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
269
@deprecated_function(zero_eight)
270
def show_diff(b, from_spec, specific_files, external_diff_options=None,
271
revision2=None, output=None, b2=None):
272
"""Shortcut for showing the diff to the working tree.
274
Please use show_diff_trees instead.
280
None for 'basis tree', or otherwise the old revision to compare against.
282
The more general form is show_diff_trees(), where the caller
283
supplies any two trees.
288
if from_spec is None:
289
old_tree = b.bzrdir.open_workingtree()
291
old_tree = old_tree = old_tree.basis_tree()
293
old_tree = b.repository.revision_tree(from_spec.in_history(b).rev_id)
295
if revision2 is None:
297
new_tree = b.bzrdir.open_workingtree()
299
new_tree = b2.bzrdir.open_workingtree()
301
new_tree = b.repository.revision_tree(revision2.in_history(b).rev_id)
303
return show_diff_trees(old_tree, new_tree, output, specific_files,
304
external_diff_options)
307
def diff_cmd_helper(tree, specific_files, external_diff_options,
308
old_revision_spec=None, new_revision_spec=None,
310
old_label='a/', new_label='b/'):
311
"""Helper for cmd_diff.
316
:param specific_files:
317
The specific files to compare, or None
319
:param external_diff_options:
320
If non-None, run an external diff, and pass it these options
322
:param old_revision_spec:
323
If None, use basis tree as old revision, otherwise use the tree for
324
the specified revision.
326
:param new_revision_spec:
327
If None, use working tree as new revision, otherwise use the tree for
328
the specified revision.
330
:param revision_specs:
331
Zero, one or two RevisionSpecs from the command line, saying what revisions
332
to compare. This can be passed as an alternative to the old_revision_spec
333
and new_revision_spec parameters.
335
The more general form is show_diff_trees(), where the caller
336
supplies any two trees.
339
# TODO: perhaps remove the old parameters old_revision_spec and
340
# new_revision_spec, since this is only really for use from cmd_diff and
341
# it now always passes through a sequence of revision_specs -- mbp
346
revision = spec.in_store(tree.branch)
348
revision = spec.in_store(None)
349
revision_id = revision.rev_id
350
branch = revision.branch
351
return branch.repository.revision_tree(revision_id)
309
353
if revision_specs is not None:
354
assert (old_revision_spec is None
355
and new_revision_spec is None)
310
356
if len(revision_specs) > 0:
311
357
old_revision_spec = revision_specs[0]
313
old_url = old_revision_spec.get_branch()
314
358
if len(revision_specs) > 1:
315
359
new_revision_spec = revision_specs[1]
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)
361
if old_revision_spec is None:
362
old_tree = tree.basis_tree()
364
old_tree = spec_tree(old_revision_spec)
366
if (new_revision_spec is None
367
or new_revision_spec.spec is None):
370
new_tree = spec_tree(new_revision_spec)
372
if new_tree is not tree:
373
extra_trees = (tree,)
377
return show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
378
external_diff_options,
379
old_label=old_label, new_label=new_label,
380
extra_trees=extra_trees)
397
383
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
398
384
external_diff_options=None,
399
385
old_label='a/', new_label='b/',
401
path_encoding='utf8',
403
387
"""Show in text form the changes from one tree to another.
409
Include only changes to these files - None for all changes.
390
If set, include only changes to these files.
411
392
external_diff_options
412
393
If set, use an external GNU diff and pass these options.
415
396
If set, more Trees to use for looking up file ids
418
If set, the path will be encoded as specified, otherwise is supposed
421
398
old_tree.lock_read()
423
if extra_trees is not None:
424
for tree in extra_trees:
426
400
new_tree.lock_read()
428
differ = DiffTree.from_trees_options(old_tree, new_tree, to_file,
430
external_diff_options,
431
old_label, new_label, using)
432
return differ.show_diff(specific_files, extra_trees)
402
return _show_diff_trees(old_tree, new_tree, to_file,
403
specific_files, external_diff_options,
404
old_label=old_label, new_label=new_label,
405
extra_trees=extra_trees)
434
407
new_tree.unlock()
435
if extra_trees is not None:
436
for tree in extra_trees:
439
409
old_tree.unlock()
442
def _patch_header_date(tree, file_id, path):
443
"""Returns a timestamp suitable for use in a patch header."""
444
mtime = tree.get_file_mtime(file_id, path)
445
return timestamp.format_patch_date(mtime)
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],)]
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):
412
def _show_diff_trees(old_tree, new_tree, to_file,
413
specific_files, external_diff_options,
414
old_label='a/', new_label='b/', extra_trees=None):
588
416
# GNU Patch uses the epoch date to detect files that are being added
589
417
# or removed in a diff.
590
418
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.
420
# TODO: Generation of pseudo-diffs for added/deleted files could
421
# be usefully made into a much faster special case.
423
if external_diff_options:
424
assert isinstance(external_diff_options, basestring)
425
opts = external_diff_options.split()
426
def diff_file(olab, olines, nlab, nlines, to_file):
427
external_diff(olab, olines, nlab, nlines, to_file, opts)
429
diff_file = internal_diff
431
delta = new_tree.changes_from(old_tree,
432
specific_files=specific_files,
433
extra_trees=extra_trees, require_versioned=True)
436
for path, file_id, kind in delta.removed:
438
print >>to_file, '=== removed %s %r' % (kind, path.encode('utf8'))
439
old_name = '%s%s\t%s' % (old_label, path,
440
_patch_header_date(old_tree, file_id, path))
441
new_name = '%s%s\t%s' % (new_label, path, EPOCH_DATE)
442
old_tree.inventory[file_id].diff(diff_file, old_name, old_tree,
443
new_name, None, None, to_file)
444
for path, file_id, kind in delta.added:
446
print >>to_file, '=== added %s %r' % (kind, path.encode('utf8'))
447
old_name = '%s%s\t%s' % (old_label, path, EPOCH_DATE)
448
new_name = '%s%s\t%s' % (new_label, path,
449
_patch_header_date(new_tree, file_id, path))
450
new_tree.inventory[file_id].diff(diff_file, new_name, new_tree,
451
old_name, None, None, to_file,
453
for (old_path, new_path, file_id, kind,
454
text_modified, meta_modified) in delta.renamed:
456
prop_str = get_prop_change(meta_modified)
457
print >>to_file, '=== renamed %s %r => %r%s' % (
458
kind, old_path.encode('utf8'),
459
new_path.encode('utf8'), prop_str)
460
old_name = '%s%s\t%s' % (old_label, old_path,
461
_patch_header_date(old_tree, file_id,
463
new_name = '%s%s\t%s' % (new_label, new_path,
464
_patch_header_date(new_tree, file_id,
466
_maybe_diff_file_or_symlink(old_name, old_tree, file_id,
468
text_modified, kind, to_file, diff_file)
469
for path, file_id, kind, text_modified, meta_modified in delta.modified:
471
prop_str = get_prop_change(meta_modified)
472
print >>to_file, '=== modified %s %r%s' % (kind, path.encode('utf8'), prop_str)
473
old_name = '%s%s\t%s' % (old_label, path,
474
_patch_header_date(old_tree, file_id, path))
475
new_name = '%s%s\t%s' % (new_label, path,
476
_patch_header_date(new_tree, file_id, path))
478
_maybe_diff_file_or_symlink(old_name, old_tree, file_id,
480
True, kind, to_file, diff_file)
485
def _patch_header_date(tree, file_id, path):
486
"""Returns a timestamp suitable for use in a patch header."""
487
tm = time.gmtime(tree.get_file_mtime(file_id, path))
488
return time.strftime('%Y-%m-%d %H:%M:%S +0000', tm)
491
def _raise_if_nonexistent(paths, old_tree, new_tree):
492
"""Complain if paths are not in either inventory or tree.
494
It's OK with the files exist in either tree's inventory, or
495
if they exist in the tree but are not versioned.
497
This can be used by operations such as bzr status that can accept
498
unknown or ignored files.
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)
500
mutter("check paths: %r", paths)
503
s = old_tree.filter_unversioned_files(paths)
504
s = new_tree.filter_unversioned_files(s)
505
s = [path for path in s if not new_tree.has_filename(path)]
507
raise errors.PathsDoNotExist(sorted(s))
510
def get_prop_change(meta_modified):
512
return " (properties changed)"
517
def _maybe_diff_file_or_symlink(old_path, old_tree, file_id,
518
new_path, new_tree, text_modified,
519
kind, to_file, diff_file):
521
new_entry = new_tree.inventory[file_id]
522
old_tree.inventory[file_id].diff(diff_file,
added
removed
bzrlib/diff.py
