/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: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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-2010 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
27
25
import errno
28
26
import subprocess
29
27
import tempfile
 
28
import time
30
29
 
31
30
from bzrlib import (
 
31
    branch as _mod_branch,
 
32
    bzrdir,
 
33
    cmdline,
32
34
    cleanup,
33
 
    cmdline,
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
45
44
""")
46
45
 
47
46
from bzrlib.registry import (
48
47
    Registry,
49
48
    )
 
49
from bzrlib.symbol_versioning import (
 
50
    deprecated_function,
 
51
    deprecated_in,
 
52
    )
50
53
from bzrlib.trace import mutter, note, warning
51
54
 
52
 
DEFAULT_CONTEXT_AMOUNT = 3
53
55
 
54
56
class AtTemplate(string.Template):
55
57
    """Templating class that uses @ instead of $."""
73
75
 
74
76
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
75
77
                  allow_binary=False, sequence_matcher=None,
76
 
                  path_encoding='utf8', context_lines=DEFAULT_CONTEXT_AMOUNT):
 
78
                  path_encoding='utf8'):
77
79
    # FIXME: difflib is wrong if there is no trailing newline.
78
80
    # The syntax used by patch seems to be "\ No newline at
79
81
    # end of file" following the last diff line from that
97
99
    if sequence_matcher is None:
98
100
        sequence_matcher = patiencediff.PatienceSequenceMatcher
99
101
    ud = patiencediff.unified_diff(oldlines, newlines,
100
 
                      fromfile=old_filename.encode(path_encoding, 'replace'),
101
 
                      tofile=new_filename.encode(path_encoding, 'replace'),
102
 
                      n=context_lines, sequencematcher=sequence_matcher)
 
102
                      fromfile=old_filename.encode(path_encoding),
 
103
                      tofile=new_filename.encode(path_encoding),
 
104
                      sequencematcher=sequence_matcher)
103
105
 
104
106
    ud = list(ud)
105
107
    if len(ud) == 0: # Identical contents, nothing to do
119
121
 
120
122
 
121
123
def _spawn_external_diff(diffcmd, capture_errors=True):
122
 
    """Spawn the external diff process, and return the child handle.
 
124
    """Spawn the externall diff process, and return the child handle.
123
125
 
124
126
    :param diffcmd: The command list to spawn
125
127
    :param capture_errors: Capture stderr as well as setting LANG=C
154
156
 
155
157
    return pipe
156
158
 
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
159
 
192
160
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
193
161
                  diff_opts):
229
197
                   '--binary',
230
198
                  ]
231
199
 
232
 
        diff_opts = default_style_unified(diff_opts)
 
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')
233
220
 
234
221
        if diff_opts:
235
222
            diffcmd.extend(diff_opts)
280
267
                msg = 'exit code %d' % rc
281
268
 
282
269
            raise errors.BzrError('external diff failed with %s; command: %r'
283
 
                                  % (msg, diffcmd))
 
270
                                  % (rc, diffcmd))
284
271
 
285
272
 
286
273
    finally:
287
274
        oldtmpf.close()                 # and delete
288
275
        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
 
 
 
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
    
303
325
 
304
326
def get_trees_and_branches_to_diff_locked(
305
327
    path_list, revision_specs, old_url, new_url, add_cleanup, apply_view=True):
372
394
    if old_url is None:
373
395
        old_url = default_location
374
396
    working_tree, branch, relpath = \
375
 
        controldir.ControlDir.open_containing_tree_or_branch(old_url)
 
397
        bzrdir.BzrDir.open_containing_tree_or_branch(old_url)
376
398
    lock_tree_or_branch(working_tree, branch)
377
399
    if consider_relpath and relpath != '':
378
400
        if working_tree is not None and apply_view:
386
408
        new_url = default_location
387
409
    if new_url != old_url:
388
410
        working_tree, branch, relpath = \
389
 
            controldir.ControlDir.open_containing_tree_or_branch(new_url)
 
411
            bzrdir.BzrDir.open_containing_tree_or_branch(new_url)
390
412
        lock_tree_or_branch(working_tree, branch)
391
413
        if consider_relpath and relpath != '':
392
414
            if working_tree is not None and apply_view:
398
420
 
399
421
    # Get the specific files (all files is None, no files is [])
400
422
    if make_paths_wt_relative and working_tree is not None:
401
 
        other_paths = working_tree.safe_relpath_files(
402
 
            other_paths,
 
423
        try:
 
424
            from bzrlib.builtins import safe_relpath_files
 
425
            other_paths = safe_relpath_files(working_tree, other_paths,
403
426
            apply_view=apply_view)
 
427
        except errors.FileInWrongBranch:
 
428
            raise errors.BzrCommandError("Files are in different branches")
404
429
    specific_files.extend(other_paths)
405
430
    if len(specific_files) == 0:
406
431
        specific_files = None
410
435
            if view_files:
411
436
                specific_files = view_files
412
437
                view_str = views.view_display_str(view_files)
413
 
                note(gettext("*** Ignoring files outside view. View is %s") % view_str)
 
438
                note("*** Ignoring files outside view. View is %s" % view_str)
414
439
 
415
440
    # Get extra trees that ought to be searched for file-ids
416
441
    extra_trees = None
417
442
    if working_tree is not None and working_tree not in (old_tree, new_tree):
418
443
        extra_trees = (working_tree,)
419
 
    return (old_tree, new_tree, old_branch, new_branch,
420
 
            specific_files, extra_trees)
 
444
    return old_tree, new_tree, old_branch, new_branch, specific_files, extra_trees
421
445
 
422
446
 
423
447
def _get_tree_to_diff(spec, tree=None, branch=None, basis_is_default=True):
440
464
                    extra_trees=None,
441
465
                    path_encoding='utf8',
442
466
                    using=None,
443
 
                    format_cls=None,
444
 
                    context=DEFAULT_CONTEXT_AMOUNT):
 
467
                    format_cls=None):
445
468
    """Show in text form the changes from one tree to another.
446
469
 
447
470
    :param to_file: The output stream.
448
 
    :param specific_files: Include only changes to these files - None for all
 
471
    :param specific_files:Include only changes to these files - None for all
449
472
        changes.
450
473
    :param external_diff_options: If set, use an external GNU diff and pass 
451
474
        these options.
454
477
        otherwise is supposed to be utf8
455
478
    :param format_cls: Formatter class (DiffTree subclass)
456
479
    """
457
 
    if context is None:
458
 
        context = DEFAULT_CONTEXT_AMOUNT
459
480
    if format_cls is None:
460
481
        format_cls = DiffTree
461
482
    old_tree.lock_read()
468
489
            differ = format_cls.from_trees_options(old_tree, new_tree, to_file,
469
490
                                                   path_encoding,
470
491
                                                   external_diff_options,
471
 
                                                   old_label, new_label, using,
472
 
                                                   context_lines=context)
 
492
                                                   old_label, new_label, using)
473
493
            return differ.show_diff(specific_files, extra_trees)
474
494
        finally:
475
495
            new_tree.unlock()
633
653
    # or removed in a diff.
634
654
    EPOCH_DATE = '1970-01-01 00:00:00 +0000'
635
655
 
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):
 
656
    def __init__(self, old_tree, new_tree, to_file, path_encoding='utf-8',
 
657
                 old_label='', new_label='', text_differ=internal_diff):
639
658
        DiffPath.__init__(self, old_tree, new_tree, to_file, path_encoding)
640
659
        self.text_differ = text_differ
641
660
        self.old_label = old_label
642
661
        self.new_label = new_label
643
662
        self.path_encoding = path_encoding
644
 
        self.context_lines = context_lines
645
663
 
646
664
    def diff(self, file_id, old_path, new_path, old_kind, new_kind):
647
665
        """Compare two files in unified diff format
688
706
        """
689
707
        def _get_text(tree, file_id, path):
690
708
            if file_id is not None:
691
 
                return tree.get_file_lines(file_id, path)
 
709
                return tree.get_file(file_id, path).readlines()
692
710
            else:
693
711
                return []
694
712
        try:
695
713
            from_text = _get_text(self.old_tree, from_file_id, from_path)
696
714
            to_text = _get_text(self.new_tree, to_file_id, to_path)
697
715
            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)
 
716
                             self.to_file)
700
717
        except errors.BinaryFile:
701
718
            self.to_file.write(
702
719
                  ("Binary files %s and %s differ\n" %
703
 
                  (from_label, to_label)).encode(self.path_encoding,'replace'))
 
720
                  (from_label, to_label)).encode(self.path_encoding))
704
721
        return self.CHANGED
705
722
 
706
723
 
722
739
                     path_encoding)
723
740
 
724
741
    @classmethod
725
 
    def make_from_diff_tree(klass, command_string, external_diff_options=None):
 
742
    def make_from_diff_tree(klass, command_string):
726
743
        def from_diff_tree(diff_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,
 
744
            return klass.from_string(command_string, diff_tree.old_tree,
731
745
                                     diff_tree.new_tree, diff_tree.to_file)
732
746
        return from_diff_tree
733
747
 
734
748
    def _get_command(self, old_path, new_path):
735
749
        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
 
750
        return [AtTemplate(t).substitute(my_map) for t in
 
751
                self.command_template]
748
752
 
749
753
    def _execute(self, old_path, new_path):
750
754
        command = self._get_command(old_path, new_path)
770
774
                raise
771
775
        return True
772
776
 
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
777
    def _write_file(self, file_id, tree, prefix, relpath, force_temp=False,
802
778
                    allow_write=False):
803
779
        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)
 
780
            return tree.abspath(tree.id2path(file_id))
 
781
        
 
782
        full_path = osutils.pathjoin(self._root, prefix, relpath)
809
783
        if not force_temp and self._try_symlink_root(tree, prefix):
810
784
            return full_path
811
785
        parent_dir = osutils.dirname(full_path)
868
842
        """
869
843
        old_path = self.old_tree.id2path(file_id)
870
844
        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)
 
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))
876
850
        subprocess.call(command, cwd=self._root)
