← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Martin Pool
  • Date: 2005-05-09 03:03:55 UTC
  • Revision ID: mbp@sourcefrog.net-20050509030355-ad6ab558d1362959
- Don't give an error if the trace file can't be opened

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
 
1
#! /usr/bin/env python
1
2
# -*- coding: UTF-8 -*-
2
3
 
3
4
# This program is free software; you can redistribute it and/or modify
14
15
# along with this program; if not, write to the Free Software
15
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
 
from bzrlib.trace import mutter
18
 
from bzrlib.errors import BzrError
19
 
from bzrlib.delta import compare_trees
20
 
 
21
 
# TODO: Rather than building a changeset object, we should probably
22
 
# invoke callbacks on an object.  That object can either accumulate a
23
 
# list, write them out directly, etc etc.
24
 
 
25
 
def internal_diff(old_filename, oldlines, new_filename, newlines, to_file):
26
 
    import difflib
27
 
    
28
 
    # FIXME: difflib is wrong if there is no trailing newline.
29
 
    # The syntax used by patch seems to be "\ No newline at
30
 
    # end of file" following the last diff line from that
31
 
    # file.  This is not trivial to insert into the
32
 
    # unified_diff output and it might be better to just fix
33
 
    # or replace that function.
34
 
 
35
 
    # In the meantime we at least make sure the patch isn't
36
 
    # mangled.
37
 
 
38
 
 
39
 
    # Special workaround for Python2.3, where difflib fails if
40
 
    # both sequences are empty.
41
 
    if not oldlines and not newlines:
42
 
        return
43
 
 
44
 
    ud = difflib.unified_diff(oldlines, newlines,
45
 
                              fromfile=old_filename+'\t', 
46
 
                              tofile=new_filename+'\t')
47
 
 
48
 
    ud = list(ud)
49
 
    # work-around for difflib being too smart for its own good
50
 
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
51
 
    if not oldlines:
52
 
        ud[2] = ud[2].replace('-1,0', '-0,0')
53
 
    elif not newlines:
54
 
        ud[2] = ud[2].replace('+1,0', '+0,0')
55
 
    # work around for difflib emitting random spaces after the label
56
 
    ud[0] = ud[0][:-2] + '\n'
57
 
    ud[1] = ud[1][:-2] + '\n'
58
 
 
59
 
    for line in ud:
60
 
        to_file.write(line)
61
 
        if not line.endswith('\n'):
62
 
            to_file.write("\n\\ No newline at end of file\n")
63
 
    print >>to_file
64
 
 
65
 
 
66
 
def external_diff(old_filename, oldlines, new_filename, newlines, to_file,
67
 
                  diff_opts):
68
 
    """Display a diff by calling out to the external diff program."""
69
 
    import sys
70
 
    
71
 
    if to_file != sys.stdout:
72
 
        raise NotImplementedError("sorry, can't send external diff other than to stdout yet",
73
 
                                  to_file)
74
 
 
75
 
    # make sure our own output is properly ordered before the diff
76
 
    to_file.flush()
77
 
 
78
 
    from tempfile import NamedTemporaryFile
79
 
    import os
80
 
 
81
 
    oldtmpf = NamedTemporaryFile()
82
 
    newtmpf = NamedTemporaryFile()
83
 
 
84
 
    try:
85
 
        # TODO: perhaps a special case for comparing to or from the empty
86
 
        # sequence; can just use /dev/null on Unix
87
 
 
88
 
        # TODO: if either of the files being compared already exists as a
89
 
        # regular named file (e.g. in the working directory) then we can
90
 
        # compare directly to that, rather than copying it.
91
 
 
92
 
        oldtmpf.writelines(oldlines)
93
 
        newtmpf.writelines(newlines)
94
 
 
95
 
        oldtmpf.flush()
96
 
        newtmpf.flush()
97
 
 
98
 
        if not diff_opts:
99
 
            diff_opts = []
100
 
        diffcmd = ['diff',
101
 
                   '--label', old_filename+'\t',
102
 
                   oldtmpf.name,
103
 
                   '--label', new_filename+'\t',
104
 
                   newtmpf.name]
105
 
 
106
 
        # diff only allows one style to be specified; they don't override.
107
 
        # note that some of these take optargs, and the optargs can be
108
 
        # directly appended to the options.
109
 
        # this is only an approximate parser; it doesn't properly understand
110
 
        # the grammar.
