← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
1
 
# Copyright (C) 2005-2011 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
27
29
import tempfile
28
30
 
29
31
from bzrlib import (
30
 
    bzrdir,
 
32
    cleanup,
31
33
    cmdline,
32
 
    cleanup,
 
34
    controldir,
33
35
    errors,
34
36
    osutils,
35
37
    patiencediff,
39
41
    )
40
42
 
41
43
from bzrlib.workingtree import WorkingTree
 
44
from bzrlib.i18n import gettext
42
45
""")
43
46
 
44
47
from bzrlib.registry import (
45
48
    Registry,
46
49
    )
47
 
from bzrlib.symbol_versioning import (
48
 
    deprecated_function,
49
 
    deprecated_in,
50
 
    )
51
50
from bzrlib.trace import mutter, note, warning
52
51
 
 
52
DEFAULT_CONTEXT_AMOUNT = 3
53
53
 
54
54
class AtTemplate(string.Template):
55
55
    """Templating class that uses @ instead of $."""
73
73
 
74
74
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
75
75
                  allow_binary=False, sequence_matcher=None,
76
 
                  path_encoding='utf8'):
 
76
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
77
77
    # FIXME: difflib is wrong if there is no trailing newline.
78
78
    # The syntax used by patch seems to be "\ No newline at
79
79
    # end of file" following the last diff line from that
99
99
    ud = patiencediff.unified_diff(oldlines, newlines,
100
100
                      fromfile=old_filename.encode(path_encoding, 'replace'),
101
101
                      tofile=new_filename.encode(path_encoding, 'replace'),
102
 
                      sequencematcher=sequence_matcher)
 
102
                      n=context_lines, sequencematcher=sequence_matcher)
103
103
 
104
104
    ud = list(ud)
105
105
    if len(ud) == 0: # Identical contents, nothing to do
119
119
 
120
120
 
121
121
def _spawn_external_diff(diffcmd, capture_errors=True):
122
 
    """Spawn the externall diff process, and return the child handle.
 
122
    """Spawn the external diff process, and return the child handle.
123
123
 
124
124
    :param diffcmd: The command list to spawn
125
125
    :param capture_errors: Capture stderr as well as setting LANG=C
154
154
 
155
155
    return pipe
156
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
 
157
191
 
158
192
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
159
193
                  diff_opts):
195
229
                   '--binary',
196
230
                  ]
197
231
 
198
 
        # diff only allows one style to be specified; they don't override.
199
 
        # note that some of these take optargs, and the optargs can be
200
 
        # directly appended to the options.
201
 
        # this is only an approximate parser; it doesn't properly understand
202
 
        # the grammar.
203
 
        for s in ['-c', '-u', '-C', '-U',
204
 
                  '-e', '--ed',
205
 
                  '-q', '--brief',
206
 
                  '--normal',
207
 
                  '-n', '--rcs',
208
 
                  '-y', '--side-by-side',
209
 
                  '-D', '--ifdef']:
210
 
            for j in diff_opts:
211
 
                if j.startswith(s):
212
 
                    break
213
 
            else:
214
 
                continue
215
 
            break
216
 
        else:
217
 
            diffcmd.append('-u')
 
232
        diff_opts = default_style_unified(diff_opts)
218
233
 
219
234
        if diff_opts:
220
235
            diffcmd.extend(diff_opts)
265
280
                msg = 'exit code %d' % rc
266
281
 
267
282
            raise errors.BzrError('external diff failed with %s; command: %r'
268
 
                                  % (rc, diffcmd))
 
283
                                  % (msg, diffcmd))
269
284
 
270
285
 
271
286
    finally:
272
287
        oldtmpf.close()                 # and delete
273
288
        newtmpf.close()
274
 
        # Clean up. Warn in case the files couldn't be deleted
275
 
        # (in case windows still holds the file open, but not
276
 
        # if the files have already been deleted)
277
 
        try:
278
 
            os.remove(old_abspath)
279
 
        except OSError, e:
280
 
            if e.errno not in (errno.ENOENT,):
281
 
                warning('Failed to delete temporary file: %s %s',
282
 
                        old_abspath, e)
283
 
        try:
284
 
            os.remove(new_abspath)
285
 
        except OSError:
286
 
            if e.errno not in (errno.ENOENT,):
287
 
                warning('Failed to delete temporary file: %s %s',
288
 
                        new_abspath, e)
289
 
 
290
 
 
291
 
@deprecated_function(deprecated_in((2, 2, 0)))
292
 
def get_trees_and_branches_to_diff(path_list, revision_specs, old_url, new_url,
293
 
                                   apply_view=True):
294
 
    """Get the trees and specific files to diff given a list of paths.
