← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Tarmac
  • Author(s): Vincent Ladeuil
  • Date: 2017-01-30 14:42:05 UTC
  • mfrom: (6620.1.1 trunk)
  • Revision ID: tarmac-20170130144205-r8fh2xpmiuxyozpv
Merge  2.7 into trunk including fix for bug #1657238 [r=vila]

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd.
 
1
# Copyright (C) 2005-2014 Canonical Ltd.
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
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
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
import difflib
18
20
import os
19
21
import re
25
27
import errno
26
28
import subprocess
27
29
import tempfile
28
 
import time
29
30
 
30
31
from bzrlib import (
31
 
    branch as _mod_branch,
32
 
    bzrdir,
 
32
    cleanup,
33
33
    cmdline,
34
 
    cleanup,
 
34
    controldir,
35
35
    errors,
36
36
    osutils,
37
37
    patiencediff,
41
41
    )
42
42
 
43
43
from bzrlib.workingtree import WorkingTree
 
44
from bzrlib.i18n import gettext
44
45
""")
45
46
 
46
47
from bzrlib.registry import (
47
48
    Registry,
48
49
    )
49
 
from bzrlib.symbol_versioning import (
50
 
    deprecated_function,
51
 
    deprecated_in,
52
 
    )
53
50
from bzrlib.trace import mutter, note, warning
54
51
 
 
52
DEFAULT_CONTEXT_AMOUNT = 3
55
53
 
56
54
class AtTemplate(string.Template):
57
55
    """Templating class that uses @ instead of $."""
75
73
 
76
74
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
77
75
                  allow_binary=False, sequence_matcher=None,
78
 
                  path_encoding='utf8'):
 
76
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
79
77
    # FIXME: difflib is wrong if there is no trailing newline.
80
78
    # The syntax used by patch seems to be "\ No newline at
81
79
    # end of file" following the last diff line from that
99
97
    if sequence_matcher is None:
100
98
        sequence_matcher = patiencediff.PatienceSequenceMatcher
101
99
    ud = patiencediff.unified_diff(oldlines, newlines,
102
 
                      fromfile=old_filename.encode(path_encoding),
103
 
                      tofile=new_filename.encode(path_encoding),
104
 
                      sequencematcher=sequence_matcher)
 
100
                      fromfile=old_filename.encode(path_encoding, 'replace'),
 
101
                      tofile=new_filename.encode(path_encoding, 'replace'),
 
102
                      n=context_lines, sequencematcher=sequence_matcher)
105
103
 
106
104
    ud = list(ud)
107
105
    if len(ud) == 0: # Identical contents, nothing to do
121
119
 
122
120
 
123
121
def _spawn_external_diff(diffcmd, capture_errors=True):
124
 
    """Spawn the externall diff process, and return the child handle.
 
122
    """Spawn the external diff process, and return the child handle.
125
123
 
126
124
    :param diffcmd: The command list to spawn
127
125
    :param capture_errors: Capture stderr as well as setting LANG=C
156
154
 
157
155
    return pipe
158
156
 
 
157
# diff style options as of GNU diff v3.2
 
158
style_option_list = ['-c', '-C', '--context',
 
159
                     '-e', '--ed',
 
160
                     '-f', '--forward-ed',
 
161
                     '-q', '--brief',
 
162
                     '--normal',
 
163
                     '-n', '--rcs',
 
164
                     '-u', '-U', '--unified',
 
165
                     '-y', '--side-by-side',
 
166
                     '-D', '--ifdef']
 
167
 
 
168
def default_style_unified(diff_opts):
 
169
    """Default to unified diff style if alternative not specified in diff_opts.
 
170
 
 
171
        diff only allows one style to be specified; they don't override.
 
172
        Note that some of these take optargs, and the optargs can be
 
173
        directly appended to the options.
 
174
        This is only an approximate parser; it doesn't properly understand
 
175
        the grammar.
 
176
 
 
177
    :param diff_opts: List of options for external (GNU) diff.
 
178
    :return: List of options with default style=='unified'.
 
