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
99
99
if sequence_matcher is None:
100
100
sequence_matcher = patiencediff.PatienceSequenceMatcher
101
101
ud = patiencediff.unified_diff(oldlines, newlines,
102
fromfile=old_filename.encode(path_encoding, 'replace'),
103
tofile=new_filename.encode(path_encoding, 'replace'),
104
n=context_lines, sequencematcher=sequence_matcher)
102
fromfile=old_filename.encode(path_encoding),
103
tofile=new_filename.encode(path_encoding),
104
sequencematcher=sequence_matcher)
107
107
if len(ud) == 0: # Identical contents, nothing to do
149
149
stdout=subprocess.PIPE,
153
153
if e.errno == errno.ENOENT:
154
154
raise errors.NoDiff(str(e))
159
# diff style options as of GNU diff v3.2
160
style_option_list = ['-c', '-C', '--context',
162
'-f', '--forward-ed',
166
'-u', '-U', '--unified',
167
'-y', '--side-by-side',
170
def default_style_unified(diff_opts):
171
"""Default to unified diff style if alternative not specified in diff_opts.
173
diff only allows one style to be specified; they don't override.
174
Note that some of these take optargs, and the optargs can be
175
directly appended to the options.
176
This is only an approximate parser; it doesn't properly understand
179
:param diff_opts: List of options for external (GNU) diff.
180
:return: List of options with default style=='unified'.
182
for s in style_option_list:
190
diff_opts.append('-u')
194
160
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
197
163
# make sure our own output is properly ordered before the diff
200
oldtmp_fd, old_abspath = tempfile.mkstemp(prefix='brz-diff-old-')
201
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-')
202
168
oldtmpf = os.fdopen(oldtmp_fd, 'wb')
203
169
newtmpf = os.fdopen(newtmp_fd, 'wb')
234
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',
237
222
diffcmd.extend(diff_opts)
239
224
pipe = _spawn_external_diff(diffcmd, capture_errors=True)
240
out, err = pipe.communicate()
225
out,err = pipe.communicate()
241
226
rc = pipe.returncode
243
228
# internal_diff() adds a trailing newline, add one here for consistency
282
267
msg = 'exit code %d' % rc
284
269
raise errors.BzrError('external diff failed with %s; command: %r'
289
274
oldtmpf.close() # and delete
293
# Warn in case the file couldn't be deleted (in case windows still
294
# holds the file open, but not if the files have already been
299
if e.errno not in (errno.ENOENT,):
300
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)
306
326
def get_trees_and_branches_to_diff_locked(
307
327
path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
374
394
if old_url is None:
375
395
old_url = default_location
376
396
working_tree, branch, relpath = \
377
controldir.ControlDir.open_containing_tree_or_branch(old_url)
397
bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
378
398
lock_tree_or_branch(working_tree, branch)
379
399
if consider_relpath and relpath != '':
380
400
if working_tree is not None and apply_view:
388
408
new_url = default_location
389
409
if new_url != old_url:
390
410
working_tree, branch, relpath = \
391
controldir.ControlDir.open_containing_tree_or_branch(new_url)
411
bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
392
412
lock_tree_or_branch(working_tree, branch)
393
413
if consider_relpath and relpath != '':
394
414
if working_tree is not None and apply_view:
401
421
# Get the specific files (all files is None, no files is [])
402
422
if make_paths_wt_relative and working_tree is not None:
403
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,
405
426
apply_view=apply_view)
427
except errors.FileInWrongBranch:
428
raise errors.BzrCommandError("Files are in different branches")
406
429
specific_files.extend(other_paths)
407
430
if len(specific_files) == 0:
408
431
specific_files = None
413
436
specific_files = view_files
414
437
view_str = views.view_display_str(view_files)
415
note(gettext("*** Ignoring files outside view. View is %s") % view_str)
438
note("*** Ignoring files outside view. View is %s" % view_str)
417
440
# Get extra trees that ought to be searched for file-ids
418
441
extra_trees = None
419
442
if working_tree is not None and working_tree not in (old_tree, new_tree):
420
443
extra_trees = (working_tree,)
421
return (old_tree, new_tree, old_branch, new_branch,
422
specific_files, extra_trees)
444
return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
425
447
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
469
489
differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
471
491
external_diff_options,
472
old_label, new_label, using,
473
context_lines=context)
492
old_label, new_label, using)
474
493
return differ.show_diff(specific_files, extra_trees)
476
495
new_tree.unlock()
477
496
if extra_trees is not None:
478
497
for tree in extra_trees:
482
503
def _patch_header_date(tree, file_id, path):
483
504
"""Returns a timestamp suitable for use in a patch header."""
485
mtime = tree.get_file_mtime(path, file_id)
486
except FileTimestampUnavailable:
506
mtime = tree.get_file_mtime(file_id, path)
507
except errors.FileTimestampUnavailable:
488
509
return timestamp.format_patch_date(mtime)
602
623
if 'symlink' not in (old_kind, new_kind):
603
624
return self.CANNOT_DIFF
604
625
if old_kind == 'symlink':
605
old_target = self.old_tree.get_symlink_target(old_path, file_id)
626
old_target = self.old_tree.get_symlink_target(file_id)
606
627
elif old_kind is None:
607
628
old_target = None
609
630
return self.CANNOT_DIFF
610
631
if new_kind == 'symlink':
611
new_target = self.new_tree.get_symlink_target(new_path, file_id)
632
new_target = self.new_tree.get_symlink_target(file_id)
612
633
elif new_kind is None:
613
634
new_target = None
632
653
# or removed in a diff.
633
654
EPOCH_DATE = '1970-01-01 00:00:00 +0000'
635
def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
636
old_label='', new_label='', text_differ=internal_diff,
637
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):
638
658
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
639
659
self.text_differ = text_differ
640
660
self.old_label = old_label
641
661
self.new_label = new_label
642
662
self.path_encoding = path_encoding
643
self.context_lines = context_lines
645
664
def diff(self, file_id, old_path, new_path, old_kind, new_kind):
646
665
"""Compare two files in unified diff format
670
689
return self.CANNOT_DIFF
671
690
from_label = '%s%s\t%s' % (self.old_label, old_path, old_date)
672
691
to_label = '%s%s\t%s' % (self.new_label, new_path, new_date)
673
return self.diff_text(old_path, new_path, from_label, to_label,
674
from_file_id, to_file_id)
692
return self.diff_text(from_file_id, to_file_id, from_label, to_label,
676
def diff_text(self, from_path, to_path, from_label, to_label,
677
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):
678
697
"""Diff the content of given files in two trees
680
: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,
681
700
the file is not present in the from tree.
682
:param to_path: The path in the to tree. This may refer
683
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,
684
703
the file is not present in the to tree.
685
:param from_file_id: The id of the file in the from tree or None if
687
: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.
690
707
def _get_text(tree, file_id, path):
708
if file_id is not None:
709
return tree.get_file(file_id, path).readlines()
693
return tree.get_file_lines(path, file_id)
695
713
from_text = _get_text(self.old_tree, from_file_id, from_path)
696
714
to_text = _get_text(self.new_tree, to_file_id, to_path)
697
715
self.text_differ(from_label, from_text, to_label, to_text,
698
self.to_file, path_encoding=self.path_encoding,
699
context_lines=self.context_lines)
700
717
except errors.BinaryFile:
701
718
self.to_file.write(
702
719
("Binary files %s and %s differ\n" %
703
(from_label, to_label)).encode(self.path_encoding, 'replace'))
720
(from_label, to_label)).encode(self.path_encoding))
704
721
return self.CHANGED
710
727
path_encoding='utf-8'):
711
728
DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
712
729
self.command_template = command_template
713
self._root = osutils.mkdtemp(prefix='brz-diff-')
730
self._root = osutils.mkdtemp(prefix='bzr-diff-')
716
733
def from_string(klass, command_string, old_tree, new_tree, to_file,
725
def make_from_diff_tree(klass, command_string, external_diff_options=None):
742
def make_from_diff_tree(klass, command_string):
726
743
def from_diff_tree(diff_tree):
727
full_command_string = [command_string]
728
if external_diff_options is not None:
729
full_command_string += ' ' + external_diff_options
730
return klass.from_string(full_command_string, diff_tree.old_tree,
744
return klass.from_string(command_string, diff_tree.old_tree,
731
745
diff_tree.new_tree, diff_tree.to_file)
732
746
return from_diff_tree
734
748
def _get_command(self, old_path, new_path):
735
749
my_map = {'old_path': old_path, 'new_path': new_path}
736
command = [AtTemplate(t).substitute(my_map) for t in
737
self.command_template]
738
if sys.platform == 'win32': # Popen doesn't accept unicode on win32
741
if isinstance(c, unicode):
742
command_encoded.append(c.encode('mbcs'))
744
command_encoded.append(c)
745
return command_encoded
750
return [AtTemplate(t).substitute(my_map) for t in
751
self.command_template]
749
753
def _execute(self, old_path, new_path):
750
754
command = self._get_command(old_path, new_path)
752
756
proc = subprocess.Popen(command, stdout=subprocess.PIPE,
755
759
if e.errno == errno.ENOENT:
756
760
raise errors.ExecutableMissing(command[0])
767
771
os.symlink(tree.abspath(''), osutils.pathjoin(self._root, prefix))
769
773
if e.errno != errno.EEXIST:
775
"""Returns safe encoding for passing file path to diff tool"""
776
if sys.platform == 'win32':
779
# Don't fallback to 'utf-8' because subprocess may not be able to
780
# handle utf-8 correctly when locale is not utf-8.
781
return sys.getfilesystemencoding() or 'ascii'
783
def _is_safepath(self, path):
784
"""Return true if `path` may be able to pass to subprocess."""
787
return path == path.encode(fenc).decode(fenc)
791
def _safe_filename(self, prefix, relpath):
792
"""Replace unsafe character in `relpath` then join `self._root`,
793
`prefix` and `relpath`."""
795
# encoded_str.replace('?', '_') may break multibyte char.
796
# So we should encode, decode, then replace(u'?', u'_')
797
relpath_tmp = relpath.encode(fenc, 'replace').decode(fenc, 'replace')
798
relpath_tmp = relpath_tmp.replace(u'?', u'_')
799
return osutils.pathjoin(self._root, prefix, relpath_tmp)
801
def _write_file(self, relpath, tree, prefix, force_temp=False,
802
allow_write=False, file_id=None):
777
def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
803
779
if not force_temp and isinstance(tree, WorkingTree):
804
full_path = tree.abspath(relpath)
805
if self._is_safepath(full_path):
808
full_path = self._safe_filename(prefix, relpath)
780
return tree.abspath(tree.id2path(file_id))
782
full_path = osutils.pathjoin(self._root, prefix, relpath)
809
783
if not force_temp and self._try_symlink_root(tree, prefix):
811
785
parent_dir = osutils.dirname(full_path)
813
787
os.makedirs(parent_dir)
815
789
if e.errno != errno.EEXIST:
817
source = tree.get_file(relpath, file_id)
791
source = tree.get_file(file_id, relpath)
819
with open(full_path, 'wb') as target:
793
target = open(full_path, 'wb')
820
795
osutils.pumpfile(source, target)
824
mtime = tree.get_file_mtime(relpath, file_id)
825
except FileTimestampUnavailable:
801
mtime = tree.get_file_mtime(file_id)
802
except errors.FileTimestampUnavailable:
828
805
os.utime(full_path, (mtime, mtime))
830
807
osutils.make_readonly(full_path)
833
def _prepare_files(self, old_path, new_path, force_temp=False,
834
allow_write_new=False, file_id=None):
835
old_disk_path = self._write_file(old_path, self.old_tree, 'old',
836
force_temp, file_id=file_id)
837
new_disk_path = self._write_file(new_path, self.new_tree, 'new',
838
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,
839
816
allow_write=allow_write_new)
840
817
return old_disk_path, new_disk_path
842
819
def finish(self):
844
821
osutils.rmtree(self._root)
846
823
if e.errno != errno.ENOENT:
847
824
mutter("The temporary directory \"%s\" was not "
848
825
"cleanly removed: %s." % (self._root, e))
851
828
if (old_kind, new_kind) != ('file', 'file'):
852
829
return DiffPath.CANNOT_DIFF
853
830
(old_disk_path, new_disk_path) = self._prepare_files(
854
old_path, new_path, file_id=file_id)
831
file_id, old_path, new_path)
855
832
self._execute(old_disk_path, new_disk_path)
857
def edit_file(self, old_path, new_path, file_id=None):
834
def edit_file(self, file_id):
858
835
"""Use this tool to edit a file.
860
837
A temporary copy will be edited, and the new contents will be
863
840
:param file_id: The id of the file to edit.
864
841
:return: The new contents of the file.
866
old_abs_path, new_abs_path = self._prepare_files(
867
old_path, new_path, allow_write_new=True, force_temp=True,
869
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))
870
850
subprocess.call(command, cwd=self._root)
871
with open(new_abs_path, 'rb') as new_file:
851
new_file = open(new_abs_path, 'r')
872
853
return new_file.read()
875
858
class DiffTree(object):
918
901
def from_trees_options(klass, old_tree, new_tree, to_file,
919
902
path_encoding, external_diff_options, old_label,
920
new_label, using, context_lines):
921
904
"""Factory for producing a DiffTree.
923
906
Designed to accept options used by show_diff_trees.
925
907
:param old_tree: The tree to show as old in the comparison
926
908
:param new_tree: The tree to show as new in the comparison
927
909
:param to_file: File to write comparisons to
933
915
:param using: Commandline to use to invoke an external diff tool
935
917
if using is not None:
936
extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
918
extra_factories = [DiffFromTool.make_from_diff_tree(using)]
938
920
extra_factories = []
939
921
if external_diff_options:
940
922
opts = external_diff_options.split()
941
def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
942
""":param path_encoding: not used but required
943
to match the signature of internal_diff.
923
def diff_file(olab, olines, nlab, nlines, to_file):
945
924
external_diff(olab, olines, nlab, nlines, to_file, opts)
947
926
diff_file = internal_diff
948
927
diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
949
old_label, new_label, diff_file, context_lines=context_lines)
928
old_label, new_label, diff_file)
950
929
return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
1017
996
self.to_file.write("=== modified %s '%s'%s\n" % (kind[0],
1018
997
newpath_encoded, prop_str))
1019
998
if changed_content:
1020
self._diff(oldpath, newpath, kind[0], kind[1], file_id=file_id)
999
self._diff(file_id, oldpath, newpath, kind[0], kind[1])
1021
1000
has_changes = 1
1023
1002
has_changes = 1
1030
1009
:param old_path: The path of the file in the old tree
1031
1010
:param new_path: The path of the file in the new tree
1033
if old_path is None:
1013
old_kind = self.old_tree.kind(file_id)
1014
except (errors.NoSuchId, errors.NoSuchFile):
1034
1015
old_kind = None
1036
old_kind = self.old_tree.kind(old_path, file_id)
1037
if new_path is None:
1017
new_kind = self.new_tree.kind(file_id)
1018
except (errors.NoSuchId, errors.NoSuchFile):
1038
1019
new_kind = None
1040
new_kind = self.new_tree.kind(new_path, file_id)
1041
self._diff(old_path, new_path, old_kind, new_kind, file_id=file_id)
1043
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):
1044
1024
result = DiffPath._diff_many(self.differs, file_id, old_path,
1045
1025
new_path, old_kind, new_kind)
1046
1026
if result is DiffPath.CANNOT_DIFF:
added
removed
bzrlib/diff.py
