~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Aaron Bentley
  • Date: 2006-05-30 15:18:12 UTC
  • mto: This revision was merged to the branch mainline in revision 1738.
  • Revision ID: abentley@panoramicfeedback.com-20060530151812-0e3e9b78cc15a804
Rename changesets to revision bundles

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#! /usr/bin/env python
2
 
# -*- coding: UTF-8 -*-
 
1
# Copyright (C) 2004, 2005, 2006 Canonical Ltd.
3
2
 
4
3
# This program is free software; you can redistribute it and/or modify
5
4
# it under the terms of the GNU General Public License as published by
15
14
# along with this program; if not, write to the Free Software
16
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
 
18
 
from sets import Set
19
 
 
20
 
from trace import mutter
21
 
 
22
 
 
23
 
 
24
 
 
25
 
 
26
 
 
27
 
def diff_trees(old_tree, new_tree):
28
 
    """Compute diff between two trees.
29
 
 
30
 
    They may be in different branches and may be working or historical
31
 
    trees.
32
 
 
33
 
    Yields a sequence of (state, id, old_name, new_name, kind).
34
 
    Each filename and each id is listed only once.
35
 
    """
36
 
 
37
 
    ## TODO: Compare files before diffing; only mention those that have changed
38
 
 
39
 
    ## TODO: Set nice names in the headers, maybe include diffstat
40
 
 
41
 
    ## TODO: Perhaps make this a generator rather than using
42
 
    ## a callback object?
43
 
 
44
 
    ## TODO: Allow specifying a list of files to compare, rather than
45
 
    ## doing the whole tree?  (Not urgent.)
46
 
 
47
 
    ## TODO: Allow diffing any two inventories, not just the
48
 
    ## current one against one.  We mgiht need to specify two
49
 
    ## stores to look for the files if diffing two branches.  That
50
 
    ## might imply this shouldn't be primarily a Branch method.
51
 
 
52
 
    ## XXX: This doesn't report on unknown files; that can be done
53
 
    ## from a separate method.
54
 
 
55
 
    old_it = old_tree.list_files()
56
 
    new_it = new_tree.list_files()
57
 
 
58
 
    def next(it):
 
17
from bzrlib.delta import compare_trees
 
18
from bzrlib.errors import BzrError
 
19
import bzrlib.errors as errors
 
20
from bzrlib.patiencediff import SequenceMatcher, unified_diff
 
21
from bzrlib.symbol_versioning import *
 
22
from bzrlib.textfile import check_text_lines
 
23
from bzrlib.trace import mutter
 
24
 
 
25
# TODO: Rather than building a changeset object, we should probably
 
26
# invoke callbacks on an object.  That object can either accumulate a
 
27
# list, write them out directly, etc etc.
 
28
 
 
29
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file,
 
30
                  allow_binary=False, sequence_matcher=None):
 
31
    # FIXME: difflib is wrong if there is no trailing newline.
 
32
    # The syntax used by patch seems to be "\ No newline at
 
33
    # end of file" following the last diff line from that
 
34
    # file.  This is not trivial to insert into the
 
35
    # unified_diff output and it might be better to just fix
 
36
    # or replace that function.
 
37
 
 
38
    # In the meantime we at least make sure the patch isn't
 
39
    # mangled.
 
40
 
 
41
 
 
42
    # Special workaround for Python2.3, where difflib fails if
 
43
    # both sequences are empty.
 
44
    if not oldlines and not newlines:
 
45
        return
 
46
    
 
47
    if allow_binary is False:
 
48
        check_text_lines(oldlines)
 
49
        check_text_lines(newlines)
 
50
 
 
51
    if sequence_matcher is None:
 
52
        sequence_matcher = SequenceMatcher
 
53
    ud = unified_diff(oldlines, newlines,
 
54
                      fromfile=old_filename+'\t', 
 
55
                      tofile=new_filename+'\t',
 
56
                      sequencematcher=sequence_matcher)
 
57
 
 
58
    ud = list(ud)
 
59
    # work-around for difflib being too smart for its own good
 
60
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
 
61
    if not oldlines:
 
