← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Patch Queue Manager
  • Date: 2015-12-17 18:39:00 UTC
  • mfrom: (6606.1.2 fix-float)
  • Revision ID: pqm@pqm.ubuntu.com-20151217183900-0719du2uv1kwu3lc
(vila) Inline testtools private method to fix an issue in xenial (the
 private implementation has changed in an backward incompatible way).
 (Jelmer Vernooij)

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,
47
49
    )
48
50
from bzrlib.trace import mutter, note, warning
49
51
 
 
52
DEFAULT_CONTEXT_AMOUNT = 3
50
53
 
51
54
class AtTemplate(string.Template):
52
55
    """Templating class that uses @ instead of $."""
70
73
 
71
74
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
72
75
                  allow_binary=False, sequence_matcher=None,
73
 
                  path_encoding='utf8'):
 
76
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
74
77
    # FIXME: difflib is wrong if there is no trailing newline.
75
78
    # The syntax used by patch seems to be "\ No newline at
76
79
    # end of file" following the last diff line from that
96
99
    ud = patiencediff.unified_diff(oldlines, newlines,
97
100
                      fromfile=old_filename.encode(path_encoding, 'replace'),
98
101
                      tofile=new_filename.encode(path_encoding, 'replace'),
99
 
                      sequencematcher=sequence_matcher)
 
102
                      n=context_lines, sequencematcher=sequence_matcher)
100
103
 
101
104
    ud = list(ud)
102
105
    if len(ud) == 0: # Identical contents, nothing to do
116
119
 
117
120
 
118
121
def _spawn_external_diff(diffcmd, capture_errors=True):
119
 
    """Spawn the externall diff process, and return the child handle.
 
122
    """Spawn the external diff process, and return the child handle.
120
123
 
121
124
    :param diffcmd: The command list to spawn
122
125
    :param capture_errors: Capture stderr as well as setting LANG=C
151
154
 
152
155
    return pipe
153
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
 
154
191
 
155
192
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
156
193
                  diff_opts):
192
229
                   '--binary',
193
230
                  ]
194
231
 
195
 
        # diff only allows one style to be specified; they don't override.
196
 
        # note that some of these take optargs, and the optargs can be
197
 
        # directly appended to the options.
198
 
        # this is only an approximate parser; it doesn't properly understand
199
 
        # the grammar.
200
 
        for s in ['-c', '-u', '-C', '-U',
201
 
                  '-e', '--ed',
202
 
                  '-q', '--brief',
203
 
                  '--normal',
204
 
                  '-n', '--rcs',
205
 
                  '-y', '--side-by-side',
206
 
                  '-D', '--ifdef']:
207
 
            for j in diff_opts:
208
 
                if j.startswith(s):
209
 
                    break
210
 
            else:
211
 
                continue
212
 
            break
213
 
        else:
214
 
            diffcmd.append('-u')
 
232
        diff_opts = default_style_unified(diff_opts)
215
233
 
216
234
        if diff_opts:
217
235
            diffcmd.extend(diff_opts)
262
280
                msg = 'exit code %d' % rc
263
281
 
264
282
            raise errors.BzrError('external diff failed with %s; command: %r'
265
 
                                  % (rc, diffcmd))
 
283
                                  % (msg, diffcmd))
266
284
 
267
285
 
268
286
    finally:
269
287
        oldtmpf.close()                 # and delete
270
288
        newtmpf.close()
271
 
        # Clean up. Warn in case the files couldn't be deleted
272
 
        # (in case windows still holds the file open, but not
273
 
        # if the files have already been deleted)
274
 
        try:
275
 
            os.remove(old_abspath)
276
 
        except OSError, e:
277
 
            if e.errno not in (errno.ENOENT,):
278
 
                warning('Failed to delete temporary file: %s %s',
279
 
                        old_abspath, e)
280
 
        try:
281
 
            os.remove(new_abspath)
282
 
        except OSError:
283
 
            if e.errno not in (errno.ENOENT,):
284
 
                warning('Failed to delete temporary file: %s %s',
285
 
                        new_abspath, e)
 
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)
286
302
 
287
303
 
288
304
def get_trees_and_branches_to_diff_locked(
356
372
    if old_url is None:
357
373
        old_url = default_location
358
374
    working_tree, branch, relpath = \
359
 
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
 
375
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
360
376
    lock_tree_or_branch(working_tree, branch)
361
377
    if consider_relpath and relpath != '':
362
378
        if working_tree is not None and apply_view:
370
386
        new_url = default_location
371
387
    if new_url != old_url:
372
388
        working_tree, branch, relpath = \
373
 
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
 
389
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
374
390
        lock_tree_or_branch(working_tree, branch)
375
391
        if consider_relpath and relpath != '':
376
392
            if working_tree is not None and apply_view:
424
440
                    extra_trees=None,
425
441
                    path_encoding='utf8',
426
442
                    using=None,
427
 
                    format_cls=None):
 
443
                    format_cls=None,
 
444
                    context=DEFAULT_CONTEXT_AMOUNT):
428
445
    """Show in text form the changes from one tree to another.
429
446
 
430
447
    :param to_file: The output stream.
437
454
        otherwise is supposed to be utf8
438
455
    :param format_cls: Formatter class (DiffTree subclass)
439
456
    """
 
457
    if context is None:
 
458
        context = DEFAULT_CONTEXT_AMOUNT
440
459
    if format_cls is None:
441
460
        format_cls = DiffTree
442
461
    old_tree.lock_read()
449
468
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
450
469
                                                   path_encoding,
451
470
                                                   external_diff_options,
452
 
                                                   old_label, new_label, using)
 
471
                                                   old_label, new_label, using,
 
472
                                                   context_lines=context)
453
473
            return differ.show_diff(specific_files, extra_trees)
454
474
        finally:
455
475
            new_tree.unlock()
613
633
    # or removed in a diff.
614
634
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
615
635
 
616
 
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
617
 
                 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):
618
639
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
619
640
        self.text_differ = text_differ
620
641
        self.old_label = old_label
621
642
        self.new_label = new_label
622
643
        self.path_encoding = path_encoding
 
644
        self.context_lines = context_lines
623
645
 
624
646
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
625
647
        """Compare two files in unified diff format
673
695
            from_text = _get_text(self.old_tree, from_file_id, from_path)
674
696
            to_text = _get_text(self.new_tree, to_file_id, to_path)
675
697
            self.text_differ(from_label, from_text, to_label, to_text,
676
 
                             self.to_file, path_encoding=self.path_encoding)
 
698
                             self.to_file, path_encoding=self.path_encoding,
 
699
                             context_lines=self.context_lines)
677
700
        except errors.BinaryFile:
678
701
            self.to_file.write(
679
702
                  ("Binary files %s and %s differ\n" %
903
926
    @classmethod
904
927
    def from_trees_options(klass, old_tree, new_tree, to_file,
905
928
                           path_encoding, external_diff_options, old_label,
906
 
                           new_label, using):
 
929
                           new_label, using, context_lines):
907
930
        """Factory for producing a DiffTree.
908
931
 
909
932
        Designed to accept options used by show_diff_trees.
924
947
            extra_factories = []
925
948
        if external_diff_options:
926
949
            opts = external_diff_options.split()
927
 
            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):
928
951
                """:param path_encoding: not used but required
929
952
                        to match the signature of internal_diff.
930
953
                """
932
955
        else:
933
956
            diff_file = internal_diff
934
957
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
935
 
                             old_label, new_label, diff_file)
 
958
                             old_label, new_label, diff_file, context_lines=context_lines)
936
959
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
937
960
                     extra_factories)
938
961