/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Vincent Ladeuil
  • Date: 2011-09-28 15:06:42 UTC
  • mto: This revision was merged to the branch mainline in revision 6175.
  • Revision ID: v.ladeuil+lp@free.fr-20110928150642-e5m0w1oqc0effxr8
https://launchpad.net/bugs/856261
Allows bzr shelve to be used in test scripts and under emacs shells

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
1
 
# Copyright (C) 2005-2014 Canonical Ltd.
 
1
# Copyright (C) 2005-2011 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
 
 
19
17
import difflib
20
18
import os
21
19
import re
29
27
import tempfile
30
28
 
31
29
from bzrlib import (
 
30
    bzrdir,
 
31
    cmdline,
32
32
    cleanup,
33
 
    cmdline,
34
 
    controldir,
35
33
    errors,
36
34
    osutils,
37
35
    patiencediff,
49
47
    )
50
48
from bzrlib.trace import mutter, note, warning
51
49
 
52
 
DEFAULT_CONTEXT_AMOUNT = 3
53
50
 
54
51
class AtTemplate(string.Template):
55
52
    """Templating class that uses @ instead of $."""
73
70
 
74
71
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
75
72
                  allow_binary=False, sequence_matcher=None,
76
 
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
 
73
                  path_encoding='utf8'):
77
74
    # FIXME: difflib is wrong if there is no trailing newline.
78
75
    # The syntax used by patch seems to be "\ No newline at
79
76
    # end of file" following the last diff line from that
99
96
    ud = patiencediff.unified_diff(oldlines, newlines,
100
97
                      fromfile=old_filename.encode(path_encoding, 'replace'),
101
98
                      tofile=new_filename.encode(path_encoding, 'replace'),
102
 
                      n=context_lines, sequencematcher=sequence_matcher)
 
99
                      sequencematcher=sequence_matcher)
103
100
 
104
101
    ud = list(ud)
105
102
    if len(ud) == 0: # Identical contents, nothing to do
119
116
 
120
117
 
121
118
def _spawn_external_diff(diffcmd, capture_errors=True):
122
 
    """Spawn the external diff process, and return the child handle.
 
119
    """Spawn the externall diff process, and return the child handle.
123
120
 
124
121
    :param diffcmd: The command list to spawn
125
122
    :param capture_errors: Capture stderr as well as setting LANG=C
154
151
 
155
152
    return pipe
156
153
 
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
 
 
191
154
 
192
155
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
193
156
                  diff_opts):
229
192
                   '--binary',
230
193
                  ]
231
194
 
232
 
        diff_opts = default_style_unified(diff_opts)
 
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')
233
215
 
234
216
        if diff_opts:
235
217
            diffcmd.extend(diff_opts)
280
262
                msg = 'exit code %d' % rc
281
263
 
282
264
            raise errors.BzrError('external diff failed with %s; command: %r'
283
 
                                  % (msg, diffcmd))
 
265
                                  % (rc, diffcmd))
284
266
 
285
267
 
286
268
    finally:
287
269
        oldtmpf.close()                 # and delete
288
270
        newtmpf.close()
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)
 
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)
302
286
 
303
287
 
304
288
def get_trees_and_branches_to_diff_locked(
372
356
    if old_url is None:
373
357
        old_url = default_location
374
358
    working_tree, branch, relpath = \
375
 
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
 
359
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
376
360
    lock_tree_or_branch(working_tree, branch)
377
361
    if consider_relpath and relpath != '':
378
362
        if working_tree is not None and apply_view:
386
370
        new_url = default_location
387
371
    if new_url != old_url:
388
372
        working_tree, branch, relpath = \
389
 
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
 
373
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
390
374
        lock_tree_or_branch(working_tree, branch)
391
375
        if consider_relpath and relpath != '':
392
376
            if working_tree is not None and apply_view:
440
424
                    extra_trees=None,
441
425
                    path_encoding='utf8',
442
426
                    using=None,
443
 
                    format_cls=None,
444
 
                    context=DEFAULT_CONTEXT_AMOUNT):
 
427
                    format_cls=None):
445
428
    """Show in text form the changes from one tree to another.
446
429
 
447
430
    :param to_file: The output stream.
454
437
        otherwise is supposed to be utf8
455
438
    :param format_cls: Formatter class (DiffTree subclass)
456
439
    """
457
 
    if context is None:
458
 
        context = DEFAULT_CONTEXT_AMOUNT
459
440
    if format_cls is None:
460
441
        format_cls = DiffTree
461
442
    old_tree.lock_read()
468
449
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
469
450
                                                   path_encoding,
470
451
                                                   external_diff_options,
471
 
                                                   old_label, new_label, using,
472
 
                                                   context_lines=context)
 
452
                                                   old_label, new_label, using)
473
453
            return differ.show_diff(specific_files, extra_trees)
474
454
        finally:
475
455
            new_tree.unlock()
633
613
    # or removed in a diff.
634
614
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
635
615
 
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):
 
616
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
 
617
                 old_label='', new_label='', text_differ=internal_diff):
639
618
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
640
619
        self.text_differ = text_differ
641
620
        self.old_label = old_label
642
621
        self.new_label = new_label
643
622
        self.path_encoding = path_encoding
644
 
        self.context_lines = context_lines
645
623
 
646
624
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
647
625
        """Compare two files in unified diff format
695
673
            from_text = _get_text(self.old_tree, from_file_id, from_path)
696
674
            to_text = _get_text(self.new_tree, to_file_id, to_path)
697
675
            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)
 
676
                             self.to_file, path_encoding=self.path_encoding)
700
677
        except errors.BinaryFile:
701
678
            self.to_file.write(
702
679
                  ("Binary files %s and %s differ\n" %
926
903
    @classmethod
927
904
    def from_trees_options(klass, old_tree, new_tree, to_file,
928
905
                           path_encoding, external_diff_options, old_label,
929
 
                           new_label, using, context_lines):
 
906
                           new_label, using):
930
907
        """Factory for producing a DiffTree.
931
908
 
932
909
        Designed to accept options used by show_diff_trees.
947
924
            extra_factories = []
948
925
        if external_diff_options:
949
926
            opts = external_diff_options.split()
950
 
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
 
927
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None):
951
928
                """:param path_encoding: not used but required
952
929
                        to match the signature of internal_diff.
953
930
                """
955
932
        else:
956
933
            diff_file = internal_diff
957
934
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
958
 
                             old_label, new_label, diff_file, context_lines=context_lines)
 
935
                             old_label, new_label, diff_file)
959
936
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
960
937
                     extra_factories)
961
938