62
        ud[2] = ud[2].replace('-1,0', '-0,0')
 
63
    elif not newlines:
 
64
        ud[2] = ud[2].replace('+1,0', '+0,0')
 
65
    # work around for difflib emitting random spaces after the label
 
66
    ud[0] = ud[0][:-2] + '\n'
 
67
    ud[1] = ud[1][:-2] + '\n'
 
68
 
 
69
    for line in ud:
 
70
        to_file.write(line)
 
71
        if not line.endswith('\n'):
 
72
            to_file.write("\n\\ No newline at end of file\n")
 
73
    print >>to_file
 
74
 
 
75
 
 
76
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
 
77
                  diff_opts):
 
78
    """Display a diff by calling out to the external diff program."""
 
79
    import sys
 
80
    
 
81
    if to_file != sys.stdout:
 
82
        raise NotImplementedError("sorry, can't send external diff other than to stdout yet",
 
83
                                  to_file)
 
84
 
 
85
    # make sure our own output is properly ordered before the diff
 
86
    to_file.flush()
 
87
 
 
88
    from tempfile import NamedTemporaryFile
 
89
    import os
 
90
 
 
91
    oldtmpf = NamedTemporaryFile()
 
92
    newtmpf = NamedTemporaryFile()
 
93
 
 
94
    try:
 
95
        # TODO: perhaps a special case for comparing to or from the empty
 
96
        # sequence; can just use /dev/null on Unix
 
97
 
 
98
        # TODO: if either of the files being compared already exists as a
 
99
        # regular named file (e.g. in the working directory) then we can
 
100
        # compare directly to that, rather than copying it.
 
101
 
 
102
        oldtmpf.writelines(oldlines)
 
103
        newtmpf.writelines(newlines)
 
104
 
 
105
        oldtmpf.flush()
 
106
        newtmpf.flush()
 
107
 
 
108
        if not diff_opts:
 
109
            diff_opts = []
 
110
        diffcmd = ['diff',
 
111
                   '--label', old_filename+'\t',
 
112
                   oldtmpf.name,
 
113
                   '--label', new_filename+'\t',
 
114
                   newtmpf.name]
 
115
 
 
116
        # diff only allows one style to be specified; they don't override.
 
117
        # note that some of these take optargs, and the optargs can be
 
118
        # directly appended to the options.
 
119
        # this is only an approximate parser; it doesn't properly understand
 
120
        # the grammar.
 
121
        for s in ['-c', '-u', '-C', '-U',
 
122
                  '-e', '--ed',
 
123
                  '-q', '--brief',
 
124
                  '--normal',
 
125
                  '-n', '--rcs',
 
126
                  '-y', '--side-by-side',
 
127
                  '-D', '--ifdef']:
 
128
            for j in diff_opts:
 
129
                if j.startswith(s):
 
130
                    break
 
131
            else:
 
132
                continue
 
133
            break
 
134
        else:
 
135
            diffcmd.append('-u')
 
136
                  
 
137
        if diff_opts:
 
138
            diffcmd.extend(diff_opts)
 
139
 
 
140
        rc = os.spawnvp(os.P_WAIT, 'diff', diffcmd)
 
141
        
 
142
        if rc != 0 and rc != 1:
 
143
            # returns 1 if files differ; that's OK
 
144
            if rc < 0:
 
145
                msg = 'signal %d' % (-rc)
 
146
            else:
 
147
                msg = 'exit code %d' % rc
 
148
                
 
149
            raise BzrError('external diff failed with %s; command: %r' % (rc, diffcmd))
 
150
    finally:
 
151
        oldtmpf.close()                 # and delete
 
152
        newtmpf.close()
 
153
 
 
154
 
 
155
@deprecated_function(zero_eight)
 
156
def show_diff(b, from_spec, specific_files, external_diff_options=None,
 
157
              revision2=None, output=None, b2=None):
 
158
    """Shortcut for showing the diff to the working tree.
 
159
 
 
160
    Please use show_diff_trees instead.
 
161
 
 
162
    b
 
163
        Branch.
 
164
 
 
165
    revision
 
166
        None for 'basis tree', or otherwise the old revision to compare against.
 
167
    
 
168
    The more general form is show_diff_trees(), where the caller
 
169
    supplies any two trees.
 
170
    """
 