179
    """
 
180
    for s in style_option_list:
 
181
        for j in diff_opts:
 
182
            if j.startswith(s):
 
183
                break
 
184
        else:
 
185
            continue
 
186
        break
 
187
    else:
 
188
        diff_opts.append('-u')
 
189
    return diff_opts
 
190
 
159
191
 
160
192
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
161
193
                  diff_opts):
197
229
                   '--binary',
198
230
                  ]
199
231
 
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
204
 
        # the grammar.
205
 
        for s in ['-c', '-u', '-C', '-U',
206
 
                  '-e', '--ed',
207
 
                  '-q', '--brief',
208
 
                  '--normal',
209
 
                  '-n', '--rcs',
210
 
                  '-y', '--side-by-side',
211
 
                  '-D', '--ifdef']:
212
 
            for j in diff_opts:
213
 
                if j.startswith(s):
214
 
                    break
215
 
            else:
216
 
                continue
217
 
            break
218
 
        else:
219
 
            diffcmd.append('-u')
 
232
        diff_opts = default_style_unified(diff_opts)
220
233
 
221
234
        if diff_opts:
222
235
            diffcmd.extend(diff_opts)
267
280
                msg = 'exit code %d' % rc
268
281
 
269
282
            raise errors.BzrError('external diff failed with %s; command: %r'
270
 
                                  % (rc, diffcmd))
 
283
                                  % (msg, diffcmd))
271
284
 
272
285
 
273
286
    finally:
274
287
        oldtmpf.close()                 # and delete
275
288
        newtmpf.close()
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)
279
 
        try:
280
 
            os.remove(old_abspath)
281
 
        except OSError, e:
282
 
            if e.errno not in (errno.ENOENT,):
283
 
                warning('Failed to delete temporary file: %s %s',
284
 
                        old_abspath, e)
285
 
        try:
286
 
            os.remove(new_abspath)
287
 
        except OSError:
288
 
            if e.errno not in (errno.ENOENT,):
289
 
                warning('Failed to delete temporary file: %s %s',
290
 
                        new_abspath, e)
291
 
 
292
 
 
293
 
@deprecated_function(deprecated_in((2, 2, 0)))
294
 
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
295
 
                                   apply_view=True):
296
 
    """Get the trees and specific files to diff given a list of paths.
297
 
 
298
 
    This method works out the trees to be diff'ed and the files of
299
 
    interest within those trees.
300
 
 
301
 
    :param path_list:
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.
306
 
    :param old_url:
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.
309
 
    :param new_url:
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.
312
 
    :param apply_view:
313
 
        if True and a view is set, apply the view or check that the paths
314
 
        are within it
315
 
    :returns:
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
319
 
        are not locked.
320
 
    """
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)
324
 
    
 
289
 
 
290
        def cleanup(path):
 
291
            # Warn in case the file couldn't be deleted (in case windows still
 
292
            # holds the file open, but not if the files have already been
 
293
            # deleted)
 
294
            try:
 
295
                os.remove(path)
 
296
            except OSError, e:
 
297
                if e.errno not in (errno.ENOENT,):
 
298
                    warning('Failed to delete temporary file: %s %s', path, e)
 
299
 
 
300
        cleanup(old_abspath)
 
301
        cleanup(new_abspath)
 
302
 
325
303
 
326
304
def get_trees_and_branches_to_diff_locked(
327
305
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
394
372
    if old_url is None:
395
373
        old_url = default_location
396
374
    working_tree, branch, relpath = \
397
 
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
 
375
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
398
376
    lock_tree_or_branch(working_tree, branch)
399
377
    if consider_relpath and relpath != '':
400
378
        if working_tree is not None and apply_view:
408
386
        new_url = default_location
409
387
    if new_url != old_url:
410
388
        working_tree, branch, relpath = \
411
 
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
 
389
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
412
390
        lock_tree_or_branch(working_tree, branch)
413
391
        if consider_relpath and relpath != '':
414
392
            if working_tree is not None and apply_view:
420
398
 
421
399
    # Get the specific files (all files is None, no files is [])
422
400
    if make_paths_wt_relative and working_tree is not None:
423
 
        try:
424
 
            from bzrlib.builtins import safe_relpath_files
425
 
            other_paths = safe_relpath_files(working_tree, other_paths,
 
401
        other_paths = working_tree.safe_relpath_files(
 
402
            other_paths,
426
403
            apply_view=apply_view)
427
 
        except errors.FileInWrongBranch:
428
 
            raise errors.BzrCommandError("Files are in different branches")
429
404
    specific_files.extend(other_paths)
430
405
    if len(specific_files) == 0:
431
406
        specific_files = None
435
410
            if view_files:
436
411
                specific_files = view_files
437
412
                view_str = views.view_display_str(view_files)
438
 
                note("*** Ignoring files outside view. View is %s" % view_str)
 
413
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
439
414
 
440
415
    # Get extra trees that ought to be searched for file-ids
441
416
    extra_trees = None
442
417
    if working_tree is not None and working_tree not in (old_tree, new_tree):
443
418
        extra_trees = (working_tree,)
444
 
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
 
419
    return (old_tree, new_tree, old_branch, new_branch,
 
420
            specific_files, extra_trees)
445
421
 
446
422
 
447
423
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
464
440
                    extra_trees=None,
465
441
                    path_encoding='utf8',
466
442
                    using=None,
467
 
                    format_cls=None):
 
443
                    format_cls=None,
 
444
                    context=DEFAULT_CONTEXT_AMOUNT):
468
445
    """Show in text form the changes from one tree to another.
