207
@deprecated_function(zero_eight)
208
def show_diff(b, from_spec, specific_files, external_diff_options=None,
209
revision2=None, output=None, b2=None):
210
"""Shortcut for showing the diff to the working tree.
212
Please use show_diff_trees instead.
218
None for 'basis tree', or otherwise the old revision to compare against.
220
The more general form is show_diff_trees(), where the caller
221
supplies any two trees.
226
if from_spec is None:
227
old_tree = b.bzrdir.open_workingtree()
229
old_tree = old_tree = old_tree.basis_tree()
231
old_tree = b.repository.revision_tree(from_spec.in_history(b).rev_id)
233
if revision2 is None:
235
new_tree = b.bzrdir.open_workingtree()
237
new_tree = b2.bzrdir.open_workingtree()
239
new_tree = b.repository.revision_tree(revision2.in_history(b).rev_id)
241
return show_diff_trees(old_tree, new_tree, output, specific_files,
242
external_diff_options)
245
def diff_cmd_helper(tree, specific_files, external_diff_options,
246
old_revision_spec=None, new_revision_spec=None,
247
old_label='a/', new_label='b/'):
248
"""Helper for cmd_diff.
254
The specific files to compare, or None
256
external_diff_options
257
If non-None, run an external diff, and pass it these options
260
If None, use basis tree as old revision, otherwise use the tree for
261
the specified revision.
264
If None, use working tree as new revision, otherwise use the tree for
265
the specified revision.
267
The more general form is show_diff_trees(), where the caller
268
supplies any two trees.
272
revision = spec.in_store(tree.branch)
274
revision = spec.in_store(None)
275
revision_id = revision.rev_id
276
branch = revision.branch
277
return branch.repository.revision_tree(revision_id)
278
if old_revision_spec is None:
279
old_tree = tree.basis_tree()
281
old_tree = spec_tree(old_revision_spec)
283
if new_revision_spec is None:
286
new_tree = spec_tree(new_revision_spec)
287
if new_tree is not tree:
288
extra_trees = (tree,)
292
return show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
293
external_diff_options,
294
old_label=old_label, new_label=new_label,
295
extra_trees=extra_trees)
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
309
if revision_specs is not None:
310
if len(revision_specs) > 0:
311
old_revision_spec = revision_specs[0]
313
old_url = old_revision_spec.get_branch()
314
if len(revision_specs) > 1:
315
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)
298
397
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
299
398
external_diff_options=None,
300
399
old_label='a/', new_label='b/',
401
path_encoding='utf8',
302
403
"""Show in text form the changes from one tree to another.
305
If set, include only changes to these files.
409
Include only changes to these files - None for all changes.
307
411
external_diff_options
308
412
If set, use an external GNU diff and pass these options.
311
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
313
421
old_tree.lock_read()
423
if extra_trees is not None:
424
for tree in extra_trees:
315
426
new_tree.lock_read()
317
return _show_diff_trees(old_tree, new_tree, to_file,
318
specific_files, external_diff_options,
319
old_label=old_label, new_label=new_label,
320
extra_trees=extra_trees)
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)
322
434
new_tree.unlock()
435
if extra_trees is not None:
436
for tree in extra_trees:
324
439
old_tree.unlock()
327
def _show_diff_trees(old_tree, new_tree, to_file,
328
specific_files, external_diff_options,
329
old_label='a/', new_label='b/', extra_trees=None):
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):
331
588
# GNU Patch uses the epoch date to detect files that are being added
332
589
# or removed in a diff.
333
590
EPOCH_DATE = '1970-01-01 00:00:00 +0000'
335
# TODO: Generation of pseudo-diffs for added/deleted files could
336
# be usefully made into a much faster special case.
338
if external_diff_options:
339
assert isinstance(external_diff_options, basestring)
340
opts = external_diff_options.split()
341
def diff_file(olab, olines, nlab, nlines, to_file):
342
external_diff(olab, olines, nlab, nlines, to_file, opts)
344
diff_file = internal_diff
346
delta = new_tree.changes_from(old_tree,
347
specific_files=specific_files,
348
extra_trees=extra_trees, require_versioned=True)
351
for path, file_id, kind in delta.removed:
353
print >>to_file, '=== removed %s %r' % (kind, path.encode('utf8'))
354
old_name = '%s%s\t%s' % (old_label, path,
355
_patch_header_date(old_tree, file_id, path))
356
new_name = '%s%s\t%s' % (new_label, path, EPOCH_DATE)
357
old_tree.inventory[file_id].diff(diff_file, old_name, old_tree,
358
new_name, None, None, to_file)
359
for path, file_id, kind in delta.added:
361
print >>to_file, '=== added %s %r' % (kind, path.encode('utf8'))
362
old_name = '%s%s\t%s' % (old_label, path, EPOCH_DATE)
363
new_name = '%s%s\t%s' % (new_label, path,
364
_patch_header_date(new_tree, file_id, path))
365
new_tree.inventory[file_id].diff(diff_file, new_name, new_tree,
366
old_name, None, None, to_file,
368
for (old_path, new_path, file_id, kind,
369
text_modified, meta_modified) in delta.renamed:
371
prop_str = get_prop_change(meta_modified)
372
print >>to_file, '=== renamed %s %r => %r%s' % (
373
kind, old_path.encode('utf8'),
374
new_path.encode('utf8'), prop_str)
375
old_name = '%s%s\t%s' % (old_label, old_path,
376
_patch_header_date(old_tree, file_id,
378
new_name = '%s%s\t%s' % (new_label, new_path,
379
_patch_header_date(new_tree, file_id,
381
_maybe_diff_file_or_symlink(old_name, old_tree, file_id,
383
text_modified, kind, to_file, diff_file)
384
for path, file_id, kind, text_modified, meta_modified in delta.modified:
386
prop_str = get_prop_change(meta_modified)
387
print >>to_file, '=== modified %s %r%s' % (kind, path.encode('utf8'), prop_str)
388
old_name = '%s%s\t%s' % (old_label, path,
389
_patch_header_date(old_tree, file_id, path))
390
new_name = '%s%s\t%s' % (new_label, path,
391
_patch_header_date(new_tree, file_id, path))
393
_maybe_diff_file_or_symlink(old_name, old_tree, file_id,
395
True, kind, to_file, diff_file)
400
def _patch_header_date(tree, file_id, path):
401
"""Returns a timestamp suitable for use in a patch header."""
402
tm = time.gmtime(tree.get_file_mtime(file_id, path))
403
return time.strftime('%Y-%m-%d %H:%M:%S +0000', tm)
406
def _raise_if_nonexistent(paths, old_tree, new_tree):
407
"""Complain if paths are not in either inventory or tree.
409
It's OK with the files exist in either tree's inventory, or
410
if they exist in the tree but are not versioned.
412
This can be used by operations such as bzr status that can accept
413
unknown or ignored files.
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.
415
mutter("check paths: %r", paths)
418
s = old_tree.filter_unversioned_files(paths)
419
s = new_tree.filter_unversioned_files(s)
420
s = [path for path in s if not new_tree.has_filename(path)]
422
raise errors.PathsDoNotExist(sorted(s))
425
def get_prop_change(meta_modified):
427
return " (properties changed)"
432
def _maybe_diff_file_or_symlink(old_path, old_tree, file_id,
433
new_path, new_tree, text_modified,
434
kind, to_file, diff_file):
436
new_entry = new_tree.inventory[file_id]
437
old_tree.inventory[file_id].diff(diff_file,
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)