171
    if output is None:
 
172
        import sys
 
173
        output = sys.stdout
 
174
 
 
175
    if from_spec is None:
 
176
        old_tree = b.bzrdir.open_workingtree()
 
177
        if b2 is None:
 
178
            old_tree = old_tree = old_tree.basis_tree()
 
179
    else:
 
180
        old_tree = b.repository.revision_tree(from_spec.in_history(b).rev_id)
 
181
 
 
182
    if revision2 is None:
 
183
        if b2 is None:
 
184
            new_tree = b.bzrdir.open_workingtree()
 
185
        else:
 
186
            new_tree = b2.bzrdir.open_workingtree()
 
187
    else:
 
188
        new_tree = b.repository.revision_tree(revision2.in_history(b).rev_id)
 
189
 
 
190
    return show_diff_trees(old_tree, new_tree, output, specific_files,
 
191
                           external_diff_options)
 
192
 
 
193
 
 
194
def diff_cmd_helper(tree, specific_files, external_diff_options, 
 
195
                    old_revision_spec=None, new_revision_spec=None,
 
196
                    old_label='a/', new_label='b/'):
 
197
    """Helper for cmd_diff.
 
198
 
 
199
   tree 
 
200
        A WorkingTree
 
201
 
 
202
    specific_files
 
203
        The specific files to compare, or None
 
204
 
 
205
    external_diff_options
 
206
        If non-None, run an external diff, and pass it these options
 
207
 
 
208
    old_revision_spec
 
209
        If None, use basis tree as old revision, otherwise use the tree for
 
210
        the specified revision. 
 
211
 
 
212
    new_revision_spec
 
213
        If None, use working tree as new revision, otherwise use the tree for
 
214
        the specified revision.
 
215
    
 
216
    The more general form is show_diff_trees(), where the caller
 
217
    supplies any two trees.
 
218
    """
 
219
    import sys
 
220
    output = sys.stdout
 
221
    def spec_tree(spec):
 
222
        revision_id = spec.in_store(tree.branch).rev_id
 
223
        return tree.branch.repository.revision_tree(revision_id)
 
224
    if old_revision_spec is None:
 
225
        old_tree = tree.basis_tree()
 
226
    else:
 
227
        old_tree = spec_tree(old_revision_spec)
 
228
 
 
229
    if new_revision_spec is None:
 
230
        new_tree = tree
 
231
    else:
 
232
        new_tree = spec_tree(new_revision_spec)
 
233
 
 
234
    return show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
 
235
                           external_diff_options,
 
236
                           old_label=old_label, new_label=new_label)
 
237
 
 
238
 
 
239
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
 
240
                    external_diff_options=None,
 
241
                    old_label='a/', new_label='b/'):
 
242
    """Show in text form the changes from one tree to another.
 
243
 
 
244
    to_files
 
245
        If set, include only changes to these files.
 
246
 
 
247
    external_diff_options
 
248
        If set, use an external GNU diff and pass these options.
 
249
    """
 
250
    old_tree.lock_read()
 
251
    try:
 
252
        new_tree.lock_read()
59
253
        try:
60
 
            return it.next()
61
 
        except StopIteration:
62
 
            return None
63
 
 
64
 
    old_item = next(old_it)
65
 
    new_item = next(new_it)
66
 
 
67
 
    # We step through the two sorted iterators in parallel, trying to
68
 
    # keep them lined up.
69
 
 
70
 
    while (old_item != None) or (new_item != None):
71
 
        # OK, we still have some remaining on both, but they may be
72
 
        # out of step.        
73
 
        if old_item != None:
74
 
            old_name, old_class, old_kind, old_id = old_item
75
 
        else:
76
 
            old_name = None
77
 
            
78
 
        if new_item != None:
79
 
            new_name, new_class, new_kind, new_id = new_item
80
 
        else:
81
 
            new_name = None
82
 
 
83
 
        mutter("   diff pairwise %r" % (old_item,))