469
446
 
470
447
    :param to_file: The output stream.
471
 
    :param specific_files:Include only changes to these files - None for all
 
448
    :param specific_files: Include only changes to these files - None for all
472
449
        changes.
473
450
    :param external_diff_options: If set, use an external GNU diff and pass 
474
451
        these options.
477
454
        otherwise is supposed to be utf8
478
455
    :param format_cls: Formatter class (DiffTree subclass)
479
456
    """
 
457
    if context is None:
 
458
        context = DEFAULT_CONTEXT_AMOUNT
480
459
    if format_cls is None:
481
460
        format_cls = DiffTree
482
461
    old_tree.lock_read()
489
468
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
490
469
                                                   path_encoding,
491
470
                                                   external_diff_options,
492
 
                                                   old_label, new_label, using)
 
471
                                                   old_label, new_label, using,
 
472
                                                   context_lines=context)
493
473
            return differ.show_diff(specific_files, extra_trees)
494
474
        finally:
495
475
            new_tree.unlock()
653
633
    # or removed in a diff.
654
634
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
655
635
 
656
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
657
 
                 old_label='', new_label='', text_differ=internal_diff):
 
636
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8', 
 
637
                 old_label='', new_label='', text_differ=internal_diff, 
 
638
                 context_lines=DEFAULT_CONTEXT_AMOUNT):
658
639
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
659
640
        self.text_differ = text_differ
660
641
        self.old_label = old_label
661
642
        self.new_label = new_label
662
643
        self.path_encoding = path_encoding
 
644
        self.context_lines = context_lines
663
645
 
664
646
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
665
647
        """Compare two files in unified diff format
706
688
        """
707
689
        def _get_text(tree, file_id, path):
708
690
            if file_id is not None:
709
 
                return tree.get_file(file_id, path).readlines()
 
691
                return tree.get_file_lines(file_id, path)
710
692
            else:
711
693
                return []
712
694
        try:
713
695
            from_text = _get_text(self.old_tree, from_file_id, from_path)
714
696
            to_text = _get_text(self.new_tree, to_file_id, to_path)
715
697
            self.text_differ(from_label, from_text, to_label, to_text,
716
 
                             self.to_file)
 
698
                             self.to_file, path_encoding=self.path_encoding,
 
699
                             context_lines=self.context_lines)
717
700
        except errors.BinaryFile:
718
701
            self.to_file.write(
719
702
                  ("Binary files %s and %s differ\n" %
720
 
                  (from_label, to_label)).encode(self.path_encoding))
 
703
                  (from_label, to_label)).encode(self.path_encoding,'replace'))
721
704
        return self.CHANGED
722
705
 
723
706
 
739
722
                     path_encoding)
740
723
 
741
724
    @classmethod
742
 
    def make_from_diff_tree(klass, command_string):
 
725
    def make_from_diff_tree(klass, command_string, external_diff_options=None):
743
726
        def from_diff_tree(diff_tree):
744
 
            return klass.from_string(command_string, diff_tree.old_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,
745
731
                                     diff_tree.new_tree, diff_tree.to_file)
746
732
        return from_diff_tree
747
733
 
748
734
    def _get_command(self, old_path, new_path):
749
735
        my_map = {'old_path': old_path, 'new_path': new_path}
750
 
        return [AtTemplate(t).substitute(my_map) for t in
751
 
                self.command_template]
 
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
 
739
            command_encoded = []
 
740
            for c in command:
 
741
                if isinstance(c, unicode):
 
742
                    command_encoded.append(c.encode('mbcs'))
 
743
                else:
 
744
                    command_encoded.append(c)
 
745
            return command_encoded
 
746
        else:
 
747
            return command
752
748
 
753
749
    def _execute(self, old_path, new_path):
754
750
        command = self._get_command(old_path, new_path)
774
770
                raise
775
771
        return True
776
772
 
 
773
    @staticmethod
 
774
    def _fenc():
 
775
        """Returns safe encoding for passing file path to diff tool"""
 
776
        if sys.platform == 'win32':
 
777
            return 'mbcs'
 
778
        else:
 
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'
 
782
 
 
783
    def _is_safepath(self, path):
 
784
        """Return true if `path` may be able to pass to subprocess."""
 
785
        fenc = self._fenc()
 
786
        try:
 
787
            return path == path.encode(fenc).decode(fenc)
 
788
        except UnicodeError:
 
789
            return False
 
790
 
 
791
    def _safe_filename(self, prefix, relpath):
 
792
        """Replace unsafe character in `relpath` then join `self._root`,
 
