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
25
from .lazy_import import lazy_import
23
from bzrlib.lazy_import import lazy_import
26
24
lazy_import(globals(), """
31
branch as _mod_branch,
43
from breezy.workingtree import WorkingTree
44
from breezy.i18n import gettext
43
from bzrlib.workingtree import WorkingTree
47
from .registry import (
46
from bzrlib.registry import (
50
from .trace import mutter, note, warning
51
from .tree import FileTimestampUnavailable
54
DEFAULT_CONTEXT_AMOUNT = 3
49
from bzrlib.symbol_versioning import (
53
from bzrlib.trace import mutter, note, warning
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', context_lines=DEFAULT_CONTEXT_AMOUNT):
78
path_encoding='utf8'):
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
93
99
if sequence_matcher is None:
94
100
sequence_matcher = patiencediff.PatienceSequenceMatcher
95
101
ud = patiencediff.unified_diff(oldlines, newlines,
96
fromfile=old_filename.encode(path_encoding, 'replace'),
97
tofile=new_filename.encode(path_encoding, 'replace'),
98
n=context_lines, sequencematcher=sequence_matcher)
102
fromfile=old_filename.encode(path_encoding),
103
tofile=new_filename.encode(path_encoding),
104
sequencematcher=sequence_matcher)
101
107
if len(ud) == 0: # Identical contents, nothing to do
143
149
stdout=subprocess.PIPE,
147
153
if e.errno == errno.ENOENT:
148
154
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')
188
160
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
191
163
# make sure our own output is properly ordered before the diff
194
oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='brz-diff-old-')
195
newtmp_fd, new_abspath = tempfile.mkstemp(prefix='brz-diff-new-')
166
oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='bzr-diff-old-')
167
newtmp_fd, new_abspath = tempfile.mkstemp(prefix='bzr-diff-new-')
196
168
oldtmpf = os.fdopen(oldtmp_fd, 'wb')
197
169
newtmpf = os.fdopen(newtmp_fd, 'wb')
228
diff_opts = default_style_unified(diff_opts)
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',
231
222
diffcmd.extend(diff_opts)
233
224
pipe = _spawn_external_diff(diffcmd, capture_errors=True)
234
out, err = pipe.communicate()
225
out,err = pipe.communicate()
235
226
rc = pipe.returncode
237
228
# internal_diff() adds a trailing newline, add one here for consistency
276
267
msg = 'exit code %d' % rc
278
269
raise errors.BzrError('external diff failed with %s; command: %r'
283
274
oldtmpf.close() # and delete
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)
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)
300
326
def get_trees_and_branches_to_diff_locked(
301
327
path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
368
394
if old_url is None:
369
395
old_url = default_location
370
396
working_tree, branch, relpath = \
371
controldir.ControlDir.open_containing_tree_or_branch(old_url)
397
bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
372
398
lock_tree_or_branch(working_tree, branch)
373
399
if consider_relpath and relpath != '':
374
400
if working_tree is not None and apply_view:
382
408
new_url = default_location
383
409
if new_url != old_url:
384
410
working_tree, branch, relpath = \
385
controldir.ControlDir.open_containing_tree_or_branch(new_url)
411
bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
386
412
lock_tree_or_branch(working_tree, branch)
387
413
if consider_relpath and relpath != '':
388
414
if working_tree is not None and apply_view:
395
421
# Get the specific files (all files is None, no files is [])
396
422
if make_paths_wt_relative and working_tree is not None:
397
other_paths = working_tree.safe_relpath_files(
424
from bzrlib.builtins import safe_relpath_files
425
other_paths = safe_relpath_files(working_tree, other_paths,
399
426
apply_view=apply_view)
427
except errors.FileInWrongBranch:
428
raise errors.BzrCommandError("Files are in different branches")
400
429
specific_files.extend(other_paths)
401
430
if len(specific_files) == 0:
402
431
specific_files = None
407
436
specific_files = view_files
408
437
view_str = views.view_display_str(view_files)
409
note(gettext("*** Ignoring files outside view. View is %s") % view_str)
438
note("*** Ignoring files outside view. View is %s" % view_str)
411
440
# Get extra trees that ought to be searched for file-ids
412
441
extra_trees = None
413
442
if working_tree is not None and working_tree not in (old_tree, new_tree):
414
443
extra_trees = (working_tree,)
415
return (old_tree, new_tree, old_branch, new_branch,
416
specific_files, extra_trees)
444
return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
419
447
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
463
489
differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
465
491
external_diff_options,
466
old_label, new_label, using,
467
context_lines=context)
492
old_label, new_label, using)
468
493
return differ.show_diff(specific_files, extra_trees)
470
495
new_tree.unlock()
471
496
if extra_trees is not None:
472
497
for tree in extra_trees:
476
503
def _patch_header_date(tree, file_id, path):
477
504
"""Returns a timestamp suitable for use in a patch header."""
479
mtime = tree.get_file_mtime(path, file_id)
480
except FileTimestampUnavailable:
506
mtime = tree.get_file_mtime(file_id, path)
507
except errors.FileTimestampUnavailable:
482
509
return timestamp.format_patch_date(mtime)
596
623
if 'symlink' not in (old_kind, new_kind):
597
624
return self.CANNOT_DIFF
598
625
if old_kind == 'symlink':
599
old_target = self.old_tree.get_symlink_target(old_path, file_id)
626
old_target = self.old_tree.get_symlink_target(file_id)
600
627
elif old_kind is None:
601
628
old_target = None
603
630
return self.CANNOT_DIFF
604
631
if new_kind == 'symlink':
605
new_target = self.new_tree.get_symlink_target(new_path, file_id)
632
new_target = self.new_tree.get_symlink_target(file_id)
606
633
elif new_kind is None:
607
634
new_target = None
626
653
# or removed in a diff.
627
654
EPOCH_DATE = '1970-01-01 00:00:00 +0000'
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):
656
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
657
old_label='', new_label='', text_differ=internal_diff):
632
658
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
633
659
self.text_differ = text_differ
634
660
self.old_label = old_label
635
661
self.new_label = new_label
636
662
self.path_encoding = path_encoding
637
self.context_lines = context_lines
639
664
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
640
665
"""Compare two files in unified diff format
664
689
return self.CANNOT_DIFF
665
690
from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
666
691
to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
667
return self.diff_text(old_path, new_path, from_label, to_label,
668
from_file_id, to_file_id)
692
return self.diff_text(from_file_id, to_file_id, from_label, to_label,
670
def diff_text(self, from_path, to_path, from_label, to_label,
671
from_file_id=None, to_file_id=None):
695
def diff_text(self, from_file_id, to_file_id, from_label, to_label,
696
from_path=None, to_path=None):
672
697
"""Diff the content of given files in two trees
674
:param from_path: The path in the from tree. If None,
699
:param from_file_id: The id of the file in the from tree. If None,
675
700
the file is not present in the from tree.
676
:param to_path: The path in the to tree. This may refer
677
to a different file from from_path. If None,
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,
678
703
the file is not present in the to tree.
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
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.
684
707
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)
689
713
from_text = _get_text(self.old_tree, from_file_id, from_path)
690
714
to_text = _get_text(self.new_tree, to_file_id, to_path)
691
715
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)
694
717
except errors.BinaryFile:
695
718
self.to_file.write(
696
719
("Binary files %s and %s differ\n" %
697
(from_label, to_label)).encode(self.path_encoding, 'replace'))
720
(from_label, to_label)).encode(self.path_encoding))
698
721
return self.CHANGED
704
727
path_encoding='utf-8'):
705
728
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
706
729
self.command_template = command_template
707
self._root = osutils.mkdtemp(prefix='brz-diff-')
730
self._root = osutils.mkdtemp(prefix='bzr-diff-')
710
733
def from_string(klass, command_string, old_tree, new_tree, to_file,
719
def make_from_diff_tree(klass, command_string, external_diff_options=None):
742
def make_from_diff_tree(klass, command_string):
720
743
def from_diff_tree(diff_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,
744
return klass.from_string(command_string, diff_tree.old_tree,
725
745
diff_tree.new_tree, diff_tree.to_file)
726
746
return from_diff_tree
728
748
def _get_command(self, old_path, new_path):
729
749
my_map = {'old_path': old_path, 'new_path': new_path}
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
750
return [AtTemplate(t).substitute(my_map) for t in
751
self.command_template]
743
753
def _execute(self, old_path, new_path):
744
754
command = self._get_command(old_path, new_path)
746
756
proc = subprocess.Popen(command, stdout=subprocess.PIPE,
749
759
if e.errno == errno.ENOENT:
750
760
raise errors.ExecutableMissing(command[0])
761
771
os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
763
773
if e.errno != errno.EEXIST:
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):
777
def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
797
779
if not force_temp and isinstance(tree, WorkingTree):
798
full_path = tree.abspath(relpath)
799
if self._is_safepath(full_path):
802
full_path = self._safe_filename(prefix, relpath)
780
return tree.abspath(tree.id2path(file_id))
782
full_path = osutils.pathjoin(self._root, prefix, relpath)
803
783
if not force_temp and self._try_symlink_root(tree, prefix):
805
785
parent_dir = osutils.dirname(full_path)
807
787
os.makedirs(parent_dir)
809
789
if e.errno != errno.EEXIST:
811
source = tree.get_file(relpath, file_id)
791
source = tree.get_file(file_id, relpath)
813
with open(full_path, 'wb') as target:
793
target = open(full_path, 'wb')
814
795
osutils.pumpfile(source, target)
818
mtime = tree.get_file_mtime(relpath, file_id)
819
except FileTimestampUnavailable:
801
mtime = tree.get_file_mtime(file_id)
802
except errors.FileTimestampUnavailable:
822
805
os.utime(full_path, (mtime, mtime))
824
807
osutils.make_readonly(full_path)
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,
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,
833
816
allow_write=allow_write_new)
834
817
return old_disk_path, new_disk_path
836
819
def finish(self):
838
821
osutils.rmtree(self._root)
840
823
if e.errno != errno.ENOENT:
841
824
mutter("The temporary directory \"%s\" was not "
842
825
"cleanly removed: %s." % (self._root, e))
845
828
if (old_kind, new_kind) != ('file', 'file'):
846
829
return DiffPath.CANNOT_DIFF
847
830
(old_disk_path, new_disk_path) = self._prepare_files(
848
old_path, new_path, file_id=file_id)
831
file_id, old_path, new_path)
849
832
self._execute(old_disk_path, new_disk_path)
851
def edit_file(self, old_path, new_path, file_id=None):
834
def edit_file(self, file_id):
852
835
"""Use this tool to edit a file.
854
837
A temporary copy will be edited, and the new contents will be
857
840
:param file_id: The id of the file to edit.
858
841
:return: The new contents of the file.
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)
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))
864
850
subprocess.call(command, cwd=self._root)
865
with open(new_abs_path, 'rb') as new_file:
851
new_file = open(new_abs_path, 'r')
866
853
return new_file.read()
869
858
class DiffTree(object):
912
901
def from_trees_options(klass, old_tree, new_tree, to_file,
913
902
path_encoding, external_diff_options, old_label,
914
new_label, using, context_lines):
915
904
"""Factory for producing a DiffTree.
917
906
Designed to accept options used by show_diff_trees.
919
907
:param old_tree: The tree to show as old in the comparison
920
908
:param new_tree: The tree to show as new in the comparison
921
909
:param to_file: File to write comparisons to
927
915
:param using: Commandline to use to invoke an external diff tool
929
917
if using is not None:
930
extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
918
extra_factories = [DiffFromTool.make_from_diff_tree(using)]
932
920
extra_factories = []
933
921
if external_diff_options:
934
922
opts = external_diff_options.split()
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.
923
def diff_file(olab, olines, nlab, nlines, to_file):
939
924
external_diff(olab, olines, nlab, nlines, to_file, opts)
941
926
diff_file = internal_diff
942
927
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
943
old_label, new_label, diff_file, context_lines=context_lines)
928
old_label, new_label, diff_file)
944
929
return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
990
975
properties_changed.extend(get_executable_change(executable[0], executable[1]))
992
977
if properties_changed:
993
prop_str = b" (properties changed: %s)" % (
994
b", ".join(properties_changed),)
978
prop_str = " (properties changed: %s)" % (", ".join(properties_changed),)
998
982
if (old_present, new_present) == (True, False):
999
self.to_file.write(b"=== removed %s '%s'\n" %
1000
(kind[0].encode('ascii'), oldpath_encoded))
983
self.to_file.write("=== removed %s '%s'\n" %
984
(kind[0], oldpath_encoded))
1001
985
newpath = oldpath
1002
986
elif (old_present, new_present) == (False, True):
1003
self.to_file.write(b"=== added %s '%s'\n" %
1004
(kind[1].encode('ascii'), newpath_encoded))
987
self.to_file.write("=== added %s '%s'\n" %
988
(kind[1], newpath_encoded))
1005
989
oldpath = newpath
1007
self.to_file.write(b"=== renamed %s '%s' => '%s'%s\n" %
1008
(kind[0].encode('ascii'), oldpath_encoded, newpath_encoded, prop_str))
991
self.to_file.write("=== renamed %s '%s' => '%s'%s\n" %
992
(kind[0], oldpath_encoded, newpath_encoded, prop_str))
1010
994
# if it was produced by iter_changes, it must be
1011
995
# modified *somehow*, either content or execute bit.
1012
self.to_file.write(b"=== modified %s '%s'%s\n" % (kind[0].encode('ascii'),
996
self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
1013
997
newpath_encoded, prop_str))
1014
998
if changed_content:
1015
self._diff(oldpath, newpath, kind[0], kind[1], file_id=file_id)
999
self._diff(file_id, oldpath, newpath, kind[0], kind[1])
1016
1000
has_changes = 1
1018
1002
has_changes = 1
1025
1009
:param old_path: The path of the file in the old tree
1026
1010
:param new_path: The path of the file in the new tree
1028
if old_path is None:
1013
old_kind = self.old_tree.kind(file_id)
1014
except (errors.NoSuchId, errors.NoSuchFile):
1029
1015
old_kind = None
1031
old_kind = self.old_tree.kind(old_path, file_id)
1032
if new_path is None:
1017
new_kind = self.new_tree.kind(file_id)
1018
except (errors.NoSuchId, errors.NoSuchFile):
1033
1019
new_kind = None
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):
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):
1039
1024
result = DiffPath._diff_many(self.differs, file_id, old_path,
1040
1025
new_path, old_kind, new_kind)
1041
1026
if result is DiffPath.CANNOT_DIFF:
added
removed
bzrlib/diff.py