111
 
        for s in ['-c', '-u', '-C', '-U',
112
 
                  '-e', '--ed',
113
 
                  '-q', '--brief',
114
 
                  '--normal',
115
 
                  '-n', '--rcs',
116
 
                  '-y', '--side-by-side',
117
 
                  '-D', '--ifdef']:
118
 
            for j in diff_opts:
119
 
                if j.startswith(s):
120
 
                    break
121
 
            else:
122
 
                continue
123
 
            break
124
 
        else:
125
 
            diffcmd.append('-u')
126
 
                  
127
 
        if diff_opts:
128
 
            diffcmd.extend(diff_opts)
129
 
 
130
 
        rc = os.spawnvp(os.P_WAIT, 'diff', diffcmd)
 
18
from sets import Set
 
19
 
 
20
from trace import mutter
 
21
from errors import BzrError
 
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):
 
56
        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, types
 
145
    
 
146
    if revision == None:
 
147
        old_tree = b.basis_tree()
 
148
    else:
 
149
        old_tree = b.revision_tree(b.lookup_revision(revision))
131
150
        
132
 
        if rc != 0 and rc != 1:
133
 
            # returns 1 if files differ; that's OK
134
 
            if rc < 0:
135
 
                msg = 'signal %d' % (-rc)
136
 
            else:
137
 
                msg = 'exit code %d' % rc
138
 
                
139
 
            raise BzrError('external diff failed with %s; command: %r' % (rc, diffcmd))
140
 
    finally:
141
 
        oldtmpf.close()                 # and delete
142
 
        newtmpf.close()
143
 
 
144
 
def show_diff(b, from_spec, specific_files, external_diff_options=None,
145
 
              revision2=None, output=None, b2=None):
146
 
    """Shortcut for showing the diff to the working tree.
147
 
 
148
 
    b
149
 
        Branch.
150
 
 
151
 
    revision
152
 
        None for 'basis tree', or otherwise the old revision to compare against.
153
 
    
154
 
    The more general form is show_diff_trees(), where the caller
155
 
    supplies any two trees.
156
 
    """
157
 
    if output is None:
158
 
        import sys
159
 
        output = sys.stdout
160
 
 
161
 
    if from_spec is None:
162
 
        if b2 is None:
163
 
            old_tree = b.basis_tree()
164
 
        else:
165
 
            old_tree = b.working_tree()
166
 
    else:
167
 
        old_tree = b.revision_tree(from_spec.in_history(b).rev_id)
168
 
 
169
 
    if revision2 is None:
170
 
        if b2 is None:
171
 
            new_tree = b.working_tree()
172
 
        else:
173
 
            new_tree = b2.working_tree()
174
 
    else:
175
 
        new_tree = b.revision_tree(revision2.in_history(b).rev_id)
176
 
 
177
 
    return show_diff_trees(old_tree, new_tree, output, specific_files,
178
 
                           external_diff_options)
179
 
 
180
 
 
181
 
 
182
 
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
183
 
                    external_diff_options=None):
184
 
    """Show in text form the changes from one tree to another.
185
 
 
186
 
    to_files
187
 
        If set, include only changes to these files.
188
 
 
189
 
    external_diff_options
190
 
        If set, use an external GNU diff and pass these options.
191
 
    """
 
151
    new_tree = b.working_tree()
192
152
 
193
153
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
194
154
    old_label = ''
202
162
    # TODO: Generation of pseudo-diffs for added/deleted files could
203
163
    # be usefully made into a much faster special case.
204
164
 
205
 
    if external_diff_options:
206
 
        assert isinstance(external_diff_options, basestring)
207
 
        opts = external_diff_options.split()
208
 
        def diff_file(olab, olines, nlab, nlines, to_file):
209
 
            external_diff(olab, olines, nlab, nlines, to_file, opts)
210
 
    else:
211
 
        diff_file = internal_diff
212
 
    
213
 
 
214
 
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
215
 
                          specific_files=specific_files)
216
 
 
217
 
    has_changes = 0
218
 
    for path, file_id, kind in delta.removed:
219
 
        has_changes = 1
220
 
        print >>to_file, '=== removed %s %r' % (kind, path)
221
 
        old_tree.inventory[file_id].diff(diff_file, old_label + path, old_tree,
222
 
                                         DEVNULL, None, None, to_file)
223
 
    for path, file_id, kind in delta.added:
224
 
        has_changes = 1
225
 
        print >>to_file, '=== added %s %r' % (kind, path)
226
 
        new_tree.inventory[file_id].diff(diff_file, new_label + path, new_tree,
227
 
                                         DEVNULL, None, None, to_file, 
228
 
                                         reverse=True)
229
 
    for (old_path, new_path, file_id, kind,
230
 
         text_modified, meta_modified) in delta.renamed:
231
 
        has_changes = 1
232
 
        prop_str = get_prop_change(meta_modified)
233
 
        print >>to_file, '=== renamed %s %r => %r%s' % (
234
 
                          kind, old_path, new_path, prop_str)
235
 
        _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
236
 
                                    new_label, new_path, new_tree,
237
 
                                    text_modified, kind, to_file, diff_file)
238
 
    for path, file_id, kind, text_modified, meta_modified in delta.modified:
239
 
        has_changes = 1
240
 
        prop_str = get_prop_change(meta_modified)
241
 
        print >>to_file, '=== modified %s %r%s' % (kind, path, prop_str)
242
 
        if text_modified:
243
 
            _maybe_diff_file_or_symlink(old_label, path, old_tree, file_id,
244
 
                                        new_label, path, new_tree,
245
 
                                        True, kind, to_file, diff_file)
246
 
    return has_changes
247
 
    
248
 
 
249
 
def get_prop_change(meta_modified):
250
 
    if meta_modified:
251
 
        return " (properties changed)"
252
 
    else:
253
 
        return  ""
254
 
 
255
 
 
256
 
def _maybe_diff_file_or_symlink(old_label, old_path, old_tree, file_id,
257
 
                                new_label, new_path, new_tree, text_modified,
258
 
                                kind, to_file, diff_file):
259
 
    if text_modified:
260
 
        new_entry = new_tree.inventory[file_id]
261
 
        old_tree.inventory[file_id].diff(diff_file,
262
 
                                         old_label + old_path, old_tree,
263
 
                                         new_label + new_path, new_entry, 
264
 
                                         new_tree, to_file)
 
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
            raise BzrError("can't represent state %s {%s}" % (file_state, fid))
 
249
 
 
250
 
 
251
 
 
252
class TreeDelta:
 
253
    """Describes changes from one tree to another.
 
254
 
 
255
    Contains four lists:
 
256
 
 
257
    added
 
258
        (path, id)
 
259
    removed
 
260
        (path, id)
 
261
    renamed
 
262
        (oldpath, newpath, id)
 
263
    modified
 
264
        (path, id)
 
265
 
 
266
    A path may occur in more than one list if it was e.g. deleted
 
267
    under an old id and renamed into place in a new id.
 
268
 
 
269
    Files are listed in either modified or renamed, not both.  In
 
270
    other words, renamed files may also be modified.
 
271
    """
 
272
    def __init__(self):
 
273
        self.added = []
 
274
        self.removed = []
 
275
        self.renamed = []
 
276
        self.modified = []
 
277
 
 
278
 
 
279
def compare_inventories(old_inv, new_inv):
 
280
    """Return a TreeDelta object describing changes between inventories.
 
281
 
 
282
    This only describes changes in the shape of the tree, not the
 
283
    actual texts.
 
284
 
 
285
    This is an alternative to diff_trees() and should probably
 
286
    eventually replace it.
 
287
    """
 
288
    old_ids = old_inv.id_set()
 
289
    new_ids = new_inv.id_set()
 
290
    delta = TreeDelta()
 
291
 
 
292
    delta.removed = [(old_inv.id2path(fid), fid) for fid in (old_ids - new_ids)]
 
293
    delta.removed.sort()
 
294
 
 
295
    delta.added = [(new_inv.id2path(fid), fid) for fid in (new_ids - old_ids)]
 
296
    delta.added.sort()
 
297
 
 
298
    for fid in old_ids & new_ids:
 
299
        old_ie = old_inv[fid]
 
300
        new_ie = new_inv[fid]
 
301
        old_path = old_inv.id2path(fid)
 
302
        new_path = new_inv.id2path(fid)
 
303
 
 
304
        if old_path != new_path:
 
305
            delta.renamed.append((old_path, new_path, fid))
 
306
        elif old_ie.text_sha1 != new_ie.text_sha1:
 
307
            delta.modified.append((new_path, fid))
 
308
 
 
309
    delta.modified.sort()
 
310
    delta.renamed.sort()    
 
311
 
 
312
    return delta