84
 
        mutter("                 %r" % (new_item,))
85
 
 
86
 
        if old_item:
87
 
            # can't handle the old tree being a WorkingTree
88
 
            assert old_class == 'V'
89
 
 
90
 
        if new_item and (new_class != 'V'):
91
 
            yield new_class, None, None, new_name, new_kind
92
 
            new_item = next(new_it)
93
 
        elif (not new_item) or (old_item and (old_name < new_name)):
94
 
            mutter("     extra entry in old-tree sequence")
95
 
            if new_tree.has_id(old_id):
96
 
                # will be mentioned as renamed under new name
97
 
                pass
98
 
            else:
99
 
                yield 'D', old_id, old_name, None, old_kind
100
 
            old_item = next(old_it)
101
 
        elif (not old_item) or (new_item and (new_name < old_name)):
102
 
            mutter("     extra entry in new-tree sequence")
103
 
            if old_tree.has_id(new_id):
104
 
                yield 'R', new_id, old_tree.id2path(new_id), new_name, new_kind
105
 
            else:
106
 
                yield 'A', new_id, None, new_name, new_kind
107
 
            new_item = next(new_it)
108
 
        elif old_id != new_id:
109
 
            assert old_name == new_name
110
 
            # both trees have a file of this name, but it is not the
111
 
            # same file.  in other words, the old filename has been
112
 
            # overwritten by either a newly-added or a renamed file.
113
 
            # (should we return something about the overwritten file?)
114
 
            if old_tree.has_id(new_id):
115
 
                # renaming, overlying a deleted file
116
 
                yield 'R', new_id, old_tree.id2path(new_id), new_name, new_kind
117
 
            else:
118
 
                yield 'A', new_id, None, new_name, new_kind
119
 
 
120
 
            new_item = next(new_it)
121
 
            old_item = next(old_it)
122
 
        else:
123
 
            assert old_id == new_id
124
 
            assert old_id != None
125
 
            assert old_name == new_name
126
 
            assert old_kind == new_kind
127
 
 
128
 
            if old_kind == 'directory':
129
 
                yield '.', new_id, old_name, new_name, new_kind
130
 
            elif old_tree.get_file_size(old_id) != new_tree.get_file_size(old_id):
131
 
                mutter("    file size has changed, must be different")
132
 
                yield 'M', new_id, old_name, new_name, new_kind
133
 
            elif old_tree.get_file_sha1(old_id) == new_tree.get_file_sha1(old_id):
134
 
                mutter("      SHA1 indicates they're identical")
135
 
                ## assert compare_files(old_tree.get_file(i), new_tree.get_file(i))
136
 
                yield '.', new_id, old_name, new_name, new_kind
137
 
            else:
138
 
                mutter("      quick compare shows different")
139
 
                yield 'M', new_id, old_name, new_name, new_kind
140
 
 
141
 
            new_item = next(new_it)
142
 
            old_item = next(old_it)
143
 
 
144
 
 
 
254
            return _show_diff_trees(old_tree, new_tree, to_file,
 
255
                                    specific_files, external_diff_options,
 
256
                                    old_label=old_label, new_label=new_label)
 
257
        finally:
 
258
            new_tree.unlock()
 
259
    finally:
 
260
        old_tree.unlock()
 
261
 
 
262
 
 
263
def _show_diff_trees(old_tree, new_tree, to_file,
 
264
                     specific_files, external_diff_options, 
 
265
                     old_label='a/', new_label='b/' ):
 
266
 
 
267
    DEVNULL = '/dev/null'
 
268
    # Windows users, don't panic about this filename -- it is a
 
269
    # special signal to GNU patch that the file should be created or
 
270
    # deleted respectively.
 
271
 
 
272
    # TODO: Generation of pseudo-diffs for added/deleted files could
 
273
    # be usefully made into a much faster special case.
 
274
 
 
275
    _raise_if_doubly_unversioned(specific_files, old_tree, new_tree)
 
276
 
 
277
    if external_diff_options:
 
278
        assert isinstance(external_diff_options, basestring)
 
279
        opts = external_diff_options.split()
 
