1
# Copyright (C) 2004, 2005, 2006 Canonical Ltd.
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
from bzrlib.lazy_import import lazy_import
24
lazy_import(globals(), """
31
branch as _mod_branch,
43
from bzrlib.symbol_versioning import (
46
from bzrlib.trace import mutter, note, warning
49
# TODO: Rather than building a changeset object, we should probably
50
# invoke callbacks on an object. That object can either accumulate a
51
# list, write them out directly, etc etc.
54
class _PrematchedMatcher(difflib.SequenceMatcher):
55
"""Allow SequenceMatcher operations to use predetermined blocks"""
57
def __init__(self, matching_blocks):
58
difflib.SequenceMatcher(self, None, None)
59
self.matching_blocks = matching_blocks
63
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
64
allow_binary=False, sequence_matcher=None,
65
path_encoding='utf8'):
66
# FIXME: difflib is wrong if there is no trailing newline.
67
# The syntax used by patch seems to be "\ No newline at
68
# end of file" following the last diff line from that
69
# file. This is not trivial to insert into the
70
# unified_diff output and it might be better to just fix
71
# or replace that function.
73
# In the meantime we at least make sure the patch isn't
77
# Special workaround for Python2.3, where difflib fails if
78
# both sequences are empty.
79
if not oldlines and not newlines:
82
if allow_binary is False:
83
textfile.check_text_lines(oldlines)
84
textfile.check_text_lines(newlines)
86
if sequence_matcher is None:
87
sequence_matcher = patiencediff.PatienceSequenceMatcher
88
ud = patiencediff.unified_diff(oldlines, newlines,
89
fromfile=old_filename.encode(path_encoding),
90
tofile=new_filename.encode(path_encoding),
91
sequencematcher=sequence_matcher)
94
if len(ud) == 0: # Identical contents, nothing to do
96
# work-around for difflib being too smart for its own good
97
# if /dev/null is "1,0", patch won't recognize it as /dev/null
99
ud[2] = ud[2].replace('-1,0', '-0,0')
101
ud[2] = ud[2].replace('+1,0', '+0,0')
105
if not line.endswith('\n'):
106
to_file.write("\n\\ No newline at end of file\n")
110
def _spawn_external_diff(diffcmd, capture_errors=True):
111
"""Spawn the externall diff process, and return the child handle.
113
:param diffcmd: The command list to spawn
114
:param capture_errors: Capture stderr as well as setting LANG=C
115
and LC_ALL=C. This lets us read and understand the output of diff,
116
and respond to any errors.
117
:return: A Popen object.
120
# construct minimal environment
122
path = os.environ.get('PATH')
125
env['LANGUAGE'] = 'C' # on win32 only LANGUAGE has effect
128
stderr = subprocess.PIPE
134
pipe = subprocess.Popen(diffcmd,
135
stdin=subprocess.PIPE,
136
stdout=subprocess.PIPE,
140
if e.errno == errno.ENOENT:
141
raise errors.NoDiff(str(e))
147
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
149
"""Display a diff by calling out to the external diff program."""
150
# make sure our own output is properly ordered before the diff
153
oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
154
newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
155
oldtmpf = os.fdopen(oldtmp_fd, 'wb')
156
newtmpf = os.fdopen(newtmp_fd, 'wb')
159
# TODO: perhaps a special case for comparing to or from the empty
160
# sequence; can just use /dev/null on Unix
162
# TODO: if either of the files being compared already exists as a
163
# regular named file (e.g. in the working directory) then we can
164
# compare directly to that, rather than copying it.
166
oldtmpf.writelines(oldlines)
167
newtmpf.writelines(newlines)
174
if sys.platform == 'win32':
175
# Popen doesn't do the proper encoding for external commands
176
# Since we are dealing with an ANSI api, use mbcs encoding
177
old_filename = old_filename.encode('mbcs')
178
new_filename = new_filename.encode('mbcs')
180
'--label', old_filename,
182
'--label', new_filename,
187
# diff only allows one style to be specified; they don't override.
188
# note that some of these take optargs, and the optargs can be
189
# directly appended to the options.
190
# this is only an approximate parser; it doesn't properly understand
192
for s in ['-c', '-u', '-C', '-U',
197
'-y', '--side-by-side',
209
diffcmd.extend(diff_opts)
211
pipe = _spawn_external_diff(diffcmd, capture_errors=True)
212
out,err = pipe.communicate()
215
# internal_diff() adds a trailing newline, add one here for consistency
218
# 'diff' gives retcode == 2 for all sorts of errors
219
# one of those is 'Binary files differ'.
220
# Bad options could also be the problem.
221
# 'Binary files' is not a real error, so we suppress that error.
224
# Since we got here, we want to make sure to give an i18n error
225
pipe = _spawn_external_diff(diffcmd, capture_errors=False)
226
out, err = pipe.communicate()
228
# Write out the new i18n diff response
229
to_file.write(out+'\n')
230
if pipe.returncode != 2:
231
raise errors.BzrError(
232
'external diff failed with exit code 2'
233
' when run with LANG=C and LC_ALL=C,'
234
' but not when run natively: %r' % (diffcmd,))
236
first_line = lang_c_out.split('\n', 1)[0]
237
# Starting with diffutils 2.8.4 the word "binary" was dropped.
238
m = re.match('^(binary )?files.*differ$', first_line, re.I)
240
raise errors.BzrError('external diff failed with exit code 2;'
241
' command: %r' % (diffcmd,))
243
# Binary files differ, just return
246
# If we got to here, we haven't written out the output of diff
250
# returns 1 if files differ; that's OK
252
msg = 'signal %d' % (-rc)
254
msg = 'exit code %d' % rc
256
raise errors.BzrError('external diff failed with %s; command: %r'
261
oldtmpf.close() # and delete
263
# Clean up. Warn in case the files couldn't be deleted
264
# (in case windows still holds the file open, but not
265
# if the files have already been deleted)
267
os.remove(old_abspath)
269
if e.errno not in (errno.ENOENT,):
270
warning('Failed to delete temporary file: %s %s',
273
os.remove(new_abspath)
275
if e.errno not in (errno.ENOENT,):
276
warning('Failed to delete temporary file: %s %s',
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)
397
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
398
external_diff_options=None,
399
old_label='a/', new_label='b/',
401
path_encoding='utf8',
403
"""Show in text form the changes from one tree to another.
409
Include only changes to these files - None for all changes.
411
external_diff_options
412
If set, use an external GNU diff and pass these options.
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
423
if extra_trees is not None:
424
for tree in 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)
435
if extra_trees is not None:
436
for tree in extra_trees:
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):
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
