← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: John Arbash Meinel
  • Date: 2011-04-20 15:06:17 UTC
  • mto: This revision was merged to the branch mainline in revision 5836.
  • Revision ID: john@arbash-meinel.com-20110420150617-i41caxgemg32tq1r
Start adding tests that _worth_saving_limit works as expected.

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,
41
39
    )
42
40
 
43
41
from bzrlib.workingtree import WorkingTree
44
 
from bzrlib.i18n import gettext
45
42
""")
46
43
 
47
44
from bzrlib.registry import (
48
45
    Registry,
49
46
    )
 
47
from bzrlib.symbol_versioning import (
 
48
    deprecated_function,
 
49
    deprecated_in,
 
50
    )
50
51
from bzrlib.trace import mutter, note, warning
51
52
 
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', context_lines=DEFAULT_CONTEXT_AMOUNT):
 
76
                  path_encoding='utf8'):
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
 
                      n=context_lines, sequencematcher=sequence_matcher)
 
102
                      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 external diff process, and return the child handle.
 
122
    """Spawn the externall 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
 
 
191
157
 
192
158
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
193
159
                  diff_opts):
229
195
                   '--binary',
230
196
                  ]
231
197
 
232
 
        diff_opts = default_style_unified(diff_opts)
 
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')
233
218
 
234
219
        if diff_opts:
235
220
            diffcmd.extend(diff_opts)
280
265
                msg = 'exit code %d' % rc
281
266
 
282
267
            raise errors.BzrError('external diff failed with %s; command: %r'
283
 
                                  % (msg, diffcmd))
 
268
                                  % (rc, diffcmd))
284
269
 
285
270
 
286
271
    finally:
287
272
        oldtmpf.close()                 # and delete
288
273
        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)
302
 
 
 
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
    
303
323
 
304
324
def get_trees_and_branches_to_diff_locked(
305
325
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
372
392
    if old_url is None:
373
393
        old_url = default_location
374
394
    working_tree, branch, relpath = \
375
 
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
 
395
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
376
396
    lock_tree_or_branch(working_tree, branch)
377
397
    if consider_relpath and relpath != '':
378
398
        if working_tree is not None and apply_view:
386
406
        new_url = default_location
387
407
    if new_url != old_url:
388
408
        working_tree, branch, relpath = \
389
 
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
 
409
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
390
410
        lock_tree_or_branch(working_tree, branch)
391
411
        if consider_relpath and relpath != '':
392
412
            if working_tree is not None and apply_view:
410
430
            if view_files:
411
431
                specific_files = view_files
412
432
                view_str = views.view_display_str(view_files)
413
 
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
 
433
                note("*** Ignoring files outside view. View is %s" % view_str)
414
434
 
415
435
    # Get extra trees that ought to be searched for file-ids
416
436
    extra_trees = None
417
437
    if working_tree is not None and working_tree not in (old_tree, new_tree):
418
438
        extra_trees = (working_tree,)
419
 
    return (old_tree, new_tree, old_branch, new_branch,
420
 
            specific_files, extra_trees)
 
439
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
421
440
 
422
441
 
423
442
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
440
459
                    extra_trees=None,
441
460
                    path_encoding='utf8',
442
461
                    using=None,
443
 
                    format_cls=None,
444
 
                    context=DEFAULT_CONTEXT_AMOUNT):
 
462
                    format_cls=None):
445
463
    """Show in text form the changes from one tree to another.
446
464
 
447
465
    :param to_file: The output stream.
448
 
    :param specific_files: Include only changes to these files - None for all
 
466
    :param specific_files:Include only changes to these files - None for all
449
467
        changes.
450
468
    :param external_diff_options: If set, use an external GNU diff and pass 
451
469
        these options.
454
472
        otherwise is supposed to be utf8
455
473
    :param format_cls: Formatter class (DiffTree subclass)
456
474
    """
457
 
    if context is None:
458
 
        context = DEFAULT_CONTEXT_AMOUNT
459
475
    if format_cls is None:
460
476
        format_cls = DiffTree
461
477
    old_tree.lock_read()
468
484
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
469
485
                                                   path_encoding,
470
486
                                                   external_diff_options,
471
 
                                                   old_label, new_label, using,
472
 
                                                   context_lines=context)
 
487
                                                   old_label, new_label, using)
473
488
            return differ.show_diff(specific_files, extra_trees)
474
489
        finally:
475
490
            new_tree.unlock()
633
648
    # or removed in a diff.
634
649
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
635
650
 
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):
 
651
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
 
652
                 old_label='', new_label='', text_differ=internal_diff):
639
653
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
640
654
        self.text_differ = text_differ
641
655
        self.old_label = old_label
642
656
        self.new_label = new_label
643
657
        self.path_encoding = path_encoding
644
 
        self.context_lines = context_lines
645
658
 
646
659
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
647
660
        """Compare two files in unified diff format
695
708
            from_text = _get_text(self.old_tree, from_file_id, from_path)
696
709
            to_text = _get_text(self.new_tree, to_file_id, to_path)
697
710
            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)
 
711
                             self.to_file, path_encoding=self.path_encoding)
700
712
        except errors.BinaryFile:
701
713
            self.to_file.write(
702
714
                  ("Binary files %s and %s differ\n" %
733
745
 
734
746
    def _get_command(self, old_path, new_path):
735
747
        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
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
 
748
        return [AtTemplate(t).substitute(my_map) for t in
 
749
                self.command_template]
748
750
 
749
751
    def _execute(self, old_path, new_path):
750
752
        command = self._get_command(old_path, new_path)
770
772
                raise
771
773
        return True
772
774
 
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
 
 
801
775
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
802
776
                    allow_write=False):
803
777
        if not force_temp and isinstance(tree, WorkingTree):
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)
 
778
            return tree.abspath(tree.id2path(file_id))
 
779
        
 
780
        full_path = osutils.pathjoin(self._root, prefix, relpath)
809
781
        if not force_temp and self._try_symlink_root(tree, prefix):
810
782
            return full_path
811
783
        parent_dir = osutils.dirname(full_path)
868
840
        """
869
841
        old_path = self.old_tree.id2path(file_id)
870
842
        new_path = self.new_tree.id2path(file_id)
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)
 
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))
876
848
        subprocess.call(command, cwd=self._root)
877
 
        new_file = open(new_abs_path, 'rb')
 
849
        new_file = open(new_abs_path, 'r')
878
850
        try:
879
851
            return new_file.read()
880
852
        finally:
926
898
    @classmethod
927
899
    def from_trees_options(klass, old_tree, new_tree, to_file,
928
900
                           path_encoding, external_diff_options, old_label,
929
 
                           new_label, using, context_lines):
 
901
                           new_label, using):
930
902
        """Factory for producing a DiffTree.
931
903
 
932
904
        Designed to accept options used by show_diff_trees.
933
 
 
934
905
        :param old_tree: The tree to show as old in the comparison
935
906
        :param new_tree: The tree to show as new in the comparison
936
907
        :param to_file: File to write comparisons to
947
918
            extra_factories = []
948
919
        if external_diff_options:
949
920
            opts = external_diff_options.split()
950
 
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None, context_lines=None):
 
921
            def diff_file(olab, olines, nlab, nlines, to_file, path_encoding=None):
951
922
                """:param path_encoding: not used but required
952
923
                        to match the signature of internal_diff.
953
924
                """
955
926
        else:
956
927
            diff_file = internal_diff
957
928
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
958
 
                             old_label, new_label, diff_file, context_lines=context_lines)
 
929
                             old_label, new_label, diff_file)
959
930
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
960
931
                     extra_factories)
961
932