280
        def diff_file(olab, olines, nlab, nlines, to_file):
 
281
            external_diff(olab, olines, nlab, nlines, to_file, opts)
 
282
    else:
 
283
        diff_file = internal_diff
 
284
    
 
285
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
 
286
                          specific_files=specific_files)
 
287
 
 
288
    has_changes = 0
 
289
    for path, file_id, kind in delta.removed:
 
290
        has_changes = 1
 
291
        print >>to_file, '=== removed %s %r' % (kind, path)
 
292
        old_tree.inventory[file_id].diff(diff_file, old_label + path, old_tree,
 
293
                                         DEVNULL, None, None, to_file)
 
294
    for path, file_id, kind in delta.added:
 
295
        has_changes = 1
 
296
        print >>to_file, '=== added %s %r' % (kind, path)
 
297
        new_tree.inventory[file_id].diff(diff_file, new_label + path, new_tree,
 
298
                                         DEVNULL, None, None, to_file, 
 
299
                                         reverse=True)
 
300
    for (old_path, new_path, file_id, kind,
 
301
         text_modified, meta_modified) in delta.renamed:
 
302
        has_changes = 1
 
303
        prop_str = get_prop_change(meta_modified)
 
304
        print >>to_file, '=== renamed %s %r => %r%s' % (
 
305
                    kind, old_path, new_path, prop_str)
 
306
        _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
 
307
                                    new_label, new_path, new_tree,
 
308
                                    text_modified, kind, to_file, diff_file)
 
309
    for path, file_id, kind, text_modified, meta_modified in delta.modified:
 
310
        has_changes = 1
 
311
        prop_str = get_prop_change(meta_modified)
 
312
        print >>to_file, '=== modified %s %r%s' % (kind, path, prop_str)
 
313
        if text_modified:
 
314
            _maybe_diff_file_or_symlink(old_label, path, old_tree, file_id,
 
315
                                        new_label, path, new_tree,
 
316
                                        True, kind, to_file, diff_file)
 
317
 
 
318
    return has_changes
 
319
 
 
320
 
 
321
def _raise_if_doubly_unversioned(specific_files, old_tree, new_tree):
 
322
    """Complain if paths are not versioned in either tree."""
 
323
    if not specific_files:
 
324
        return
 
325
    old_unversioned = old_tree.filter_unversioned_files(specific_files)
 
326
    new_unversioned = new_tree.filter_unversioned_files(specific_files)
 
327
    unversioned = old_unversioned.intersection(new_unversioned)
 
328
    if unversioned:
 
329
        raise errors.PathsNotVersionedError(sorted(unversioned))
 
330
    
 
331
 
 
332
def _raise_if_nonexistent(paths, old_tree, new_tree):
 
333
    """Complain if paths are not in either inventory or tree.
 
334
 
 
335
    It's OK with the files exist in either tree's inventory, or 
 
336
    if they exist in the tree but are not versioned.
 
337
    
 
338
    This can be used by operations such as bzr status that can accept
 
339
    unknown or ignored files.
 
340
    """
 
341
    mutter("check paths: %r", paths)
 
342
    if not paths:
 
343
        return
 
344
    s = old_tree.filter_unversioned_files(paths)
 
345
    s = new_tree.filter_unversioned_files(s)
 
346
    s = [path for path in s if not new_tree.has_filename(path)]
 
347
    if s:
 
348
        raise errors.PathsDoNotExist(sorted(s))
 
349
 
 
350
 
 
351
def get_prop_change(meta_modified):
 
352
    if meta_modified:
 
353
        return " (properties changed)"
 
354
    else:
 
355
        return  ""
 
356
 
 
357
 
 
358
def _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
 
359
                                new_label, new_path, new_tree, text_modified,
 
360
                                kind, to_file, diff_file):
 
361
    if text_modified:
 
362
        new_entry = new_tree.inventory[file_id]
 
363
        old_tree.inventory[file_id].diff(diff_file,
 
364
                                         old_label + old_path, old_tree,
 
365
                                         new_label + new_path, new_entry, 
 
366
                                         new_tree, to_file)