877
 
        new_file = open(new_abs_path, 'rb')
 
851
        new_file = open(new_abs_path, 'r')
878
852
        try:
879
853
            return new_file.read()
880
854
        finally:
926
900
    @classmethod
927
901
    def from_trees_options(klass, old_tree, new_tree, to_file,
928
902
                           path_encoding, external_diff_options, old_label,
929
 
                           new_label, using, context_lines):
 
903
                           new_label, using):
930
904
        """Factory for producing a DiffTree.
931
905
 
932
906
        Designed to accept options used by show_diff_trees.
933
 
 
934
907
        :param old_tree: The tree to show as old in the comparison
935
908
        :param new_tree: The tree to show as new in the comparison
936
909
        :param to_file: File to write comparisons to
942
915
        :param using: Commandline to use to invoke an external diff tool
943
916
        """
944
917
        if using is not None:
945
 
            extra_factories = [DiffFromTool.make_from_diff_tree(using, external_diff_options)]
 
918
            extra_factories = [DiffFromTool.make_from_diff_tree(using)]
946
919
        else:
947
920
            extra_factories = []
948
921
        if external_diff_options:
949
922
            opts = external_diff_options.split()
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
 
                """
 
923
            def diff_file(olab, olines, nlab, nlines, to_file):
954
924
                external_diff(olab, olines, nlab, nlines, to_file, opts)
955
925
        else:
956
926
            diff_file = internal_diff
957
927
        diff_text = DiffText(old_tree, new_tree, to_file, path_encoding,
958
 
                             old_label, new_label, diff_file, context_lines=context_lines)
 
928
                             old_label, new_label, diff_file)
959
929
        return klass(old_tree, new_tree, to_file, path_encoding, diff_text,
960
930
                     extra_factories)
961
931