1
# Copyright (C) 2004, 2005, 2006 Canonical Ltd.
2
# -*- coding: UTF-8 -*-
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
5
6
# the Free Software Foundation; either version 2 of the License, or
6
7
# (at your option) any later version.
8
9
# This program is distributed in the hope that it will be useful,
9
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
12
# GNU General Public License for more details.
13
14
# You should have received a copy of the GNU General Public License
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23
from bzrlib.lazy_import import lazy_import
24
lazy_import(globals(), """
31
branch as _mod_branch,
42
from bzrlib.symbol_versioning import (
46
from bzrlib.trace import 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.
20
from trace import mutter
24
def diff_trees(old_tree, new_tree):
25
"""Compute diff between two trees.
27
They may be in different branches and may be working or historical
30
Yields a sequence of (state, id, old_name, new_name, kind).
31
Each filename and each id is listed only once.
120
# construct minimal environment
122
path = os.environ.get('PATH')
125
env['LANGUAGE'] = 'C' # on win32 only LANGUAGE has effect
128
stderr = subprocess.PIPE
34
## TODO: Compare files before diffing; only mention those that have changed
36
## TODO: Set nice names in the headers, maybe include diffstat
38
## TODO: Perhaps make this a generator rather than using
41
## TODO: Allow specifying a list of files to compare, rather than
42
## doing the whole tree? (Not urgent.)
44
## TODO: Allow diffing any two inventories, not just the
45
## current one against one. We mgiht need to specify two
46
## stores to look for the files if diffing two branches. That
47
## might imply this shouldn't be primarily a Branch method.
49
## XXX: This doesn't report on unknown files; that can be done
50
## from a separate method.
52
old_it = old_tree.list_files()
53
new_it = new_tree.list_files()
61
old_item = next(old_it)
62
new_item = next(new_it)
64
# We step through the two sorted iterators in parallel, trying to
67
while (old_item != None) or (new_item != None):
68
# OK, we still have some remaining on both, but they may be
71
old_name, old_class, old_kind, old_id = old_item
76
new_name, new_class, new_kind, new_id = new_item
80
mutter(" diff pairwise %r" % (old_item,))
81
mutter(" %r" % (new_item,))
84
# can't handle the old tree being a WorkingTree
85
assert old_class == 'V'
87
if new_item and (new_class != 'V'):
88
yield new_class, None, None, new_name, new_kind
89
new_item = next(new_it)
90
elif (not new_item) or (old_item and (old_name < new_name)):
91
mutter(" extra entry in old-tree sequence")
92
if new_tree.has_id(old_id):
93
# will be mentioned as renamed under new name
96
yield 'D', old_id, old_name, None, old_kind
97
old_item = next(old_it)
98
elif (not old_item) or (new_item and (new_name < old_name)):
99
mutter(" extra entry in new-tree sequence")
100
if old_tree.has_id(new_id):
101
yield 'R', new_id, old_tree.id2path(new_id), new_name, new_kind
103
yield 'A', new_id, None, new_name, new_kind
104
new_item = next(new_it)
105
elif old_id != new_id:
106
assert old_name == new_name
107
# both trees have a file of this name, but it is not the
108
# same file. in other words, the old filename has been
109
# overwritten by either a newly-added or a renamed file.
110
# (should we return something about the overwritten file?)
111
if old_tree.has_id(new_id):
112
# renaming, overlying a deleted file
113
yield 'R', new_id, old_tree.id2path(new_id), new_name, new_kind
115
yield 'A', new_id, None, new_name, new_kind
117
new_item = next(new_it)
118
old_item = next(old_it)
120
assert old_id == new_id
121
assert old_id != None
122
assert old_name == new_name
123
assert old_kind == new_kind
125
if old_kind == 'directory':
126
yield '.', new_id, old_name, new_name, new_kind
127
elif old_tree.get_file_size(old_id) != new_tree.get_file_size(old_id):
128
mutter(" file size has changed, must be different")
129
yield 'M', new_id, old_name, new_name, new_kind
130
elif old_tree.get_file_sha1(old_id) == new_tree.get_file_sha1(old_id):
131
mutter(" SHA1 indicates they're identical")
132
## assert compare_files(old_tree.get_file(i), new_tree.get_file(i))
133
yield '.', new_id, old_name, new_name, new_kind
135
mutter(" quick compare shows different")
136
yield 'M', new_id, old_name, new_name, new_kind
138
new_item = next(new_it)
139
old_item = next(old_it)
143
def show_diff(b, revision, file_list):
147
old_tree = b.basis_tree()
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)
175
'--label', old_filename,
177
'--label', new_filename,
182
# diff only allows one style to be specified; they don't override.
183
# note that some of these take optargs, and the optargs can be
184
# directly appended to the options.
185
# this is only an approximate parser; it doesn't properly understand
187
for s in ['-c', '-u', '-C', '-U',
192
'-y', '--side-by-side',
204
diffcmd.extend(diff_opts)
206
pipe = _spawn_external_diff(diffcmd, capture_errors=True)
207
out,err = pipe.communicate()
210
# internal_diff() adds a trailing newline, add one here for consistency
213
# 'diff' gives retcode == 2 for all sorts of errors
214
# one of those is 'Binary files differ'.
215
# Bad options could also be the problem.
216
# 'Binary files' is not a real error, so we suppress that error.
219
# Since we got here, we want to make sure to give an i18n error
220
pipe = _spawn_external_diff(diffcmd, capture_errors=False)
221
out, err = pipe.communicate()
223
# Write out the new i18n diff response
224
to_file.write(out+'\n')
225
if pipe.returncode != 2:
226
raise errors.BzrError(
227
'external diff failed with exit code 2'
228
' when run with LANG=C and LC_ALL=C,'
229
' but not when run natively: %r' % (diffcmd,))
231
first_line = lang_c_out.split('\n', 1)[0]
232
# Starting with diffutils 2.8.4 the word "binary" was dropped.
233
m = re.match('^(binary )?files.*differ$', first_line, re.I)
235
raise errors.BzrError('external diff failed with exit code 2;'
236
' command: %r' % (diffcmd,))
238
# Binary files differ, just return
149
old_tree = b.revision_tree(b.lookup_revision(revision))
151
new_tree = b.working_tree()
153
# TODO: Options to control putting on a prefix or suffix, perhaps as a format string
157
DEVNULL = '/dev/null'
158
# Windows users, don't panic about this filename -- it is a
159
# special signal to GNU patch that the file should be created or
160
# deleted respectively.
162
# TODO: Generation of pseudo-diffs for added/deleted files could
163
# be usefully made into a much faster special case.
165
# TODO: Better to return them in sorted order I think.
168
file_list = [b.relpath(f) for f in file_list]
170
# FIXME: If given a file list, compare only those files rather
171
# than comparing everything and then throwing stuff away.
173
for file_state, fid, old_name, new_name, kind in diff_trees(old_tree, new_tree):
175
if file_list and (new_name not in file_list):
178
# Don't show this by default; maybe do it if an option is passed
179
# idlabel = ' {%s}' % fid
182
# FIXME: Something about the diff format makes patch unhappy
183
# with newly-added files.
185
def diffit(oldlines, newlines, **kw):
187
# FIXME: difflib is wrong if there is no trailing newline.
188
# The syntax used by patch seems to be "\ No newline at
189
# end of file" following the last diff line from that
190
# file. This is not trivial to insert into the
191
# unified_diff output and it might be better to just fix
192
# or replace that function.
194
# In the meantime we at least make sure the patch isn't
198
# Special workaround for Python2.3, where difflib fails if
199
# both sequences are empty.
200
if not oldlines and not newlines:
241
# If we got to here, we haven't written out the output of diff
245
# returns 1 if files differ; that's OK
247
msg = 'signal %d' % (-rc)
249
msg = 'exit code %d' % rc
251
raise errors.BzrError('external diff failed with %s; command: %r'
256
oldtmpf.close() # and delete
258
# Clean up. Warn in case the files couldn't be deleted
259
# (in case windows still holds the file open, but not
260
# if the files have already been deleted)
262
os.remove(old_abspath)
264
if e.errno not in (errno.ENOENT,):
265
warning('Failed to delete temporary file: %s %s',
268
os.remove(new_abspath)
270
if e.errno not in (errno.ENOENT,):
271
warning('Failed to delete temporary file: %s %s',
275
def _get_trees_to_diff(path_list, revision_specs, old_url, new_url):
276
"""Get the trees and specific files to diff given a list of paths.
278
This method works out the trees to be diff'ed and the files of
279
interest within those trees.
282
the list of arguments passed to the diff command
283
:param revision_specs:
284
Zero, one or two RevisionSpecs from the diff command line,
285
saying what revisions to compare.
287
The url of the old branch or tree. If None, the tree to use is
288
taken from the first path, if any, or the current working tree.
290
The url of the new branch or tree. If None, the tree to use is
291
taken from the first path, if any, or the current working tree.
293
a tuple of (old_tree, new_tree, specific_files, extra_trees) where
294
extra_trees is a sequence of additional trees to search in for
297
# Get the old and new revision specs
298
old_revision_spec = None
299
new_revision_spec = None
300
if revision_specs is not None:
301
if len(revision_specs) > 0:
302
old_revision_spec = revision_specs[0]
304
old_url = old_revision_spec.get_branch()
305
if len(revision_specs) > 1:
306
new_revision_spec = revision_specs[1]
308
new_url = new_revision_spec.get_branch()
311
make_paths_wt_relative = True
312
consider_relpath = True
313
if path_list is None or len(path_list) == 0:
314
# If no path is given, the current working tree is used
315
default_location = u'.'
316
consider_relpath = False
317
elif old_url is not None and new_url is not None:
318
other_paths = path_list
319
make_paths_wt_relative = False
321
default_location = path_list[0]
322
other_paths = path_list[1:]
324
# Get the old location
327
old_url = default_location
328
working_tree, branch, relpath = \
329
bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
330
if consider_relpath and relpath != '':
331
specific_files.append(relpath)
332
old_tree = _get_tree_to_diff(old_revision_spec, working_tree, branch)
334
# Get the new location
336
new_url = default_location
337
if new_url != old_url:
338
working_tree, branch, relpath = \
339
bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
340
if consider_relpath and relpath != '':
341
specific_files.append(relpath)
342
new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
343
basis_is_default=working_tree is None)
345
# Get the specific files (all files is None, no files is [])
346
if make_paths_wt_relative and working_tree is not None:
347
other_paths = _relative_paths_in_tree(working_tree, other_paths)
348
specific_files.extend(other_paths)
349
if len(specific_files) == 0:
350
specific_files = None
352
# Get extra trees that ought to be searched for file-ids
354
if working_tree is not None and working_tree not in (old_tree, new_tree):
355
extra_trees = (working_tree,)
356
return old_tree, new_tree, specific_files, extra_trees
359
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
360
if branch is None and tree is not None:
362
if spec is None or spec.spec is None:
365
return tree.basis_tree()
367
return branch.basis_tree()
370
return spec.as_tree(branch)
373
def _relative_paths_in_tree(tree, paths):
374
"""Get the relative paths within a working tree.
376
Each path may be either an absolute path or a path relative to the
377
current working directory.
380
for filename in paths:
382
result.append(tree.relpath(osutils.dereference_path(filename)))
383
except errors.PathNotChild:
384
raise errors.BzrCommandError("Files are in different branches")
388
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
389
external_diff_options=None,
390
old_label='a/', new_label='b/',
392
path_encoding='utf8',
394
"""Show in text form the changes from one tree to another.
400
Include only changes to these files - None for all changes.
402
external_diff_options
403
If set, use an external GNU diff and pass these options.
406
If set, more Trees to use for looking up file ids
409
If set, the path will be encoded as specified, otherwise is supposed
414
if extra_trees is not None:
415
for tree in extra_trees:
419
differ = DiffTree.from_trees_options(old_tree, new_tree, to_file,
421
external_diff_options,
422
old_label, new_label, using)
423
return differ.show_diff(specific_files, extra_trees)
426
if extra_trees is not None:
427
for tree in extra_trees:
433
def _patch_header_date(tree, file_id, path):
434
"""Returns a timestamp suitable for use in a patch header."""
435
mtime = tree.get_file_mtime(file_id, path)
436
return timestamp.format_patch_date(mtime)
439
@deprecated_function(one_three)
440
def get_prop_change(meta_modified):
442
return " (properties changed)"
446
def get_executable_change(old_is_x, new_is_x):
447
descr = { True:"+x", False:"-x", None:"??" }
448
if old_is_x != new_is_x:
449
return ["%s to %s" % (descr[old_is_x], descr[new_is_x],)]
454
class DiffPath(object):
455
"""Base type for command object that compare files"""
457
# The type or contents of the file were unsuitable for diffing
458
CANNOT_DIFF = 'CANNOT_DIFF'
459
# The file has changed in a semantic way
461
# The file content may have changed, but there is no semantic change
462
UNCHANGED = 'UNCHANGED'
464
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8'):
467
:param old_tree: The tree to show as the old tree in the comparison
468
:param new_tree: The tree to show as new in the comparison
469
:param to_file: The file to write comparison data to
470
:param path_encoding: The character encoding to write paths in
472
self.old_tree = old_tree
473
self.new_tree = new_tree
474
self.to_file = to_file
475
self.path_encoding = path_encoding
481
def from_diff_tree(klass, diff_tree):
482
return klass(diff_tree.old_tree, diff_tree.new_tree,
483
diff_tree.to_file, diff_tree.path_encoding)
486
def _diff_many(differs, file_id, old_path, new_path, old_kind, new_kind):
487
for file_differ in differs:
488
result = file_differ.diff(file_id, old_path, new_path, old_kind,
490
if result is not DiffPath.CANNOT_DIFF:
493
return DiffPath.CANNOT_DIFF
496
class DiffKindChange(object):
497
"""Special differ for file kind changes.
499
Represents kind change as deletion + creation. Uses the other differs
502
def __init__(self, differs):
503
self.differs = differs
509
def from_diff_tree(klass, diff_tree):
510
return klass(diff_tree.differs)
512
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
513
"""Perform comparison
515
:param file_id: The file_id of the file to compare
516
:param old_path: Path of the file in the old tree
517
:param new_path: Path of the file in the new tree
518
:param old_kind: Old file-kind of the file
519
:param new_kind: New file-kind of the file
521
if None in (old_kind, new_kind):
522
return DiffPath.CANNOT_DIFF
523
result = DiffPath._diff_many(self.differs, file_id, old_path,
524
new_path, old_kind, None)
525
if result is DiffPath.CANNOT_DIFF:
527
return DiffPath._diff_many(self.differs, file_id, old_path, new_path,
531
class DiffDirectory(DiffPath):
533
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
534
"""Perform comparison between two directories. (dummy)
537
if 'directory' not in (old_kind, new_kind):
538
return self.CANNOT_DIFF
539
if old_kind not in ('directory', None):
540
return self.CANNOT_DIFF
541
if new_kind not in ('directory', None):
542
return self.CANNOT_DIFF
546
class DiffSymlink(DiffPath):
548
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
549
"""Perform comparison between two symlinks
551
:param file_id: The file_id of the file to compare
552
:param old_path: Path of the file in the old tree
553
:param new_path: Path of the file in the new tree
554
:param old_kind: Old file-kind of the file
555
:param new_kind: New file-kind of the file
557
if 'symlink' not in (old_kind, new_kind):
558
return self.CANNOT_DIFF
559
if old_kind == 'symlink':
560
old_target = self.old_tree.get_symlink_target(file_id)
561
elif old_kind is None:
564
return self.CANNOT_DIFF
565
if new_kind == 'symlink':
566
new_target = self.new_tree.get_symlink_target(file_id)
567
elif new_kind is None:
570
return self.CANNOT_DIFF
571
return self.diff_symlink(old_target, new_target)
573
def diff_symlink(self, old_target, new_target):
574
if old_target is None:
575
self.to_file.write('=== target is %r\n' % new_target)
576
elif new_target is None:
577
self.to_file.write('=== target was %r\n' % old_target)
579
self.to_file.write('=== target changed %r => %r\n' %
580
(old_target, new_target))
584
class DiffText(DiffPath):
586
# GNU Patch uses the epoch date to detect files that are being added
587
# or removed in a diff.
588
EPOCH_DATE = '1970-01-01 00:00:00 +0000'
590
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
591
old_label='', new_label='', text_differ=internal_diff):
592
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
593
self.text_differ = text_differ
594
self.old_label = old_label
595
self.new_label = new_label
596
self.path_encoding = path_encoding
598
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
599
"""Compare two files in unified diff format
601
:param file_id: The file_id of the file to compare
602
:param old_path: Path of the file in the old tree
603
:param new_path: Path of the file in the new tree
604
:param old_kind: Old file-kind of the file
605
:param new_kind: New file-kind of the file
607
if 'file' not in (old_kind, new_kind):
608
return self.CANNOT_DIFF
609
from_file_id = to_file_id = file_id
610
if old_kind == 'file':
611
old_date = _patch_header_date(self.old_tree, file_id, old_path)
612
elif old_kind is None:
613
old_date = self.EPOCH_DATE
616
return self.CANNOT_DIFF
617
if new_kind == 'file':
618
new_date = _patch_header_date(self.new_tree, file_id, new_path)
619
elif new_kind is None:
620
new_date = self.EPOCH_DATE
623
return self.CANNOT_DIFF
624
from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
625
to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
626
return self.diff_text(from_file_id, to_file_id, from_label, to_label)
628
def diff_text(self, from_file_id, to_file_id, from_label, to_label):
629
"""Diff the content of given files in two trees
631
:param from_file_id: The id of the file in the from tree. If None,
632
the file is not present in the from tree.
633
:param to_file_id: The id of the file in the to tree. This may refer
634
to a different file from from_file_id. If None,
635
the file is not present in the to tree.
637
def _get_text(tree, file_id):
638
if file_id is not None:
639
return tree.get_file(file_id).readlines()
643
from_text = _get_text(self.old_tree, from_file_id)
644
to_text = _get_text(self.new_tree, to_file_id)
645
self.text_differ(from_label, from_text, to_label, to_text,
647
except errors.BinaryFile:
649
("Binary files %s and %s differ\n" %
650
(from_label, to_label)).encode(self.path_encoding))
654
class DiffFromTool(DiffPath):
656
def __init__(self, command_template, old_tree, new_tree, to_file,
657
path_encoding='utf-8'):
658
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
659
self.command_template = command_template
660
self._root = osutils.mkdtemp(prefix='bzr-diff-')
663
def from_string(klass, command_string, old_tree, new_tree, to_file,
664
path_encoding='utf-8'):
665
command_template = commands.shlex_split_unicode(command_string)
666
command_template.extend(['%(old_path)s', '%(new_path)s'])
667
return klass(command_template, old_tree, new_tree, to_file,
671
def make_from_diff_tree(klass, command_string):
672
def from_diff_tree(diff_tree):
673
return klass.from_string(command_string, diff_tree.old_tree,
674
diff_tree.new_tree, diff_tree.to_file)
675
return from_diff_tree
677
def _get_command(self, old_path, new_path):
678
my_map = {'old_path': old_path, 'new_path': new_path}
679
return [t % my_map for t in self.command_template]
681
def _execute(self, old_path, new_path):
682
command = self._get_command(old_path, new_path)
684
proc = subprocess.Popen(command, stdout=subprocess.PIPE,
687
if e.errno == errno.ENOENT:
688
raise errors.ExecutableMissing(command[0])
691
self.to_file.write(proc.stdout.read())
694
def _try_symlink_root(self, tree, prefix):
695
if (getattr(tree, 'abspath', None) is None
696
or not osutils.host_os_dereferences_symlinks()):
699
os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
701
if e.errno != errno.EEXIST:
705
def _write_file(self, file_id, tree, prefix, relpath):
706
full_path = osutils.pathjoin(self._root, prefix, relpath)
707
if self._try_symlink_root(tree, prefix):
709
parent_dir = osutils.dirname(full_path)
711
os.makedirs(parent_dir)
713
if e.errno != errno.EEXIST:
715
source = tree.get_file(file_id, relpath)
717
target = open(full_path, 'wb')
719
osutils.pumpfile(source, target)
724
osutils.make_readonly(full_path)
725
mtime = tree.get_file_mtime(file_id)
726
os.utime(full_path, (mtime, mtime))
729
def _prepare_files(self, file_id, old_path, new_path):
730
old_disk_path = self._write_file(file_id, self.old_tree, 'old',
732
new_disk_path = self._write_file(file_id, self.new_tree, 'new',
734
return old_disk_path, new_disk_path
737
osutils.rmtree(self._root)
739
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
740
if (old_kind, new_kind) != ('file', 'file'):
741
return DiffPath.CANNOT_DIFF
742
self._prepare_files(file_id, old_path, new_path)
743
self._execute(osutils.pathjoin('old', old_path),
744
osutils.pathjoin('new', new_path))
747
class DiffTree(object):
748
"""Provides textual representations of the difference between two trees.
750
A DiffTree examines two trees and where a file-id has altered
751
between them, generates a textual representation of the difference.
752
DiffTree uses a sequence of DiffPath objects which are each
753
given the opportunity to handle a given altered fileid. The list
754
of DiffPath objects can be extended globally by appending to
755
DiffTree.diff_factories, or for a specific diff operation by
756
supplying the extra_factories option to the appropriate method.
759
# list of factories that can provide instances of DiffPath objects
760
# may be extended by plugins.
761
diff_factories = [DiffSymlink.from_diff_tree,
762
DiffDirectory.from_diff_tree]
764
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
765
diff_text=None, extra_factories=None):
768
:param old_tree: Tree to show as old in the comparison
769
:param new_tree: Tree to show as new in the comparison
770
:param to_file: File to write comparision to
771
:param path_encoding: Character encoding to write paths in
772
:param diff_text: DiffPath-type object to use as a last resort for
774
:param extra_factories: Factories of DiffPaths to try before any other
776
if diff_text is None:
777
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
778
'', '', internal_diff)
779
self.old_tree = old_tree
780
self.new_tree = new_tree
781
self.to_file = to_file
782
self.path_encoding = path_encoding
784
if extra_factories is not None:
785
self.differs.extend(f(self) for f in extra_factories)
786
self.differs.extend(f(self) for f in self.diff_factories)
787
self.differs.extend([diff_text, DiffKindChange.from_diff_tree(self)])
790
def from_trees_options(klass, old_tree, new_tree, to_file,
791
path_encoding, external_diff_options, old_label,
793
"""Factory for producing a DiffTree.
795
Designed to accept options used by show_diff_trees.
796
:param old_tree: The tree to show as old in the comparison
797
:param new_tree: The tree to show as new in the comparison
798
:param to_file: File to write comparisons to
799
:param path_encoding: Character encoding to use for writing paths
800
:param external_diff_options: If supplied, use the installed diff
801
binary to perform file comparison, using supplied options.
802
:param old_label: Prefix to use for old file labels
803
:param new_label: Prefix to use for new file labels
804
:param using: Commandline to use to invoke an external diff tool
806
if using is not None:
807
extra_factories = [DiffFromTool.make_from_diff_tree(using)]
810
if external_diff_options:
811
opts = external_diff_options.split()
812
def diff_file(olab, olines, nlab, nlines, to_file):
813
external_diff(olab, olines, nlab, nlines, to_file, opts)
815
diff_file = internal_diff
816
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
817
old_label, new_label, diff_file)
818
return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
821
def show_diff(self, specific_files, extra_trees=None):
822
"""Write tree diff to self.to_file
824
:param sepecific_files: the specific files to compare (recursive)
825
:param extra_trees: extra trees to use for mapping paths to file_ids
828
return self._show_diff(specific_files, extra_trees)
830
for differ in self.differs:
833
def _show_diff(self, specific_files, extra_trees):
834
# TODO: Generation of pseudo-diffs for added/deleted files could
835
# be usefully made into a much faster special case.
836
iterator = self.new_tree.iter_changes(self.old_tree,
837
specific_files=specific_files,
838
extra_trees=extra_trees,
839
require_versioned=True)
841
def changes_key(change):
842
old_path, new_path = change[1]
847
def get_encoded_path(path):
849
return path.encode(self.path_encoding, "replace")
850
for (file_id, paths, changed_content, versioned, parent, name, kind,
851
executable) in sorted(iterator, key=changes_key):
852
# The root does not get diffed, and items with no known kind (that
853
# is, missing) in both trees are skipped as well.
854
if parent == (None, None) or kind == (None, None):
856
oldpath, newpath = paths
857
oldpath_encoded = get_encoded_path(paths[0])
858
newpath_encoded = get_encoded_path(paths[1])
859
old_present = (kind[0] is not None and versioned[0])
860
new_present = (kind[1] is not None and versioned[1])
861
renamed = (parent[0], name[0]) != (parent[1], name[1])
863
properties_changed = []
864
properties_changed.extend(get_executable_change(executable[0], executable[1]))
866
if properties_changed:
867
prop_str = " (properties changed: %s)" % (", ".join(properties_changed),)
871
if (old_present, new_present) == (True, False):
872
self.to_file.write("=== removed %s '%s'\n" %
873
(kind[0], oldpath_encoded))
875
elif (old_present, new_present) == (False, True):
876
self.to_file.write("=== added %s '%s'\n" %
877
(kind[1], newpath_encoded))
880
self.to_file.write("=== renamed %s '%s' => '%s'%s\n" %
881
(kind[0], oldpath_encoded, newpath_encoded, prop_str))
883
# if it was produced by iter_changes, it must be
884
# modified *somehow*, either content or execute bit.
885
self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
886
newpath_encoded, prop_str))
888
self.diff(file_id, oldpath, newpath)
894
def diff(self, file_id, old_path, new_path):
895
"""Perform a diff of a single file
897
:param file_id: file-id of the file
898
:param old_path: The path of the file in the old tree
899
:param new_path: The path of the file in the new tree
902
old_kind = self.old_tree.kind(file_id)
903
except (errors.NoSuchId, errors.NoSuchFile):
906
new_kind = self.new_tree.kind(file_id)
907
except (errors.NoSuchId, errors.NoSuchFile):
910
result = DiffPath._diff_many(self.differs, file_id, old_path,
911
new_path, old_kind, new_kind)
912
if result is DiffPath.CANNOT_DIFF:
913
error_path = new_path
914
if error_path is None:
915
error_path = old_path
916
raise errors.NoDiffFound(error_path)
205
if oldlines and (oldlines[-1][-1] != '\n'):
208
if newlines and (newlines[-1][-1] != '\n'):
212
ud = difflib.unified_diff(oldlines, newlines, **kw)
213
sys.stdout.writelines(ud)
215
print "\\ No newline at end of file"
216
sys.stdout.write('\n')
218
if file_state in ['.', '?', 'I']:
220
elif file_state == 'A':
221
print '*** added %s %r' % (kind, new_name)
224
new_tree.get_file(fid).readlines(),
226
tofile=new_label + new_name + idlabel)
227
elif file_state == 'D':
228
assert isinstance(old_name, types.StringTypes)
229
print '*** deleted %s %r' % (kind, old_name)
231
diffit(old_tree.get_file(fid).readlines(), [],
232
fromfile=old_label + old_name + idlabel,
234
elif file_state in ['M', 'R']:
235
if file_state == 'M':
236
assert kind == 'file'
237
assert old_name == new_name
238
print '*** modified %s %r' % (kind, new_name)
239
elif file_state == 'R':
240
print '*** renamed %s %r => %r' % (kind, old_name, new_name)
243
diffit(old_tree.get_file(fid).readlines(),
244
new_tree.get_file(fid).readlines(),
245
fromfile=old_label + old_name + idlabel,
246
tofile=new_label + new_name)
248
bailout("can't represent state %s {%s}" % (file_state, fid))
added
removed
bzrlib/diff.py
