264
@deprecated_function(zero_eight)
265
def show_diff(b, from_spec, specific_files, external_diff_options=None,
266
revision2=None, output=None, b2=None):
267
"""Shortcut for showing the diff to the working tree.
269
Please use show_diff_trees instead.
275
None for 'basis tree', or otherwise the old revision to compare against.
277
The more general form is show_diff_trees(), where the caller
278
supplies any two trees.
283
if from_spec is None:
284
old_tree = b.bzrdir.open_workingtree()
286
old_tree = old_tree = old_tree.basis_tree()
288
old_tree = b.repository.revision_tree(from_spec.in_history(b).rev_id)
290
if revision2 is None:
292
new_tree = b.bzrdir.open_workingtree()
294
new_tree = b2.bzrdir.open_workingtree()
296
new_tree = b.repository.revision_tree(revision2.in_history(b).rev_id)
298
return show_diff_trees(old_tree, new_tree, output, specific_files,
299
external_diff_options)
302
def diff_cmd_helper(tree, specific_files, external_diff_options,
303
old_revision_spec=None, new_revision_spec=None,
305
old_label='a/', new_label='b/'):
306
"""Helper for cmd_diff.
311
:param specific_files:
312
The specific files to compare, or None
314
:param external_diff_options:
315
If non-None, run an external diff, and pass it these options
317
:param old_revision_spec:
318
If None, use basis tree as old revision, otherwise use the tree for
319
the specified revision.
321
:param new_revision_spec:
322
If None, use working tree as new revision, otherwise use the tree for
323
the specified revision.
325
:param revision_specs:
326
Zero, one or two RevisionSpecs from the command line, saying what revisions
327
to compare. This can be passed as an alternative to the old_revision_spec
328
and new_revision_spec parameters.
330
The more general form is show_diff_trees(), where the caller
331
supplies any two trees.
334
# TODO: perhaps remove the old parameters old_revision_spec and
335
# new_revision_spec, since this is only really for use from cmd_diff and
336
# it now always passes through a sequence of revision_specs -- mbp
341
revision = spec.in_store(tree.branch)
343
revision = spec.in_store(None)
344
revision_id = revision.rev_id
345
branch = revision.branch
346
return branch.repository.revision_tree(revision_id)
280
def _get_trees_to_diff(path_list, revision_specs, old_url, new_url,
282
"""Get the trees and specific files to diff given a list of paths.
284
This method works out the trees to be diff'ed and the files of
285
interest within those trees.
288
the list of arguments passed to the diff command
289
:param revision_specs:
290
Zero, one or two RevisionSpecs from the diff command line,
291
saying what revisions to compare.
293
The url of the old branch or tree. If None, the tree to use is
294
taken from the first path, if any, or the current working tree.
296
The url of the new branch or tree. If None, the tree to use is
297
taken from the first path, if any, or the current working tree.
299
if True and a view is set, apply the view or check that the paths
302
a tuple of (old_tree, new_tree, specific_files, extra_trees) where
303
extra_trees is a sequence of additional trees to search in for
306
# Get the old and new revision specs
307
old_revision_spec = None
308
new_revision_spec = None
348
309
if revision_specs is not None:
349
assert (old_revision_spec is None
350
and new_revision_spec is None)
351
310
if len(revision_specs) > 0:
352
311
old_revision_spec = revision_specs[0]
313
old_url = old_revision_spec.get_branch()
353
314
if len(revision_specs) > 1:
354
315
new_revision_spec = revision_specs[1]
356
if old_revision_spec is None:
357
old_tree = tree.basis_tree()
359
old_tree = spec_tree(old_revision_spec)
361
if (new_revision_spec is None
362
or new_revision_spec.spec is None):
365
new_tree = spec_tree(new_revision_spec)
367
if new_tree is not tree:
368
extra_trees = (tree,)
372
return show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
373
external_diff_options,
374
old_label=old_label, new_label=new_label,
375
extra_trees=extra_trees)
317
new_url = new_revision_spec.get_branch()
320
make_paths_wt_relative = True
321
consider_relpath = True
322
if path_list is None or len(path_list) == 0:
323
# If no path is given, the current working tree is used
324
default_location = u'.'
325
consider_relpath = False
326
elif old_url is not None and new_url is not None:
327
other_paths = path_list
328
make_paths_wt_relative = False
330
default_location = path_list[0]
331
other_paths = path_list[1:]
333
# Get the old location
336
old_url = default_location
337
working_tree, branch, relpath = \
338
bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
339
if consider_relpath and relpath != '':
340
if working_tree is not None and apply_view:
341
views.check_path_in_view(working_tree, relpath)
342
specific_files.append(relpath)
343
old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
345
# Get the new location
347
new_url = default_location
348
if new_url != old_url:
349
working_tree, branch, relpath = \
350
bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
351
if consider_relpath and relpath != '':
352
if working_tree is not None and apply_view:
353
views.check_path_in_view(working_tree, relpath)
354
specific_files.append(relpath)
355
new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
356
basis_is_default=working_tree is None)
358
# Get the specific files (all files is None, no files is [])
359
if make_paths_wt_relative and working_tree is not None:
361
from bzrlib.builtins import safe_relpath_files
362
other_paths = safe_relpath_files(working_tree, other_paths,
363
apply_view=apply_view)
364
except errors.FileInWrongBranch:
365
raise errors.BzrCommandError("Files are in different branches")
366
specific_files.extend(other_paths)
367
if len(specific_files) == 0:
368
specific_files = None
369
if (working_tree is not None and working_tree.supports_views()
371
view_files = working_tree.views.lookup_view()
373
specific_files = view_files
374
view_str = views.view_display_str(view_files)
375
note("*** Ignoring files outside view. View is %s" % view_str)
377
# Get extra trees that ought to be searched for file-ids
379
if working_tree is not None and working_tree not in (old_tree, new_tree):
380
extra_trees = (working_tree,)
381
return old_tree, new_tree, specific_files, extra_trees
383
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
384
if branch is None and tree is not None:
386
if spec is None or spec.spec is None:
389
return tree.basis_tree()
391
return branch.basis_tree()
394
return spec.as_tree(branch)
378
397
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
379
398
external_diff_options=None,
380
399
old_label='a/', new_label='b/',
401
path_encoding='utf8',
382
403
"""Show in text form the changes from one tree to another.
385
If set, include only changes to these files.
409
Include only changes to these files - None for all changes.
387
411
external_diff_options
388
412
If set, use an external GNU diff and pass these options.
391
415
If set, more Trees to use for looking up file ids
418
If set, the path will be encoded as specified, otherwise is supposed
393
421
old_tree.lock_read()
410
439
old_tree.unlock()
413
def _show_diff_trees(old_tree, new_tree, to_file,
414
specific_files, external_diff_options,
415
old_label='a/', new_label='b/', extra_trees=None):
417
# GNU Patch uses the epoch date to detect files that are being added
418
# or removed in a diff.
419
EPOCH_DATE = '1970-01-01 00:00:00 +0000'
421
# TODO: Generation of pseudo-diffs for added/deleted files could
422
# be usefully made into a much faster special case.
424
if external_diff_options:
425
assert isinstance(external_diff_options, basestring)
426
opts = external_diff_options.split()
427
def diff_file(olab, olines, nlab, nlines, to_file):
428
external_diff(olab, olines, nlab, nlines, to_file, opts)
430
diff_file = internal_diff
432
delta = new_tree.changes_from(old_tree,
433
specific_files=specific_files,
434
extra_trees=extra_trees, require_versioned=True)
437
for path, file_id, kind in delta.removed:
439
print >>to_file, '=== removed %s %r' % (kind, path.encode('utf8'))
440
old_name = '%s%s\t%s' % (old_label, path,
441
_patch_header_date(old_tree, file_id, path))
442
new_name = '%s%s\t%s' % (new_label, path, EPOCH_DATE)
443
old_tree.inventory[file_id].diff(diff_file, old_name, old_tree,
444
new_name, None, None, to_file)
445
for path, file_id, kind in delta.added:
447
print >>to_file, '=== added %s %r' % (kind, path.encode('utf8'))
448
old_name = '%s%s\t%s' % (old_label, path, EPOCH_DATE)
449
new_name = '%s%s\t%s' % (new_label, path,
450
_patch_header_date(new_tree, file_id, path))
451
new_tree.inventory[file_id].diff(diff_file, new_name, new_tree,
452
old_name, None, None, to_file,
454
for (old_path, new_path, file_id, kind,
455
text_modified, meta_modified) in delta.renamed:
457
prop_str = get_prop_change(meta_modified)
458
print >>to_file, '=== renamed %s %r => %r%s' % (
459
kind, old_path.encode('utf8'),
460
new_path.encode('utf8'), prop_str)
461
old_name = '%s%s\t%s' % (old_label, old_path,
462
_patch_header_date(old_tree, file_id,
464
new_name = '%s%s\t%s' % (new_label, new_path,
465
_patch_header_date(new_tree, file_id,
467
_maybe_diff_file_or_symlink(old_name, old_tree, file_id,
469
text_modified, kind, to_file, diff_file)
470
for path, file_id, kind, text_modified, meta_modified in delta.modified:
472
prop_str = get_prop_change(meta_modified)
473
print >>to_file, '=== modified %s %r%s' % (kind, path.encode('utf8'), prop_str)
474
# The file may be in a different location in the old tree (because
475
# the containing dir was renamed, but the file itself was not)
476
old_path = old_tree.id2path(file_id)
477
old_name = '%s%s\t%s' % (old_label, old_path,
478
_patch_header_date(old_tree, file_id, old_path))
479
new_name = '%s%s\t%s' % (new_label, path,
480
_patch_header_date(new_tree, file_id, path))
482
_maybe_diff_file_or_symlink(old_name, old_tree, file_id,
484
True, kind, to_file, diff_file)
489
442
def _patch_header_date(tree, file_id, path):
490
443
"""Returns a timestamp suitable for use in a patch header."""
491
444
mtime = tree.get_file_mtime(file_id, path)
492
assert mtime is not None, \
493
"got an mtime of None for file-id %s, path %s in tree %s" % (
495
445
return timestamp.format_patch_date(mtime)
498
def _raise_if_nonexistent(paths, old_tree, new_tree):
499
"""Complain if paths are not in either inventory or tree.
501
It's OK with the files exist in either tree's inventory, or
502
if they exist in the tree but are not versioned.
504
This can be used by operations such as bzr status that can accept
505
unknown or ignored files.
507
mutter("check paths: %r", paths)
510
s = old_tree.filter_unversioned_files(paths)
511
s = new_tree.filter_unversioned_files(s)
512
s = [path for path in s if not new_tree.has_filename(path)]
514
raise errors.PathsDoNotExist(sorted(s))
517
def get_prop_change(meta_modified):
519
return " (properties changed)"
448
def get_executable_change(old_is_x, new_is_x):
449
descr = { True:"+x", False:"-x", None:"??" }
450
if old_is_x != new_is_x:
451
return ["%s to %s" % (descr[old_is_x], descr[new_is_x],)]
524
def _maybe_diff_file_or_symlink(old_path, old_tree, file_id,
525
new_path, new_tree, text_modified,
526
kind, to_file, diff_file):
528
new_entry = new_tree.inventory[file_id]
529
old_tree.inventory[file_id].diff(diff_file,
456
class DiffPath(object):
457
"""Base type for command object that compare files"""
459
# The type or contents of the file were unsuitable for diffing
460
CANNOT_DIFF = 'CANNOT_DIFF'
461
# The file has changed in a semantic way
463
# The file content may have changed, but there is no semantic change
464
UNCHANGED = 'UNCHANGED'
466
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8'):
469
:param old_tree: The tree to show as the old tree in the comparison
470
:param new_tree: The tree to show as new in the comparison
471
:param to_file: The file to write comparison data to
472
:param path_encoding: The character encoding to write paths in
474
self.old_tree = old_tree
475
self.new_tree = new_tree
476
self.to_file = to_file
477
self.path_encoding = path_encoding
483
def from_diff_tree(klass, diff_tree):
484
return klass(diff_tree.old_tree, diff_tree.new_tree,
485
diff_tree.to_file, diff_tree.path_encoding)
488
def _diff_many(differs, file_id, old_path, new_path, old_kind, new_kind):
489
for file_differ in differs:
490
result = file_differ.diff(file_id, old_path, new_path, old_kind,
492
if result is not DiffPath.CANNOT_DIFF:
495
return DiffPath.CANNOT_DIFF
498
class DiffKindChange(object):
499
"""Special differ for file kind changes.
501
Represents kind change as deletion + creation. Uses the other differs
504
def __init__(self, differs):
505
self.differs = differs
511
def from_diff_tree(klass, diff_tree):
512
return klass(diff_tree.differs)
514
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
515
"""Perform comparison
517
:param file_id: The file_id of the file to compare
518
:param old_path: Path of the file in the old tree
519
:param new_path: Path of the file in the new tree
520
:param old_kind: Old file-kind of the file
521
:param new_kind: New file-kind of the file
523
if None in (old_kind, new_kind):
524
return DiffPath.CANNOT_DIFF
525
result = DiffPath._diff_many(self.differs, file_id, old_path,
526
new_path, old_kind, None)
527
if result is DiffPath.CANNOT_DIFF:
529
return DiffPath._diff_many(self.differs, file_id, old_path, new_path,
533
class DiffDirectory(DiffPath):
535
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
536
"""Perform comparison between two directories. (dummy)
539
if 'directory' not in (old_kind, new_kind):
540
return self.CANNOT_DIFF
541
if old_kind not in ('directory', None):
542
return self.CANNOT_DIFF
543
if new_kind not in ('directory', None):
544
return self.CANNOT_DIFF
548
class DiffSymlink(DiffPath):
550
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
551
"""Perform comparison between two symlinks
553
:param file_id: The file_id of the file to compare
554
:param old_path: Path of the file in the old tree
555
:param new_path: Path of the file in the new tree
556
:param old_kind: Old file-kind of the file
557
:param new_kind: New file-kind of the file
559
if 'symlink' not in (old_kind, new_kind):
560
return self.CANNOT_DIFF
561
if old_kind == 'symlink':
562
old_target = self.old_tree.get_symlink_target(file_id)
563
elif old_kind is None:
566
return self.CANNOT_DIFF
567
if new_kind == 'symlink':
568
new_target = self.new_tree.get_symlink_target(file_id)
569
elif new_kind is None:
572
return self.CANNOT_DIFF
573
return self.diff_symlink(old_target, new_target)
575
def diff_symlink(self, old_target, new_target):
576
if old_target is None:
577
self.to_file.write('=== target is %r\n' % new_target)
578
elif new_target is None:
579
self.to_file.write('=== target was %r\n' % old_target)
581
self.to_file.write('=== target changed %r => %r\n' %
582
(old_target, new_target))
586
class DiffText(DiffPath):
588
# GNU Patch uses the epoch date to detect files that are being added
589
# or removed in a diff.
590
EPOCH_DATE = '1970-01-01 00:00:00 +0000'
592
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
593
old_label='', new_label='', text_differ=internal_diff):
594
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
595
self.text_differ = text_differ
596
self.old_label = old_label
597
self.new_label = new_label
598
self.path_encoding = path_encoding
600
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
601
"""Compare two files in unified diff format
603
:param file_id: The file_id of the file to compare
604
:param old_path: Path of the file in the old tree
605
:param new_path: Path of the file in the new tree
606
:param old_kind: Old file-kind of the file
607
:param new_kind: New file-kind of the file
609
if 'file' not in (old_kind, new_kind):
610
return self.CANNOT_DIFF
611
from_file_id = to_file_id = file_id
612
if old_kind == 'file':
613
old_date = _patch_header_date(self.old_tree, file_id, old_path)
614
elif old_kind is None:
615
old_date = self.EPOCH_DATE
618
return self.CANNOT_DIFF
619
if new_kind == 'file':
620
new_date = _patch_header_date(self.new_tree, file_id, new_path)
621
elif new_kind is None:
622
new_date = self.EPOCH_DATE
625
return self.CANNOT_DIFF
626
from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
627
to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
628
return self.diff_text(from_file_id, to_file_id, from_label, to_label,
631
def diff_text(self, from_file_id, to_file_id, from_label, to_label,
632
from_path=None, to_path=None):
633
"""Diff the content of given files in two trees
635
:param from_file_id: The id of the file in the from tree. If None,
636
the file is not present in the from tree.
637
:param to_file_id: The id of the file in the to tree. This may refer
638
to a different file from from_file_id. If None,
639
the file is not present in the to tree.
640
:param from_path: The path in the from tree or None if unknown.
641
:param to_path: The path in the to tree or None if unknown.
643
def _get_text(tree, file_id, path):
644
if file_id is not None:
645
return tree.get_file(file_id, path).readlines()
649
from_text = _get_text(self.old_tree, from_file_id, from_path)
650
to_text = _get_text(self.new_tree, to_file_id, to_path)
651
self.text_differ(from_label, from_text, to_label, to_text,
653
except errors.BinaryFile:
655
("Binary files %s and %s differ\n" %
656
(from_label, to_label)).encode(self.path_encoding))
660
class DiffFromTool(DiffPath):
662
def __init__(self, command_template, old_tree, new_tree, to_file,
663
path_encoding='utf-8'):
664
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
665
self.command_template = command_template
666
self._root = osutils.mkdtemp(prefix='bzr-diff-')
669
def from_string(klass, command_string, old_tree, new_tree, to_file,
670
path_encoding='utf-8'):
671
command_template = commands.shlex_split_unicode(command_string)
672
command_template.extend(['%(old_path)s', '%(new_path)s'])
673
return klass(command_template, old_tree, new_tree, to_file,
677
def make_from_diff_tree(klass, command_string):
678
def from_diff_tree(diff_tree):
679
return klass.from_string(command_string, diff_tree.old_tree,
680
diff_tree.new_tree, diff_tree.to_file)
681
return from_diff_tree
683
def _get_command(self, old_path, new_path):
684
my_map = {'old_path': old_path, 'new_path': new_path}
685
return [t % my_map for t in self.command_template]
687
def _execute(self, old_path, new_path):
688
command = self._get_command(old_path, new_path)
690
proc = subprocess.Popen(command, stdout=subprocess.PIPE,
693
if e.errno == errno.ENOENT:
694
raise errors.ExecutableMissing(command[0])
697
self.to_file.write(proc.stdout.read())
700
def _try_symlink_root(self, tree, prefix):
701
if (getattr(tree, 'abspath', None) is None
702
or not osutils.host_os_dereferences_symlinks()):
705
os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
707
if e.errno != errno.EEXIST:
711
def _write_file(self, file_id, tree, prefix, relpath):
712
full_path = osutils.pathjoin(self._root, prefix, relpath)
713
if self._try_symlink_root(tree, prefix):
715
parent_dir = osutils.dirname(full_path)
717
os.makedirs(parent_dir)
719
if e.errno != errno.EEXIST:
721
source = tree.get_file(file_id, relpath)
723
target = open(full_path, 'wb')
725
osutils.pumpfile(source, target)
730
osutils.make_readonly(full_path)
731
mtime = tree.get_file_mtime(file_id)
732
os.utime(full_path, (mtime, mtime))
735
def _prepare_files(self, file_id, old_path, new_path):
736
old_disk_path = self._write_file(file_id, self.old_tree, 'old',
738
new_disk_path = self._write_file(file_id, self.new_tree, 'new',
740
return old_disk_path, new_disk_path
744
osutils.rmtree(self._root)
746
if e.errno != errno.ENOENT:
747
mutter("The temporary directory \"%s\" was not "
748
"cleanly removed: %s." % (self._root, e))
750
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
751
if (old_kind, new_kind) != ('file', 'file'):
752
return DiffPath.CANNOT_DIFF
753
self._prepare_files(file_id, old_path, new_path)
754
self._execute(osutils.pathjoin('old', old_path),
755
osutils.pathjoin('new', new_path))
758
class DiffTree(object):
759
"""Provides textual representations of the difference between two trees.
761
A DiffTree examines two trees and where a file-id has altered
762
between them, generates a textual representation of the difference.
763
DiffTree uses a sequence of DiffPath objects which are each
764
given the opportunity to handle a given altered fileid. The list
765
of DiffPath objects can be extended globally by appending to
766
DiffTree.diff_factories, or for a specific diff operation by
767
supplying the extra_factories option to the appropriate method.
770
# list of factories that can provide instances of DiffPath objects
771
# may be extended by plugins.
772
diff_factories = [DiffSymlink.from_diff_tree,
773
DiffDirectory.from_diff_tree]
775
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
776
diff_text=None, extra_factories=None):
779
:param old_tree: Tree to show as old in the comparison
780
:param new_tree: Tree to show as new in the comparison
781
:param to_file: File to write comparision to
782
:param path_encoding: Character encoding to write paths in
783
:param diff_text: DiffPath-type object to use as a last resort for
785
:param extra_factories: Factories of DiffPaths to try before any other
787
if diff_text is None:
788
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
789
'', '', internal_diff)
790
self.old_tree = old_tree
791
self.new_tree = new_tree
792
self.to_file = to_file
793
self.path_encoding = path_encoding
795
if extra_factories is not None:
796
self.differs.extend(f(self) for f in extra_factories)
797
self.differs.extend(f(self) for f in self.diff_factories)
798
self.differs.extend([diff_text, DiffKindChange.from_diff_tree(self)])
801
def from_trees_options(klass, old_tree, new_tree, to_file,
802
path_encoding, external_diff_options, old_label,
804
"""Factory for producing a DiffTree.
806
Designed to accept options used by show_diff_trees.
807
:param old_tree: The tree to show as old in the comparison
808
:param new_tree: The tree to show as new in the comparison
809
:param to_file: File to write comparisons to
810
:param path_encoding: Character encoding to use for writing paths
811
:param external_diff_options: If supplied, use the installed diff
812
binary to perform file comparison, using supplied options.
813
:param old_label: Prefix to use for old file labels
814
:param new_label: Prefix to use for new file labels
815
:param using: Commandline to use to invoke an external diff tool
817
if using is not None:
818
extra_factories = [DiffFromTool.make_from_diff_tree(using)]
821
if external_diff_options:
822
opts = external_diff_options.split()
823
def diff_file(olab, olines, nlab, nlines, to_file):
824
external_diff(olab, olines, nlab, nlines, to_file, opts)
826
diff_file = internal_diff
827
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
828
old_label, new_label, diff_file)
829
return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
832
def show_diff(self, specific_files, extra_trees=None):
833
"""Write tree diff to self.to_file
835
:param sepecific_files: the specific files to compare (recursive)
836
:param extra_trees: extra trees to use for mapping paths to file_ids
839
return self._show_diff(specific_files, extra_trees)
841
for differ in self.differs:
844
def _show_diff(self, specific_files, extra_trees):
845
# TODO: Generation of pseudo-diffs for added/deleted files could
846
# be usefully made into a much faster special case.
847
iterator = self.new_tree.iter_changes(self.old_tree,
848
specific_files=specific_files,
849
extra_trees=extra_trees,
850
require_versioned=True)
852
def changes_key(change):
853
old_path, new_path = change[1]
858
def get_encoded_path(path):
860
return path.encode(self.path_encoding, "replace")
861
for (file_id, paths, changed_content, versioned, parent, name, kind,
862
executable) in sorted(iterator, key=changes_key):
863
# The root does not get diffed, and items with no known kind (that
864
# is, missing) in both trees are skipped as well.
865
if parent == (None, None) or kind == (None, None):
867
oldpath, newpath = paths
868
oldpath_encoded = get_encoded_path(paths[0])
869
newpath_encoded = get_encoded_path(paths[1])
870
old_present = (kind[0] is not None and versioned[0])
871
new_present = (kind[1] is not None and versioned[1])
872
renamed = (parent[0], name[0]) != (parent[1], name[1])
874
properties_changed = []
875
properties_changed.extend(get_executable_change(executable[0], executable[1]))
877
if properties_changed:
878
prop_str = " (properties changed: %s)" % (", ".join(properties_changed),)
882
if (old_present, new_present) == (True, False):
883
self.to_file.write("=== removed %s '%s'\n" %
884
(kind[0], oldpath_encoded))
886
elif (old_present, new_present) == (False, True):
887
self.to_file.write("=== added %s '%s'\n" %
888
(kind[1], newpath_encoded))
891
self.to_file.write("=== renamed %s '%s' => '%s'%s\n" %
892
(kind[0], oldpath_encoded, newpath_encoded, prop_str))
894
# if it was produced by iter_changes, it must be
895
# modified *somehow*, either content or execute bit.
896
self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
897
newpath_encoded, prop_str))
899
self._diff(file_id, oldpath, newpath, kind[0], kind[1])
905
def diff(self, file_id, old_path, new_path):
906
"""Perform a diff of a single file
908
:param file_id: file-id of the file
909
:param old_path: The path of the file in the old tree
910
:param new_path: The path of the file in the new tree
913
old_kind = self.old_tree.kind(file_id)
914
except (errors.NoSuchId, errors.NoSuchFile):
917
new_kind = self.new_tree.kind(file_id)
918
except (errors.NoSuchId, errors.NoSuchFile):
920
self._diff(file_id, old_path, new_path, old_kind, new_kind)
923
def _diff(self, file_id, old_path, new_path, old_kind, new_kind):
924
result = DiffPath._diff_many(self.differs, file_id, old_path,
925
new_path, old_kind, new_kind)
926
if result is DiffPath.CANNOT_DIFF:
927
error_path = new_path
928
if error_path is None:
929
error_path = old_path
930
raise errors.NoDiffFound(error_path)
added
removed
bzrlib/diff.py
