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
25
from .lazy_import import lazy_import
24
26
lazy_import(globals(), """
31
branch as _mod_branch,
43
from bzrlib.workingtree import WorkingTree
43
from breezy.workingtree import WorkingTree
44
from breezy.i18n import gettext
46
from bzrlib.registry import (
47
from .registry import (
49
from bzrlib.symbol_versioning import (
53
from bzrlib.trace import mutter, note, warning
50
from .trace import mutter, note, warning
51
from .tree import FileTimestampUnavailable
54
DEFAULT_CONTEXT_AMOUNT = 3
56
56
class AtTemplate(string.Template):
57
57
"""Templating class that uses @ instead of $."""
76
76
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
77
77
allow_binary=False, sequence_matcher=None,
78
path_encoding='utf8'):
78
path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
79
79
# FIXME: difflib is wrong if there is no trailing newline.
80
80
# The syntax used by patch seems to be "\ No newline at
81
81
# end of file" following the last diff line from that
99
93
if sequence_matcher is None:
100
94
sequence_matcher = patiencediff.PatienceSequenceMatcher
101
95
ud = patiencediff.unified_diff(oldlines, newlines,
102
fromfile=old_filename.encode(path_encoding),
103
tofile=new_filename.encode(path_encoding),
104
sequencematcher=sequence_matcher)
96
fromfile=old_filename.encode(path_encoding, 'replace'),
97
tofile=new_filename.encode(path_encoding, 'replace'),
98
n=context_lines, sequencematcher=sequence_matcher)
107
101
if len(ud) == 0: # Identical contents, nothing to do
149
143
stdout=subprocess.PIPE,
153
147
if e.errno == errno.ENOENT:
154
148
raise errors.NoDiff(str(e))
153
# diff style options as of GNU diff v3.2
154
style_option_list = ['-c', '-C', '--context',
156
'-f', '--forward-ed',
160
'-u', '-U', '--unified',
161
'-y', '--side-by-side',
164
def default_style_unified(diff_opts):
165
"""Default to unified diff style if alternative not specified in diff_opts.
167
diff only allows one style to be specified; they don't override.
168
Note that some of these take optargs, and the optargs can be
169
directly appended to the options.
170
This is only an approximate parser; it doesn't properly understand
173
:param diff_opts: List of options for external (GNU) diff.
174
:return: List of options with default style=='unified'.
176
for s in style_option_list:
184
diff_opts.append('-u')
160
188
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
163
191
# 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-')
194
oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='brz-diff-old-')
195
newtmp_fd, new_abspath = tempfile.mkstemp(prefix='brz-diff-new-')
168
196
oldtmpf = os.fdopen(oldtmp_fd, 'wb')
169
197
newtmpf = os.fdopen(newtmp_fd, 'wb')
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',
228
diff_opts = default_style_unified(diff_opts)
222
231
diffcmd.extend(diff_opts)
224
233
pipe = _spawn_external_diff(diffcmd, capture_errors=True)
225
out,err = pipe.communicate()
234
out, err = pipe.communicate()
226
235
rc = pipe.returncode
228
237
# internal_diff() adds a trailing newline, add one here for consistency
267
276
msg = 'exit code %d' % rc
269
278
raise errors.BzrError('external diff failed with %s; command: %r'
274
283
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)
287
# Warn in case the file couldn't be deleted (in case windows still
288
# holds the file open, but not if the files have already been
293
if e.errno not in (errno.ENOENT,):
294
warning('Failed to delete temporary file: %s %s', path, e)
326
300
def get_trees_and_branches_to_diff_locked(
327
301
path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
394
368
if old_url is None:
395
369
old_url = default_location
396
370
working_tree, branch, relpath = \
397
bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
371
controldir.ControlDir.open_containing_tree_or_branch(old_url)
398
372
lock_tree_or_branch(working_tree, branch)
399
373
if consider_relpath and relpath != '':
400
374
if working_tree is not None and apply_view:
408
382
new_url = default_location
409
383
if new_url != old_url:
410
384
working_tree, branch, relpath = \
411
bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
385
controldir.ControlDir.open_containing_tree_or_branch(new_url)
412
386
lock_tree_or_branch(working_tree, branch)
413
387
if consider_relpath and relpath != '':
414
388
if working_tree is not None and apply_view:
421
395
# Get the specific files (all files is None, no files is [])
422
396
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,
397
other_paths = working_tree.safe_relpath_files(
426
399
apply_view=apply_view)
427
except errors.FileInWrongBranch:
428
raise errors.BzrCommandError("Files are in different branches")
429
400
specific_files.extend(other_paths)
430
401
if len(specific_files) == 0:
431
402
specific_files = None
436
407
specific_files = view_files
437
408
view_str = views.view_display_str(view_files)
438
note("*** Ignoring files outside view. View is %s" % view_str)
409
note(gettext("*** Ignoring files outside view. View is %s") % view_str)
440
411
# Get extra trees that ought to be searched for file-ids
441
412
extra_trees = None
442
413
if working_tree is not None and working_tree not in (old_tree, new_tree):
443
414
extra_trees = (working_tree,)
444
return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
415
return (old_tree, new_tree, old_branch, new_branch,
416
specific_files, extra_trees)
447
419
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
489
463
differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
491
465
external_diff_options,
492
old_label, new_label, using)
466
old_label, new_label, using,
467
context_lines=context)
493
468
return differ.show_diff(specific_files, extra_trees)
495
470
new_tree.unlock()
496
471
if extra_trees is not None:
497
472
for tree in extra_trees:
503
476
def _patch_header_date(tree, file_id, path):
504
477
"""Returns a timestamp suitable for use in a patch header."""
506
mtime = tree.get_file_mtime(file_id, path)
507
except errors.FileTimestampUnavailable:
479
mtime = tree.get_file_mtime(path, file_id)
480
except FileTimestampUnavailable:
509
482
return timestamp.format_patch_date(mtime)
623
596
if 'symlink' not in (old_kind, new_kind):
624
597
return self.CANNOT_DIFF
625
598
if old_kind == 'symlink':
626
old_target = self.old_tree.get_symlink_target(file_id)
599
old_target = self.old_tree.get_symlink_target(old_path, file_id)
627
600
elif old_kind is None:
628
601
old_target = None
630
603
return self.CANNOT_DIFF
631
604
if new_kind == 'symlink':
632
new_target = self.new_tree.get_symlink_target(file_id)
605
new_target = self.new_tree.get_symlink_target(new_path, file_id)
633
606
elif new_kind is None:
634
607
new_target = None
653
626
# or removed in a diff.
654
627
EPOCH_DATE = '1970-01-01 00:00:00 +0000'
656
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
657
old_label='', new_label='', text_differ=internal_diff):
629
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
630
old_label='', new_label='', text_differ=internal_diff,
631
context_lines=DEFAULT_CONTEXT_AMOUNT):
658
632
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
659
633
self.text_differ = text_differ
660
634
self.old_label = old_label
661
635
self.new_label = new_label
662
636
self.path_encoding = path_encoding
637
self.context_lines = context_lines
664
639
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
665
640
"""Compare two files in unified diff format
689
664
return self.CANNOT_DIFF
690
665
from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
691
666
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,
667
return self.diff_text(old_path, new_path, from_label, to_label,
668
from_file_id, to_file_id)
695
def diff_text(self, from_file_id, to_file_id, from_label, to_label,
696
from_path=None, to_path=None):
670
def diff_text(self, from_path, to_path, from_label, to_label,
671
from_file_id=None, to_file_id=None):
697
672
"""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,
674
:param from_path: The path in the from tree. If None,
700
675
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,
676
:param to_path: The path in the to tree. This may refer
677
to a different file from from_path. If None,
703
678
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.
679
:param from_file_id: The id of the file in the from tree or None if
681
:param to_file_id: The id of the file in the to tree or None if
707
684
def _get_text(tree, file_id, path):
708
if file_id is not None:
709
return tree.get_file(file_id, path).readlines()
687
return tree.get_file_lines(path, file_id)
713
689
from_text = _get_text(self.old_tree, from_file_id, from_path)
714
690
to_text = _get_text(self.new_tree, to_file_id, to_path)
715
691
self.text_differ(from_label, from_text, to_label, to_text,
692
self.to_file, path_encoding=self.path_encoding,
693
context_lines=self.context_lines)
717
694
except errors.BinaryFile:
718
695
self.to_file.write(
719
696
("Binary files %s and %s differ\n" %
720
(from_label, to_label)).encode(self.path_encoding))
697
(from_label, to_label)).encode(self.path_encoding, 'replace'))
721
698
return self.CHANGED
727
704
path_encoding='utf-8'):
728
705
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
729
706
self.command_template = command_template
730
self._root = osutils.mkdtemp(prefix='bzr-diff-')
707
self._root = osutils.mkdtemp(prefix='brz-diff-')
733
710
def from_string(klass, command_string, old_tree, new_tree, to_file,
742
def make_from_diff_tree(klass, command_string):
719
def make_from_diff_tree(klass, command_string, external_diff_options=None):
743
720
def from_diff_tree(diff_tree):
744
return klass.from_string(command_string, diff_tree.old_tree,
721
full_command_string = [command_string]
722
if external_diff_options is not None:
723
full_command_string += ' ' + external_diff_options
724
return klass.from_string(full_command_string, diff_tree.old_tree,
745
725
diff_tree.new_tree, diff_tree.to_file)
746
726
return from_diff_tree
748
728
def _get_command(self, old_path, new_path):
749
729
my_map = {'old_path': old_path, 'new_path': new_path}
750
return [AtTemplate(t).substitute(my_map) for t in
751
self.command_template]
730
command = [AtTemplate(t).substitute(my_map) for t in
731
self.command_template]
732
if sys.platform == 'win32': # Popen doesn't accept unicode on win32
735
if isinstance(c, text_type):
736
command_encoded.append(c.encode('mbcs'))
738
command_encoded.append(c)
739
return command_encoded
753
743
def _execute(self, old_path, new_path):
754
744
command = self._get_command(old_path, new_path)
756
746
proc = subprocess.Popen(command, stdout=subprocess.PIPE,
759
749
if e.errno == errno.ENOENT:
760
750
raise errors.ExecutableMissing(command[0])
771
761
os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
773
763
if e.errno != errno.EEXIST:
777
def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
769
"""Returns safe encoding for passing file path to diff tool"""
770
if sys.platform == 'win32':
773
# Don't fallback to 'utf-8' because subprocess may not be able to
774
# handle utf-8 correctly when locale is not utf-8.
775
return sys.getfilesystemencoding() or 'ascii'
777
def _is_safepath(self, path):
778
"""Return true if `path` may be able to pass to subprocess."""
781
return path == path.encode(fenc).decode(fenc)
785
def _safe_filename(self, prefix, relpath):
786
"""Replace unsafe character in `relpath` then join `self._root`,
787
`prefix` and `relpath`."""
789
# encoded_str.replace('?', '_') may break multibyte char.
790
# So we should encode, decode, then replace(u'?', u'_')
791
relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
792
relpath_tmp = relpath_tmp.replace(u'?', u'_')
793
return osutils.pathjoin(self._root, prefix, relpath_tmp)
795
def _write_file(self, relpath, tree, prefix, force_temp=False,
796
allow_write=False, file_id=None):
779
797
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)
798
full_path = tree.abspath(relpath)
799
if self._is_safepath(full_path):
802
full_path = self._safe_filename(prefix, relpath)
783
803
if not force_temp and self._try_symlink_root(tree, prefix):
785
805
parent_dir = osutils.dirname(full_path)
787
807
os.makedirs(parent_dir)
789
809
if e.errno != errno.EEXIST:
791
source = tree.get_file(file_id, relpath)
811
source = tree.get_file(relpath, file_id)
793
target = open(full_path, 'wb')
813
with open(full_path, 'wb') as target:
795
814
osutils.pumpfile(source, target)
801
mtime = tree.get_file_mtime(file_id)
802
except errors.FileTimestampUnavailable:
818
mtime = tree.get_file_mtime(relpath, file_id)
819
except FileTimestampUnavailable:
805
822
os.utime(full_path, (mtime, mtime))
807
824
osutils.make_readonly(full_path)
810
def _prepare_files(self, file_id, old_path, new_path, force_temp=False,
811
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,
827
def _prepare_files(self, old_path, new_path, force_temp=False,
828
allow_write_new=False, file_id=None):
829
old_disk_path = self._write_file(old_path, self.old_tree, 'old',
830
force_temp, file_id=file_id)
831
new_disk_path = self._write_file(new_path, self.new_tree, 'new',
832
force_temp, file_id=file_id,
816
833
allow_write=allow_write_new)
817
834
return old_disk_path, new_disk_path
819
836
def finish(self):
821
838
osutils.rmtree(self._root)
823
840
if e.errno != errno.ENOENT:
824
841
mutter("The temporary directory \"%s\" was not "
825
842
"cleanly removed: %s." % (self._root, e))
828
845
if (old_kind, new_kind) != ('file', 'file'):
829
846
return DiffPath.CANNOT_DIFF
830
847
(old_disk_path, new_disk_path) = self._prepare_files(
831
file_id, old_path, new_path)
848
old_path, new_path, file_id=file_id)
832
849
self._execute(old_disk_path, new_disk_path)
834
def edit_file(self, file_id):
851
def edit_file(self, old_path, new_path, file_id=None):
835
852
"""Use this tool to edit a file.
837
854
A temporary copy will be edited, and the new contents will be
840
857
:param file_id: The id of the file to edit.
841
858
: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))
860
old_abs_path, new_abs_path = self._prepare_files(
861
old_path, new_path, allow_write_new=True, force_temp=True,
863
command = self._get_command(old_abs_path, new_abs_path)
850
864
subprocess.call(command, cwd=self._root)
851
new_file = open(new_abs_path, 'r')
865
with open(new_abs_path, 'rb') as new_file:
853
866
return new_file.read()
858
869
class DiffTree(object):
901
912
def from_trees_options(klass, old_tree, new_tree, to_file,
902
913
path_encoding, external_diff_options, old_label,
914
new_label, using, context_lines):
904
915
"""Factory for producing a DiffTree.
906
917
Designed to accept options used by show_diff_trees.
907
919
:param old_tree: The tree to show as old in the comparison
908
920
:param new_tree: The tree to show as new in the comparison
909
921
:param to_file: File to write comparisons to
915
927
:param using: Commandline to use to invoke an external diff tool
917
929
if using is not None:
918
extra_factories = [DiffFromTool.make_from_diff_tree(using)]
930
extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
920
932
extra_factories = []
921
933
if external_diff_options:
922
934
opts = external_diff_options.split()
923
def diff_file(olab, olines, nlab, nlines, to_file):
935
def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
936
""":param path_encoding: not used but required
937
to match the signature of internal_diff.
924
939
external_diff(olab, olines, nlab, nlines, to_file, opts)
926
941
diff_file = internal_diff
927
942
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
928
old_label, new_label, diff_file)
943
old_label, new_label, diff_file, context_lines=context_lines)
929
944
return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
975
990
properties_changed.extend(get_executable_change(executable[0], executable[1]))
977
992
if properties_changed:
978
prop_str = " (properties changed: %s)" % (", ".join(properties_changed),)
993
prop_str = b" (properties changed: %s)" % (
994
b", ".join(properties_changed),)
982
998
if (old_present, new_present) == (True, False):
983
self.to_file.write("=== removed %s '%s'\n" %
984
(kind[0], oldpath_encoded))
999
self.to_file.write(b"=== removed %s '%s'\n" %
1000
(kind[0].encode('ascii'), oldpath_encoded))
985
1001
newpath = oldpath
986
1002
elif (old_present, new_present) == (False, True):
987
self.to_file.write("=== added %s '%s'\n" %
988
(kind[1], newpath_encoded))
1003
self.to_file.write(b"=== added %s '%s'\n" %
1004
(kind[1].encode('ascii'), newpath_encoded))
989
1005
oldpath = newpath
991
self.to_file.write("=== renamed %s '%s' => '%s'%s\n" %
992
(kind[0], oldpath_encoded, newpath_encoded, prop_str))
1007
self.to_file.write(b"=== renamed %s '%s' => '%s'%s\n" %
1008
(kind[0].encode('ascii'), oldpath_encoded, newpath_encoded, prop_str))
994
1010
# if it was produced by iter_changes, it must be
995
1011
# modified *somehow*, either content or execute bit.
996
self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
1012
self.to_file.write(b"=== modified %s '%s'%s\n" % (kind[0].encode('ascii'),
997
1013
newpath_encoded, prop_str))
998
1014
if changed_content:
999
self._diff(file_id, oldpath, newpath, kind[0], kind[1])
1015
self._diff(oldpath, newpath, kind[0], kind[1], file_id=file_id)
1000
1016
has_changes = 1
1002
1018
has_changes = 1
1009
1025
:param old_path: The path of the file in the old tree
1010
1026
: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):
1028
if old_path is None:
1015
1029
old_kind = None
1017
new_kind = self.new_tree.kind(file_id)
1018
except (errors.NoSuchId, errors.NoSuchFile):
1031
old_kind = self.old_tree.kind(old_path, file_id)
1032
if new_path is None:
1019
1033
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):
1035
new_kind = self.new_tree.kind(new_path, file_id)
1036
self._diff(old_path, new_path, old_kind, new_kind, file_id=file_id)
1038
def _diff(self, old_path, new_path, old_kind, new_kind, file_id):
1024
1039
result = DiffPath._diff_many(self.differs, file_id, old_path,
1025
1040
new_path, old_kind, new_kind)
1026
1041
if result is DiffPath.CANNOT_DIFF:
added
removed
breezy/diff.py