295
 
 
296
 
    This method works out the trees to be diff'ed and the files of
297
 
    interest within those trees.
298
 
 
299
 
    :param path_list:
300
 
        the list of arguments passed to the diff command
301
 
    :param revision_specs:
302
 
        Zero, one or two RevisionSpecs from the diff command line,
303
 
        saying what revisions to compare.
304
 
    :param old_url:
305
 
        The url of the old branch or tree. If None, the tree to use is
306
 
        taken from the first path, if any, or the current working tree.
307
 
    :param new_url:
308
 
        The url of the new branch or tree. If None, the tree to use is
309
 
        taken from the first path, if any, or the current working tree.
310
 
    :param apply_view:
311
 
        if True and a view is set, apply the view or check that the paths
312
 
        are within it
313
 
    :returns:
314
 
        a tuple of (old_tree, new_tree, old_branch, new_branch,
315
 
        specific_files, extra_trees) where extra_trees is a sequence of
316
 
        additional trees to search in for file-ids.  The trees and branches
317
 
        are not locked.
318
 
    """
319
 
    op = cleanup.OperationWithCleanups(get_trees_and_branches_to_diff_locked)
320
 
    return op.run_simple(path_list, revision_specs, old_url, new_url,
321
 
            op.add_cleanup, apply_view=apply_view)
322
 
    
 
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
 
323
303
 
324
304
def get_trees_and_branches_to_diff_locked(
325
305
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
392
372
    if old_url is None:
393
373
        old_url = default_location
394
374
    working_tree, branch, relpath = \
395
 
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
 
375
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
396
376
    lock_tree_or_branch(working_tree, branch)
397
377
    if consider_relpath and relpath != '':
398
378
        if working_tree is not None and apply_view:
406
386
        new_url = default_location
407
387
    if new_url != old_url:
408
388
        working_tree, branch, relpath = \
409
 
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
 
389
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
410
390
        lock_tree_or_branch(working_tree, branch)
411
391
        if consider_relpath and relpath != '':
412
392
            if working_tree is not None and apply_view:
430
410
            if view_files:
431
411
                specific_files = view_files
432
412
                view_str = views.view_display_str(view_files)
433
 
                note("*** Ignoring files outside view. View is %s" % view_str)
 
413
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
434
414
 
435
415
    # Get extra trees that ought to be searched for file-ids
436
416
    extra_trees = None
437
417
    if working_tree is not None and working_tree not in (old_tree, new_tree):
438
418
        extra_trees = (working_tree,)
439
 
    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)
440
421
 
441
422
 
442
423
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
459
440
                    extra_trees=None,
460
441
                    path_encoding='utf8',
461
442
                    using=None,
462
 
                    format_cls=None):
 
443
                    format_cls=None,
 
444
                    context=DEFAULT_CONTEXT_AMOUNT):
463
445
    """Show in text form the changes from one tree to another.
464
446
 
465
447
    :param to_file: The output stream.
466
 
    :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
467
449
        changes.
468
450
    :param external_diff_options: If set, use an external GNU diff and pass 
469
451
        these options.
472
454
        otherwise is supposed to be utf8
473
455
    :param format_cls: Formatter class (DiffTree subclass)