793
        `prefix` and `relpath`."""
 
794
        fenc = self._fenc()
 
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)
 
800
 
777
801
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
778
802
                    allow_write=False):
779
803
        if not force_temp and isinstance(tree, WorkingTree):
780
 
            return tree.abspath(tree.id2path(file_id))
781
 
        
782
 
        full_path = osutils.pathjoin(self._root, prefix, relpath)
 
804
            full_path = tree.abspath(tree.id2path(file_id))
 
805
            if self._is_safepath(full_path):
 
806
                return full_path
 
807
 
 
808
        full_path = self._safe_filename(prefix, relpath)
783
809
        if not force_temp and self._try_symlink_root(tree, prefix):
784
810
            return full_path
785
811
        parent_dir = osutils.dirname(full_path)
842
868
        """
843
869
        old_path = self.old_tree.id2path(file_id)
844
870
        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,
847
 
                                           force_temp=True)[1]
848
 
        command = self._get_command(osutils.pathjoin('old', old_path),
849
 
                                    osutils.pathjoin('new', new_path))
 
871
        old_abs_path, new_abs_path = self._prepare_files(
 
872
                                            file_id, old_path, new_path,
 
873
                                            allow_write_new=True,
 
874
                                            force_temp=True)
 
875
        command = self._get_command(old_abs_path, new_abs_path)
850
876
        subprocess.call(command, cwd=self._root)
851
 
        new_file = open(new_abs_path, 'r')
 
877
        new_file = open(new_abs_path, 'rb')
852
878
        try:
853
879
            return new_file.read()
854
880
        finally:
900
926
    @classmethod
901
927
    def from_trees_options(klass, old_tree, new_tree, to_file,
902
928
                           path_encoding, external_diff_options, old_label,
903
 
                           new_label, using):
 
929
                           new_label, using, context_lines):
904
930
        """Factory for producing a DiffTree.
905
931
 
906
932
        Designed to accept options used by show_diff_trees.
 
933
 
907
934
        :param old_tree: The tree to show as old in the comparison
908
935
        :param new_tree: The tree to show as new in the comparison
909
936
        :param to_file: File to write comparisons to
915
942
        :param using: Commandline to use to invoke an external diff tool
916
943
        """
917
944
        if using is not None:
918
 
            extra_factories = [DiffFromTool.make_from_diff_tree(using)]
 
945
            extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
919
946
        else:
920
947
            extra_factories = []
921
948
        if external_diff_options:
922
949
            opts = external_diff_options.split()
923
 
            def diff_file(olab, olines, nlab, nlines, to_file):
 
950
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
 
951
                """:param path_encoding: not used but required
 
952
                        to match the signature of internal_diff.
 
953
                """
924
954
                external_diff(olab, olines, nlab, nlines, to_file, opts)
925
955
        else:
926
956
            diff_file = internal_diff
927
957
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
928
 
                             old_label, new_label, diff_file)
 
958
                             old_label, new_label, diff_file, context_lines=context_lines)
929
959
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
930
960
                     extra_factories)
931
961