← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Aaron Bentley
  • Date: 2006-04-16 16:20:46 UTC
  • mto: This revision was merged to the branch mainline in revision 1673.
  • Revision ID: aaron.bentley@utoronto.ca-20060416162046-a50698189b032755
Handle binary files for diff3 merges

Show diffs side-by-side

added added

removed removed

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