474
456
    """
 
457
    if context is None:
 
458
        context = DEFAULT_CONTEXT_AMOUNT
475
459
    if format_cls is None:
476
460
        format_cls = DiffTree
477
461
    old_tree.lock_read()
484
468
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
485
469
                                                   path_encoding,
486
470
                                                   external_diff_options,
487
 
                                                   old_label, new_label, using)
 
471
                                                   old_label, new_label, using,
 
472
                                                   context_lines=context)
488
473
            return differ.show_diff(specific_files, extra_trees)
489
474
        finally:
490
475
            new_tree.unlock()
648
633
    # or removed in a diff.
649
634
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
650
635
 
651
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
652
 
                 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):
653
639
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
654
640
        self.text_differ = text_differ
655
641
        self.old_label = old_label
656
642
        self.new_label = new_label
657
643
        self.path_encoding = path_encoding
 
644
        self.context_lines = context_lines
658
645
 
659
646
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
660
647
        """Compare two files in unified diff format
708
695
            from_text = _get_text(self.old_tree, from_file_id, from_path)
709
696
            to_text = _get_text(self.new_tree, to_file_id, to_path)
710
697
            self.text_differ(from_label, from_text, to_label, to_text,
711
 
                             self.to_file, path_encoding=self.path_encoding)
 
698
                             self.to_file, path_encoding=self.path_encoding,
 
699
                             context_lines=self.context_lines)
712
700
        except errors.BinaryFile:
713
701
            self.to_file.write(
714
702
                  ("Binary files %s and %s differ\n" %
745
733
 
746
734
    def _get_command(self, old_path, new_path):
747
735
        my_map = {'old_path': old_path, 'new_path': new_path}
748
 
        return [AtTemplate(t).substitute(my_map) for t in
749
 
                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
750
748
 
751
749
    def _execute(self, old_path, new_path):
752
750
        command = self._get_command(old_path, new_path)
772
770
                raise
773
771
        return True
774
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
 
775
801
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
776
802
                    allow_write=False):
777
803
        if not force_temp and isinstance(tree, WorkingTree):
778
 
            return tree.abspath(tree.id2path(file_id))
779
 
        
780
 
        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)
781
809
        if not force_temp and self._try_symlink_root(tree, prefix):
782
810
            return full_path
783
811
        parent_dir = osutils.dirname(full_path)
840
868
        """
841
869
        old_path = self.old_tree.id2path(file_id)
842
870
        new_path = self.new_tree.id2path(file_id)
843
 
        new_abs_path = self._prepare_files(file_id, old_path, new_path,
844
 
                                           allow_write_new=True,
845
 
                                           force_temp=True)[1]
846
 
        command = self._get_command(osutils.pathjoin('old', old_path),
847
 
                                    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)
848
876
        subprocess.call(command, cwd=self._root)
849
 
        new_file = open(new_abs_path, 'r')
 
877
        new_file = open(new_abs_path, 'rb')
850
878
        try:
851
879
            return new_file.read()
852
880
        finally:
898
926
    @classmethod
899
927
    def from_trees_options(klass, old_tree, new_tree, to_file,
900
928
                           path_encoding, external_diff_options, old_label,
901
 
                           new_label, using):
 
929
                           new_label, using, context_lines):
902
930
        """Factory for producing a DiffTree.
903
931
 
904
932
        Designed to accept options used by show_diff_trees.
 
933
 
905
934
        :param old_tree: The tree to show as old in the comparison
906
935
        :param new_tree: The tree to show as new in the comparison
907
936
        :param to_file: File to write comparisons to
918
947
            extra_factories = []
919
948
        if external_diff_options:
920
949
            opts = external_diff_options.split()
921
 
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None):
 
950
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
922
951
                """:param path_encoding: not used but required
923
952
                        to match the signature of internal_diff.
924
953
                """
926
955
        else:
927
956
            diff_file = internal_diff
928
957
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
929
 
                             old_label, new_label, diff_file)
 
958
                             old_label, new_label, diff_file, context_lines=context_lines)
930
959
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
931
960
                     extra_factories)
932
961