14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
from __future__ import absolute_import
23
from bzrlib.lazy_import import lazy_import
24
from .lazy_import import lazy_import
24
25
lazy_import(globals(), """
31
branch as _mod_branch,
43
from bzrlib.workingtree import WorkingTree
40
from breezy.workingtree import WorkingTree
41
from breezy.i18n import gettext
46
from bzrlib.registry import (
44
from .registry import (
49
from bzrlib.symbol_versioning import (
53
from bzrlib.trace import mutter, note, warning
56
class AtTemplate(string.Template):
57
"""Templating class that uses @ instead of $."""
47
from .sixish import text_type
48
from .trace import mutter, note, warning
49
from .tree import FileTimestampUnavailable
52
DEFAULT_CONTEXT_AMOUNT = 3
62
55
# TODO: Rather than building a changeset object, we should probably
86
79
# In the meantime we at least make sure the patch isn't
90
# Special workaround for Python2.3, where difflib fails if
91
# both sequences are empty.
92
if not oldlines and not newlines:
95
82
if allow_binary is False:
96
83
textfile.check_text_lines(oldlines)
97
84
textfile.check_text_lines(newlines)
99
86
if sequence_matcher is None:
100
87
sequence_matcher = patiencediff.PatienceSequenceMatcher
101
ud = patiencediff.unified_diff(oldlines, newlines,
102
fromfile=old_filename.encode(path_encoding),
103
tofile=new_filename.encode(path_encoding),
104
sequencematcher=sequence_matcher)
88
ud = unified_diff_bytes(
90
fromfile=old_label.encode(path_encoding, 'replace'),
91
tofile=new_label.encode(path_encoding, 'replace'),
92
n=context_lines, sequencematcher=sequence_matcher)
107
if len(ud) == 0: # Identical contents, nothing to do
95
if len(ud) == 0: # Identical contents, nothing to do
109
97
# work-around for difflib being too smart for its own good
110
98
# if /dev/null is "1,0", patch won't recognize it as /dev/null
112
ud[2] = ud[2].replace('-1,0', '-0,0')
100
ud[2] = ud[2].replace(b'-1,0', b'-0,0')
113
101
elif not newlines:
114
ud[2] = ud[2].replace('+1,0', '+0,0')
102
ud[2] = ud[2].replace(b'+1,0', b'+0,0')
117
105
to_file.write(line)
118
if not line.endswith('\n'):
119
to_file.write("\n\\ No newline at end of file\n")
106
if not line.endswith(b'\n'):
107
to_file.write(b"\n\\ No newline at end of file\n")
111
def unified_diff_bytes(a, b, fromfile=b'', tofile=b'', fromfiledate=b'',
112
tofiledate=b'', n=3, lineterm=b'\n', sequencematcher=None):
114
Compare two sequences of lines; generate the delta as a unified diff.
116
Unified diffs are a compact way of showing line changes and a few
117
lines of context. The number of context lines is set by 'n' which
120
By default, the diff control lines (those with ---, +++, or @@) are
121
created with a trailing newline. This is helpful so that inputs
122
created from file.readlines() result in diffs that are suitable for
123
file.writelines() since both the inputs and outputs have trailing
126
For inputs that do not have trailing newlines, set the lineterm
127
argument to "" so that the output will be uniformly newline free.
129
The unidiff format normally has a header for filenames and modification
130
times. Any or all of these may be specified using strings for
131
'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'. The modification
132
times are normally expressed in the format returned by time.ctime().
136
>>> for line in bytes_unified_diff(b'one two three four'.split(),
137
... b'zero one tree four'.split(), b'Original', b'Current',
138
... b'Sat Jan 26 23:30:50 1991', b'Fri Jun 06 10:20:52 2003',
141
--- Original Sat Jan 26 23:30:50 1991
142
+++ Current Fri Jun 06 10:20:52 2003
151
if sequencematcher is None:
152
sequencematcher = difflib.SequenceMatcher
155
fromfiledate = b'\t' + bytes(fromfiledate)
157
tofiledate = b'\t' + bytes(tofiledate)
160
for group in sequencematcher(None, a, b).get_grouped_opcodes(n):
162
yield b'--- %s%s%s' % (fromfile, fromfiledate, lineterm)
163
yield b'+++ %s%s%s' % (tofile, tofiledate, lineterm)
165
i1, i2, j1, j2 = group[0][1], group[-1][2], group[0][3], group[-1][4]
166
yield b"@@ -%d,%d +%d,%d @@%s" % (i1 + 1, i2 - i1, j1 + 1, j2 - j1, lineterm)
167
for tag, i1, i2, j1, j2 in group:
169
for line in a[i1:i2]:
172
if tag == 'replace' or tag == 'delete':
173
for line in a[i1:i2]:
175
if tag == 'replace' or tag == 'insert':
176
for line in b[j1:j2]:
123
180
def _spawn_external_diff(diffcmd, capture_errors=True):
124
"""Spawn the externall diff process, and return the child handle.
181
"""Spawn the external diff process, and return the child handle.
126
183
:param diffcmd: The command list to spawn
127
184
:param capture_errors: Capture stderr as well as setting LANG=C
160
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
217
# diff style options as of GNU diff v3.2
218
style_option_list = ['-c', '-C', '--context',
220
'-f', '--forward-ed',
224
'-u', '-U', '--unified',
225
'-y', '--side-by-side',
229
def default_style_unified(diff_opts):
230
"""Default to unified diff style if alternative not specified in diff_opts.
232
diff only allows one style to be specified; they don't override.
233
Note that some of these take optargs, and the optargs can be
234
directly appended to the options.
235
This is only an approximate parser; it doesn't properly understand
238
:param diff_opts: List of options for external (GNU) diff.
239
:return: List of options with default style=='unified'.
241
for s in style_option_list:
249
diff_opts.append('-u')
253
def external_diff(old_label, oldlines, new_label, newlines, to_file,
162
255
"""Display a diff by calling out to the external diff program."""
163
256
# make sure our own output is properly ordered before the diff
166
oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
167
newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
259
oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='brz-diff-old-')
260
newtmp_fd, new_abspath = tempfile.mkstemp(prefix='brz-diff-new-')
168
261
oldtmpf = os.fdopen(oldtmp_fd, 'wb')
169
262
newtmpf = os.fdopen(newtmp_fd, 'wb')
187
280
if sys.platform == 'win32':
188
281
# Popen doesn't do the proper encoding for external commands
189
282
# Since we are dealing with an ANSI api, use mbcs encoding
190
old_filename = old_filename.encode('mbcs')
191
new_filename = new_filename.encode('mbcs')
283
old_label = old_label.encode('mbcs')
284
new_label = new_label.encode('mbcs')
192
285
diffcmd = ['diff',
193
'--label', old_filename,
286
'--label', old_label,
195
'--label', new_filename,
288
'--label', new_label,
200
# diff only allows one style to be specified; they don't override.
201
# note that some of these take optargs, and the optargs can be
202
# directly appended to the options.
203
# this is only an approximate parser; it doesn't properly understand
205
for s in ['-c', '-u', '-C', '-U',
210
'-y', '--side-by-side',
293
diff_opts = default_style_unified(diff_opts)
222
296
diffcmd.extend(diff_opts)
224
298
pipe = _spawn_external_diff(diffcmd, capture_errors=True)
225
out,err = pipe.communicate()
299
out, err = pipe.communicate()
226
300
rc = pipe.returncode
228
302
# internal_diff() adds a trailing newline, add one here for consistency
231
305
# 'diff' gives retcode == 2 for all sorts of errors
232
306
# one of those is 'Binary files differ'.
239
313
out, err = pipe.communicate()
241
315
# Write out the new i18n diff response
242
to_file.write(out+'\n')
316
to_file.write(out + b'\n')
243
317
if pipe.returncode != 2:
244
318
raise errors.BzrError(
245
'external diff failed with exit code 2'
246
' when run with LANG=C and LC_ALL=C,'
247
' but not when run natively: %r' % (diffcmd,))
319
'external diff failed with exit code 2'
320
' when run with LANG=C and LC_ALL=C,'
321
' but not when run natively: %r' % (diffcmd,))
249
first_line = lang_c_out.split('\n', 1)[0]
323
first_line = lang_c_out.split(b'\n', 1)[0]
250
324
# Starting with diffutils 2.8.4 the word "binary" was dropped.
251
m = re.match('^(binary )?files.*differ$', first_line, re.I)
325
m = re.match(b'^(binary )?files.*differ$', first_line, re.I)
253
327
raise errors.BzrError('external diff failed with exit code 2;'
254
328
' command: %r' % (diffcmd,))
267
341
msg = 'exit code %d' % rc
269
343
raise errors.BzrError('external diff failed with %s; command: %r'
274
347
oldtmpf.close() # and delete
276
# Clean up. Warn in case the files couldn't be deleted
277
# (in case windows still holds the file open, but not
278
# if the files have already been deleted)
280
os.remove(old_abspath)
282
if e.errno not in (errno.ENOENT,):
283
warning('Failed to delete temporary file: %s %s',
286
os.remove(new_abspath)
288
if e.errno not in (errno.ENOENT,):
289
warning('Failed to delete temporary file: %s %s',
293
@deprecated_function(deprecated_in((2, 2, 0)))
294
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
296
"""Get the trees and specific files to diff given a list of paths.
298
This method works out the trees to be diff'ed and the files of
299
interest within those trees.
302
the list of arguments passed to the diff command
303
:param revision_specs:
304
Zero, one or two RevisionSpecs from the diff command line,
305
saying what revisions to compare.
307
The url of the old branch or tree. If None, the tree to use is
308
taken from the first path, if any, or the current working tree.
310
The url of the new branch or tree. If None, the tree to use is
311
taken from the first path, if any, or the current working tree.
313
if True and a view is set, apply the view or check that the paths
316
a tuple of (old_tree, new_tree, old_branch, new_branch,
317
specific_files, extra_trees) where extra_trees is a sequence of
318
additional trees to search in for file-ids. The trees and branches
321
op = cleanup.OperationWithCleanups(get_trees_and_branches_to_diff_locked)
322
return op.run_simple(path_list, revision_specs, old_url, new_url,
323
op.add_cleanup, apply_view=apply_view)
351
# Warn in case the file couldn't be deleted (in case windows still
352
# holds the file open, but not if the files have already been
357
if e.errno not in (errno.ENOENT,):
358
warning('Failed to delete temporary file: %s %s', path, e)
326
364
def get_trees_and_branches_to_diff_locked(
327
path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
365
path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
328
366
"""Get the trees and specific files to diff given a list of paths.
330
368
This method works out the trees to be diff'ed and the files of
408
446
new_url = default_location
409
447
if new_url != old_url:
410
448
working_tree, branch, relpath = \
411
bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
449
controldir.ControlDir.open_containing_tree_or_branch(new_url)
412
450
lock_tree_or_branch(working_tree, branch)
413
451
if consider_relpath and relpath != '':
414
452
if working_tree is not None and apply_view:
415
453
views.check_path_in_view(working_tree, relpath)
416
454
specific_files.append(relpath)
417
455
new_tree = _get_tree_to_diff(new_revision_spec, working_tree, branch,
418
basis_is_default=working_tree is None)
456
basis_is_default=working_tree is None)
419
457
new_branch = branch
421
459
# Get the specific files (all files is None, no files is [])
422
460
if make_paths_wt_relative and working_tree is not None:
424
from bzrlib.builtins import safe_relpath_files
425
other_paths = safe_relpath_files(working_tree, other_paths,
461
other_paths = working_tree.safe_relpath_files(
426
463
apply_view=apply_view)
427
except errors.FileInWrongBranch:
428
raise errors.BzrCommandError("Files are in different branches")
429
464
specific_files.extend(other_paths)
430
465
if len(specific_files) == 0:
431
466
specific_files = None
432
if (working_tree is not None and working_tree.supports_views()
467
if (working_tree is not None and working_tree.supports_views() and
434
469
view_files = working_tree.views.lookup_view()
436
471
specific_files = view_files
437
472
view_str = views.view_display_str(view_files)
438
note("*** Ignoring files outside view. View is %s" % view_str)
473
note(gettext("*** Ignoring files outside view. View is %s") % view_str)
440
475
# Get extra trees that ought to be searched for file-ids
441
476
extra_trees = None
442
477
if working_tree is not None and working_tree not in (old_tree, new_tree):
443
478
extra_trees = (working_tree,)
444
return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
479
return (old_tree, new_tree, old_branch, new_branch,
480
specific_files, extra_trees)
447
483
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
489
527
differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
491
529
external_diff_options,
492
old_label, new_label, using)
530
old_label, new_label, using,
531
context_lines=context)
493
532
return differ.show_diff(specific_files, extra_trees)
495
534
new_tree.unlock()
496
535
if extra_trees is not None:
497
536
for tree in extra_trees:
503
def _patch_header_date(tree, file_id, path):
540
def _patch_header_date(tree, path):
504
541
"""Returns a timestamp suitable for use in a patch header."""
506
mtime = tree.get_file_mtime(file_id, path)
507
except errors.FileTimestampUnavailable:
543
mtime = tree.get_file_mtime(path)
544
except FileTimestampUnavailable:
509
546
return timestamp.format_patch_date(mtime)
512
549
def get_executable_change(old_is_x, new_is_x):
513
descr = { True:"+x", False:"-x", None:"??" }
550
descr = {True: b"+x", False: b"-x", None: b"??"}
514
551
if old_is_x != new_is_x:
515
return ["%s to %s" % (descr[old_is_x], descr[new_is_x],)]
552
return [b"%s to %s" % (descr[old_is_x], descr[new_is_x],)]
587
623
if None in (old_kind, new_kind):
588
624
return DiffPath.CANNOT_DIFF
589
result = DiffPath._diff_many(self.differs, file_id, old_path,
590
new_path, old_kind, None)
625
result = DiffPath._diff_many(
626
self.differs, old_path, new_path, old_kind, None)
591
627
if result is DiffPath.CANNOT_DIFF:
593
return DiffPath._diff_many(self.differs, file_id, old_path, new_path,
629
return DiffPath._diff_many(
630
self.differs, old_path, new_path, None, new_kind)
633
class DiffTreeReference(DiffPath):
635
def diff(self, old_path, new_path, old_kind, new_kind):
636
"""Perform comparison between two tree references. (dummy)
639
if 'tree-reference' not in (old_kind, new_kind):
640
return self.CANNOT_DIFF
641
if old_kind not in ('tree-reference', None):
642
return self.CANNOT_DIFF
643
if new_kind not in ('tree-reference', None):
644
return self.CANNOT_DIFF
597
648
class DiffDirectory(DiffPath):
599
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
650
def diff(self, old_path, new_path, old_kind, new_kind):
600
651
"""Perform comparison between two directories. (dummy)
654
707
EPOCH_DATE = '1970-01-01 00:00:00 +0000'
656
709
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
657
old_label='', new_label='', text_differ=internal_diff):
710
old_label='', new_label='', text_differ=internal_diff,
711
context_lines=DEFAULT_CONTEXT_AMOUNT):
658
712
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
659
713
self.text_differ = text_differ
660
714
self.old_label = old_label
661
715
self.new_label = new_label
662
716
self.path_encoding = path_encoding
717
self.context_lines = context_lines
664
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
719
def diff(self, old_path, new_path, old_kind, new_kind):
665
720
"""Compare two files in unified diff format
667
:param file_id: The file_id of the file to compare
668
722
:param old_path: Path of the file in the old tree
669
723
:param new_path: Path of the file in the new tree
670
724
:param old_kind: Old file-kind of the file
673
727
if 'file' not in (old_kind, new_kind):
674
728
return self.CANNOT_DIFF
675
from_file_id = to_file_id = file_id
676
729
if old_kind == 'file':
677
old_date = _patch_header_date(self.old_tree, file_id, old_path)
730
old_date = _patch_header_date(self.old_tree, old_path)
678
731
elif old_kind is None:
679
732
old_date = self.EPOCH_DATE
682
734
return self.CANNOT_DIFF
683
735
if new_kind == 'file':
684
new_date = _patch_header_date(self.new_tree, file_id, new_path)
736
new_date = _patch_header_date(self.new_tree, new_path)
685
737
elif new_kind is None:
686
738
new_date = self.EPOCH_DATE
689
740
return self.CANNOT_DIFF
690
from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
691
to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
692
return self.diff_text(from_file_id, to_file_id, from_label, to_label,
741
from_label = '%s%s\t%s' % (self.old_label, old_path,
743
to_label = '%s%s\t%s' % (self.new_label, new_path,
745
return self.diff_text(old_path, new_path, from_label, to_label)
695
def diff_text(self, from_file_id, to_file_id, from_label, to_label,
696
from_path=None, to_path=None):
747
def diff_text(self, from_path, to_path, from_label, to_label):
697
748
"""Diff the content of given files in two trees
699
:param from_file_id: The id of the file in the from tree. If None,
750
:param from_path: The path in the from tree. If None,
700
751
the file is not present in the from tree.
701
:param to_file_id: The id of the file in the to tree. This may refer
702
to a different file from from_file_id. If None,
752
:param to_path: The path in the to tree. This may refer
753
to a different file from from_path. If None,
703
754
the file is not present in the to tree.
704
:param from_path: The path in the from tree or None if unknown.
705
:param to_path: The path in the to tree or None if unknown.
707
def _get_text(tree, file_id, path):
708
if file_id is not None:
709
return tree.get_file(file_id, path).readlines()
756
def _get_text(tree, path):
760
return tree.get_file_lines(path)
761
except errors.NoSuchFile:
713
from_text = _get_text(self.old_tree, from_file_id, from_path)
714
to_text = _get_text(self.new_tree, to_file_id, to_path)
764
from_text = _get_text(self.old_tree, from_path)
765
to_text = _get_text(self.new_tree, to_path)
715
766
self.text_differ(from_label, from_text, to_label, to_text,
767
self.to_file, path_encoding=self.path_encoding,
768
context_lines=self.context_lines)
717
769
except errors.BinaryFile:
718
770
self.to_file.write(
719
("Binary files %s and %s differ\n" %
720
(from_label, to_label)).encode(self.path_encoding))
771
("Binary files %s%s and %s%s differ\n" %
772
(self.old_label, from_path, self.new_label, to_path)).encode(self.path_encoding, 'replace'))
721
773
return self.CHANGED
727
779
path_encoding='utf-8'):
728
780
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
729
781
self.command_template = command_template
730
self._root = osutils.mkdtemp(prefix='bzr-diff-')
782
self._root = osutils.mkdtemp(prefix='brz-diff-')
733
def from_string(klass, command_string, old_tree, new_tree, to_file,
785
def from_string(klass, command_template, old_tree, new_tree, to_file,
734
786
path_encoding='utf-8'):
735
command_template = cmdline.split(command_string)
736
if '@' not in command_string:
737
command_template.extend(['@old_path', '@new_path'])
738
787
return klass(command_template, old_tree, new_tree, to_file,
742
def make_from_diff_tree(klass, command_string):
791
def make_from_diff_tree(klass, command_string, external_diff_options=None):
743
792
def from_diff_tree(diff_tree):
744
return klass.from_string(command_string, diff_tree.old_tree,
793
full_command_string = [command_string]
794
if external_diff_options is not None:
795
full_command_string += ' ' + external_diff_options
796
return klass.from_string(full_command_string, diff_tree.old_tree,
745
797
diff_tree.new_tree, diff_tree.to_file)
746
798
return from_diff_tree
748
800
def _get_command(self, old_path, new_path):
749
801
my_map = {'old_path': old_path, 'new_path': new_path}
750
return [AtTemplate(t).substitute(my_map) for t in
751
self.command_template]
802
command = [t.format(**my_map) for t in
803
self.command_template]
804
if sys.platform == 'win32': # Popen doesn't accept unicode on win32
807
if isinstance(c, text_type):
808
command_encoded.append(c.encode('mbcs'))
810
command_encoded.append(c)
811
return command_encoded
753
815
def _execute(self, old_path, new_path):
754
816
command = self._get_command(old_path, new_path)
756
818
proc = subprocess.Popen(command, stdout=subprocess.PIPE,
759
821
if e.errno == errno.ENOENT:
760
822
raise errors.ExecutableMissing(command[0])
763
825
self.to_file.write(proc.stdout.read())
764
827
return proc.wait()
766
829
def _try_symlink_root(self, tree, prefix):
767
if (getattr(tree, 'abspath', None) is None
768
or not osutils.host_os_dereferences_symlinks()):
830
if (getattr(tree, 'abspath', None) is None or
831
not osutils.host_os_dereferences_symlinks()):
771
834
os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
773
836
if e.errno != errno.EEXIST:
777
def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
842
"""Returns safe encoding for passing file path to diff tool"""
843
if sys.platform == 'win32':
846
# Don't fallback to 'utf-8' because subprocess may not be able to
847
# handle utf-8 correctly when locale is not utf-8.
848
return sys.getfilesystemencoding() or 'ascii'
850
def _is_safepath(self, path):
851
"""Return true if `path` may be able to pass to subprocess."""
854
return path == path.encode(fenc).decode(fenc)
858
def _safe_filename(self, prefix, relpath):
859
"""Replace unsafe character in `relpath` then join `self._root`,
860
`prefix` and `relpath`."""
862
# encoded_str.replace('?', '_') may break multibyte char.
863
# So we should encode, decode, then replace(u'?', u'_')
864
relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
865
relpath_tmp = relpath_tmp.replace(u'?', u'_')
866
return osutils.pathjoin(self._root, prefix, relpath_tmp)
868
def _write_file(self, relpath, tree, prefix, force_temp=False,
778
869
allow_write=False):
779
870
if not force_temp and isinstance(tree, WorkingTree):
780
return tree.abspath(tree.id2path(file_id))
782
full_path = osutils.pathjoin(self._root, prefix, relpath)
871
full_path = tree.abspath(relpath)
872
if self._is_safepath(full_path):
875
full_path = self._safe_filename(prefix, relpath)
783
876
if not force_temp and self._try_symlink_root(tree, prefix):
785
878
parent_dir = osutils.dirname(full_path)
787
880
os.makedirs(parent_dir)
789
882
if e.errno != errno.EEXIST:
791
source = tree.get_file(file_id, relpath)
884
source = tree.get_file(relpath)
793
target = open(full_path, 'wb')
886
with open(full_path, 'wb') as target:
795
887
osutils.pumpfile(source, target)
801
mtime = tree.get_file_mtime(file_id)
802
except errors.FileTimestampUnavailable:
891
mtime = tree.get_file_mtime(relpath)
892
except FileTimestampUnavailable:
805
895
os.utime(full_path, (mtime, mtime))
807
897
osutils.make_readonly(full_path)
810
def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
900
def _prepare_files(self, old_path, new_path, force_temp=False,
811
901
allow_write_new=False):
812
old_disk_path = self._write_file(file_id, self.old_tree, 'old',
813
old_path, force_temp)
814
new_disk_path = self._write_file(file_id, self.new_tree, 'new',
815
new_path, force_temp,
816
allow_write=allow_write_new)
902
old_disk_path = self._write_file(
903
old_path, self.old_tree, 'old', force_temp)
904
new_disk_path = self._write_file(
905
new_path, self.new_tree, 'new', force_temp,
906
allow_write=allow_write_new)
817
907
return old_disk_path, new_disk_path
819
909
def finish(self):
821
911
osutils.rmtree(self._root)
823
913
if e.errno != errno.ENOENT:
824
914
mutter("The temporary directory \"%s\" was not "
825
"cleanly removed: %s." % (self._root, e))
915
"cleanly removed: %s." % (self._root, e))
827
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
917
def diff(self, old_path, new_path, old_kind, new_kind):
828
918
if (old_kind, new_kind) != ('file', 'file'):
829
919
return DiffPath.CANNOT_DIFF
830
920
(old_disk_path, new_disk_path) = self._prepare_files(
831
file_id, old_path, new_path)
832
922
self._execute(old_disk_path, new_disk_path)
834
def edit_file(self, file_id):
924
def edit_file(self, old_path, new_path):
835
925
"""Use this tool to edit a file.
837
927
A temporary copy will be edited, and the new contents will be
840
:param file_id: The id of the file to edit.
841
930
:return: The new contents of the file.
843
old_path = self.old_tree.id2path(file_id)
844
new_path = self.new_tree.id2path(file_id)
845
new_abs_path = self._prepare_files(file_id, old_path, new_path,
846
allow_write_new=True,
848
command = self._get_command(osutils.pathjoin('old', old_path),
849
osutils.pathjoin('new', new_path))
932
old_abs_path, new_abs_path = self._prepare_files(
933
old_path, new_path, allow_write_new=True, force_temp=True)
934
command = self._get_command(old_abs_path, new_abs_path)
850
935
subprocess.call(command, cwd=self._root)
851
new_file = open(new_abs_path, 'r')
936
with open(new_abs_path, 'rb') as new_file:
853
937
return new_file.read()
858
940
class DiffTree(object):
915
999
:param using: Commandline to use to invoke an external diff tool
917
1001
if using is not None:
918
extra_factories = [DiffFromTool.make_from_diff_tree(using)]
1002
extra_factories = [DiffFromTool.make_from_diff_tree(
1003
using, external_diff_options)]
920
1005
extra_factories = []
921
1006
if external_diff_options:
922
1007
opts = external_diff_options.split()
923
def diff_file(olab, olines, nlab, nlines, to_file):
1009
def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
1010
""":param path_encoding: not used but required
1011
to match the signature of internal_diff.
924
1013
external_diff(olab, olines, nlab, nlines, to_file, opts)
926
1015
diff_file = internal_diff
927
1016
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
928
old_label, new_label, diff_file)
1017
old_label, new_label, diff_file, context_lines=context_lines)
929
1018
return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
930
1019
extra_factories)
945
1034
# TODO: Generation of pseudo-diffs for added/deleted files could
946
1035
# be usefully made into a much faster special case.
947
1036
iterator = self.new_tree.iter_changes(self.old_tree,
948
specific_files=specific_files,
949
extra_trees=extra_trees,
950
require_versioned=True)
1037
specific_files=specific_files,
1038
extra_trees=extra_trees,
1039
require_versioned=True)
952
1042
def changes_key(change):
953
1043
old_path, new_path = change[1]
955
1045
if path is None:
958
1049
def get_encoded_path(path):
959
1050
if path is not None:
960
1051
return path.encode(self.path_encoding, "replace")
961
for (file_id, paths, changed_content, versioned, parent, name, kind,
962
executable) in sorted(iterator, key=changes_key):
1052
for change in sorted(iterator, key=changes_key):
963
1053
# The root does not get diffed, and items with no known kind (that
964
1054
# is, missing) in both trees are skipped as well.
965
if parent == (None, None) or kind == (None, None):
967
oldpath, newpath = paths
968
oldpath_encoded = get_encoded_path(paths[0])
969
newpath_encoded = get_encoded_path(paths[1])
970
old_present = (kind[0] is not None and versioned[0])
971
new_present = (kind[1] is not None and versioned[1])
972
renamed = (parent[0], name[0]) != (parent[1], name[1])
1055
if change.parent_id == (None, None) or change.kind == (None, None):
1057
if change.kind[0] == 'symlink' and not self.new_tree.supports_symlinks():
1059
'Ignoring "%s" as symlinks are not '
1060
'supported on this filesystem.' % (change.path[0],))
1062
oldpath, newpath = change.path
1063
oldpath_encoded = get_encoded_path(change.path[0])
1064
newpath_encoded = get_encoded_path(change.path[1])
1065
old_present = (change.kind[0] is not None and change.versioned[0])
1066
new_present = (change.kind[1] is not None and change.versioned[1])
1067
executable = change.executable
1069
renamed = (change.parent_id[0], change.name[0]) != (change.parent_id[1], change.name[1])
974
1071
properties_changed = []
975
properties_changed.extend(get_executable_change(executable[0], executable[1]))
1072
properties_changed.extend(
1073
get_executable_change(executable[0], executable[1]))
977
1075
if properties_changed:
978
prop_str = " (properties changed: %s)" % (", ".join(properties_changed),)
1076
prop_str = b" (properties changed: %s)" % (
1077
b", ".join(properties_changed),)
982
1081
if (old_present, new_present) == (True, False):
983
self.to_file.write("=== removed %s '%s'\n" %
984
(kind[0], oldpath_encoded))
1082
self.to_file.write(b"=== removed %s '%s'\n" %
1083
(kind[0].encode('ascii'), oldpath_encoded))
985
1084
newpath = oldpath
986
1085
elif (old_present, new_present) == (False, True):
987
self.to_file.write("=== added %s '%s'\n" %
988
(kind[1], newpath_encoded))
1086
self.to_file.write(b"=== added %s '%s'\n" %
1087
(kind[1].encode('ascii'), newpath_encoded))
989
1088
oldpath = newpath
991
self.to_file.write("=== renamed %s '%s' => '%s'%s\n" %
992
(kind[0], oldpath_encoded, newpath_encoded, prop_str))
1090
self.to_file.write(b"=== renamed %s '%s' => '%s'%s\n" %
1091
(kind[0].encode('ascii'), oldpath_encoded, newpath_encoded, prop_str))
994
1093
# if it was produced by iter_changes, it must be
995
1094
# modified *somehow*, either content or execute bit.
996
self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
997
newpath_encoded, prop_str))
999
self._diff(file_id, oldpath, newpath, kind[0], kind[1])
1095
self.to_file.write(b"=== modified %s '%s'%s\n" % (kind[0].encode('ascii'),
1096
newpath_encoded, prop_str))
1097
if change.changed_content:
1098
self._diff(oldpath, newpath, kind[0], kind[1])
1000
1099
has_changes = 1
1002
1101
has_changes = 1
1003
1102
return has_changes
1005
def diff(self, file_id, old_path, new_path):
1104
def diff(self, old_path, new_path):
1006
1105
"""Perform a diff of a single file
1008
:param file_id: file-id of the file
1009
1107
:param old_path: The path of the file in the old tree
1010
1108
:param new_path: The path of the file in the new tree
1013
old_kind = self.old_tree.kind(file_id)
1014
except (errors.NoSuchId, errors.NoSuchFile):
1110
if old_path is None:
1015
1111
old_kind = None
1017
new_kind = self.new_tree.kind(file_id)
1018
except (errors.NoSuchId, errors.NoSuchFile):
1113
old_kind = self.old_tree.kind(old_path)
1114
if new_path is None:
1019
1115
new_kind = None
1020
self._diff(file_id, old_path, new_path, old_kind, new_kind)
1023
def _diff(self, file_id, old_path, new_path, old_kind, new_kind):
1024
result = DiffPath._diff_many(self.differs, file_id, old_path,
1025
new_path, old_kind, new_kind)
1117
new_kind = self.new_tree.kind(new_path)
1118
self._diff(old_path, new_path, old_kind, new_kind)
1120
def _diff(self, old_path, new_path, old_kind, new_kind):
1121
result = DiffPath._diff_many(
1122
self.differs, old_path, new_path, old_kind, new_kind)
1026
1123
if result is DiffPath.CANNOT_DIFF:
1027
1124
error_path = new_path
1028
1125
if error_path is None: