/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: Martin Pool
  • Date: 2005-05-11 02:48:39 UTC
  • Revision ID: mbp@sourcefrog.net-20050511024839-7da25dca4d8c8bac
- diff now uses stat-cache -- much faster

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
 
from bzrlib.trace import mutter
19
 
from bzrlib.errors import BzrError
20
 
from bzrlib.delta import compare_trees
21
 
 
22
 
# TODO: Rather than building a changeset object, we should probably
23
 
# invoke callbacks on an object.  That object can either accumulate a
24
 
# list, write them out directly, etc etc.
25
 
 
26
 
def internal_diff(old_label, oldlines, new_label, newlines, to_file):
27
 
    import difflib
28
 
    
29
 
    # FIXME: difflib is wrong if there is no trailing newline.
30
 
    # The syntax used by patch seems to be "\ No newline at
31
 
    # end of file" following the last diff line from that
32
 
    # file.  This is not trivial to insert into the
33
 
    # unified_diff output and it might be better to just fix
34
 
    # or replace that function.
35
 
 
36
 
    # In the meantime we at least make sure the patch isn't
37
 
    # mangled.
38
 
 
39
 
 
40
 
    # Special workaround for Python2.3, where difflib fails if
41
 
    # both sequences are empty.
42
 
    if not oldlines and not newlines:
43
 
        return
44
 
 
45
 
    ud = difflib.unified_diff(oldlines, newlines,
46
 
                              fromfile=old_label, tofile=new_label)
47
 
 
48
 
    # work-around for difflib being too smart for its own good
49
 
    # if /dev/null is "1,0", patch won't recognize it as /dev/null
50
 
    if not oldlines:
51
 
        ud = list(ud)
52
 
        ud[2] = ud[2].replace('-1,0', '-0,0')
53
 
    elif not newlines:
54
 
        ud = list(ud)
55
 
        ud[2] = ud[2].replace('+1,0', '+0,0')
56
 
 
57
 
    for line in ud:
58
 
        to_file.write(line)
59
 
        if not line.endswith('\n'):
60
 
            to_file.write("\n\\ No newline at end of file\n")
61
 
    print >>to_file
62
 
 
63
 
 
64
 
 
65
 
 
66
 
def external_diff(old_label, oldlines, new_label, 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_label,
102
 
                   oldtmpf.name,
103
 
                   '--label', new_label,
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)
131
 
        
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
 
 
145
 
 
146
 
def show_diff(b, revision, specific_files, external_diff_options=None):
147
 
    """Shortcut for showing the diff to the working tree.
148
 
 
149
 
    b
150
 
        Branch.
151
 
 
152
 
    revision
153
 
        None for each, or otherwise the old revision to compare against.
154
 
    
155
 
    The more general form is show_diff_trees(), where the caller
156
 
    supplies any two trees.
 
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.
157
32
    """
158
 
    import sys
159
 
 
 
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
    sha_match_cnt = modified_cnt = 0
 
53
 
 
54
    old_it = old_tree.list_files()
 
55
    new_it = new_tree.list_files()
 
56
 
 
57
    def next(it):
 
58
        try:
 
59
            return it.next()
 
60
        except StopIteration:
 
61
            return None
 
62
 
 
63
    old_item = next(old_it)
 
64
    new_item = next(new_it)
 
65
 
 
66
    # We step through the two sorted iterators in parallel, trying to
 
67
    # keep them lined up.
 
68
 
 
69
    while (old_item != None) or (new_item != None):
 
70
        # OK, we still have some remaining on both, but they may be
 
71
        # out of step.        
 
72
        if old_item != None:
 
73
            old_name, old_class, old_kind, old_id = old_item
 
74
        else:
 
75
            old_name = None
 
76
            
 
77
        if new_item != None:
 
78
            new_name, new_class, new_kind, new_id = new_item
 
79
        else:
 
80
            new_name = None
 
81
 
 
82
        if old_item:
 
83
            # can't handle the old tree being a WorkingTree
 
84
            assert old_class == 'V'
 
85
 
 
86
        if new_item and (new_class != 'V'):
 
87
            yield new_class, None, None, new_name, new_kind
 
88
            new_item = next(new_it)
 
89
        elif (not new_item) or (old_item and (old_name < new_name)):
 
90
            if new_tree.has_id(old_id):
 
91
                # will be mentioned as renamed under new name
 
92
                pass
 
93
            else:
 
94
                yield 'D', old_id, old_name, None, old_kind
 
95
            old_item = next(old_it)
 
96
        elif (not old_item) or (new_item and (new_name < old_name)):
 
97
            if old_tree.has_id(new_id):
 
98
                yield 'R', new_id, old_tree.id2path(new_id), new_name, new_kind
 
99
            else:
 
100
                yield 'A', new_id, None, new_name, new_kind
 
101
            new_item = next(new_it)
 
102
        elif old_id != new_id:
 
103
            assert old_name == new_name
 
104
            # both trees have a file of this name, but it is not the
 
105
            # same file.  in other words, the old filename has been
 
106
            # overwritten by either a newly-added or a renamed file.
 
107
            # (should we return something about the overwritten file?)
 
108
            if old_tree.has_id(new_id):
 
109
                # renaming, overlying a deleted file
 
110
                yield 'R', new_id, old_tree.id2path(new_id), new_name, new_kind
 
111
            else:
 
112
                yield 'A', new_id, None, new_name, new_kind
 
113
 
 
114
            new_item = next(new_it)
 
115
            old_item = next(old_it)
 
116
        else:
 
117
            assert old_id == new_id
 
118
            assert old_id != None
 
119
            assert old_name == new_name
 
120
            assert old_kind == new_kind
 
121
 
 
122
            if old_kind == 'directory':
 
123
                yield '.', new_id, old_name, new_name, new_kind
 
124
            elif old_tree.get_file_sha1(old_id) == new_tree.get_file_sha1(old_id):
 
125
                sha_match_cnt += 1
 
126
                yield '.', new_id, old_name, new_name, new_kind
 
127
            else:
 
128
                modified_cnt += 1
 
129
                yield 'M', new_id, old_name, new_name, new_kind
 
130
 
 
131
            new_item = next(new_it)
 
132
            old_item = next(old_it)
 
133
 
 
134
 
 
135
    mutter("diff finished: %d SHA matches, %d modified"
 
136
           % (sha_match_cnt, modified_cnt))
 
137
 
 
138
 
 
139
 
 
140
def show_diff(b, revision, file_list):
 
141
    import difflib, sys, types
 
142
    
160
143
    if revision == None:
161
144
        old_tree = b.basis_tree()
162
145
    else:
164
147
        
165
148
    new_tree = b.working_tree()
166
149
 
167
 
    show_diff_trees(old_tree, new_tree, sys.stdout, specific_files,
168
 
                    external_diff_options)
169
 
 
170
 
 
171
 
 
172
 
def show_diff_trees(old_tree, new_tree, to_file, specific_files=None,
173
 
                    external_diff_options=None):
174
 
    """Show in text form the changes from one tree to another.
175
 
 
176
 
    to_files
177
 
        If set, include only changes to these files.
178
 
 
179
 
    external_diff_options
180
 
        If set, use an external GNU diff and pass these options.
181
 
    """
182
 
 
183
150
    # TODO: Options to control putting on a prefix or suffix, perhaps as a format string
184
151
    old_label = ''
185
152
    new_label = ''
192
159
    # TODO: Generation of pseudo-diffs for added/deleted files could
193
160
    # be usefully made into a much faster special case.
194
161
 
195
 
    if external_diff_options:
196
 
        assert isinstance(external_diff_options, basestring)
197
 
        opts = external_diff_options.split()
198
 
        def diff_file(olab, olines, nlab, nlines, to_file):
199
 
            external_diff(olab, olines, nlab, nlines, to_file, opts)
200
 
    else:
201
 
        diff_file = internal_diff
 
162
    # TODO: Better to return them in sorted order I think.
 
163
 
 
164
    if file_list:
 
165
        file_list = [b.relpath(f) for f in file_list]
 
166
 
 
167
    # FIXME: If given a file list, compare only those files rather
 
168
    # than comparing everything and then throwing stuff away.
202
169
    
203
 
 
204
 
    delta = compare_trees(old_tree, new_tree, want_unchanged=False,
205
 
                          specific_files=specific_files)
206
 
 
207
 
    for path, file_id, kind in delta.removed:
208
 
        print >>to_file, '*** removed %s %r' % (kind, path)
209
 
        if kind == 'file':
210
 
            diff_file(old_label + path,
211
 
                      old_tree.get_file(file_id).readlines(),
212
 
                      DEVNULL, 
213
 
                      [],
214
 
                      to_file)
215
 
 
216
 
    for path, file_id, kind in delta.added:
217
 
        print >>to_file, '*** added %s %r' % (kind, path)
218
 
        if kind == 'file':
219
 
            diff_file(DEVNULL,
220
 
                      [],
221
 
                      new_label + path,
222
 
                      new_tree.get_file(file_id).readlines(),
223
 
                      to_file)
224
 
 
225
 
    for old_path, new_path, file_id, kind, text_modified in delta.renamed:
226
 
        print >>to_file, '*** renamed %s %r => %r' % (kind, old_path, new_path)
227
 
        if text_modified:
228
 
            diff_file(old_label + old_path,
229
 
                      old_tree.get_file(file_id).readlines(),
230
 
                      new_label + new_path,
231
 
                      new_tree.get_file(file_id).readlines(),
232
 
                      to_file)
233
 
 
234
 
    for path, file_id, kind in delta.modified:
235
 
        print >>to_file, '*** modified %s %r' % (kind, path)
236
 
        if kind == 'file':
237
 
            diff_file(old_label + path,
238
 
                      old_tree.get_file(file_id).readlines(),
239
 
                      new_label + path,
240
 
                      new_tree.get_file(file_id).readlines(),
241
 
                      to_file)
242
 
 
243
 
 
244
 
 
245
 
 
246
 
 
 
170
    for file_state, fid, old_name, new_name, kind in diff_trees(old_tree, new_tree):
 
171
 
 
172
        if file_list and (new_name not in file_list):
 
173
            continue
 
174
        
 
175
        # Don't show this by default; maybe do it if an option is passed
 
176
        # idlabel = '      {%s}' % fid
 
177
        idlabel = ''
 
178
 
 
179
        def diffit(oldlines, newlines, **kw):
 
180
            
 
181
            # FIXME: difflib is wrong if there is no trailing newline.
 
182
            # The syntax used by patch seems to be "\ No newline at
 
183
            # end of file" following the last diff line from that
 
184
            # file.  This is not trivial to insert into the
 
185
            # unified_diff output and it might be better to just fix
 
186
            # or replace that function.
 
187
 
 
188
            # In the meantime we at least make sure the patch isn't
 
189
            # mangled.
 
190
            
 
191
 
 
192
            # Special workaround for Python2.3, where difflib fails if
 
193
            # both sequences are empty.
 
194
            if not oldlines and not newlines:
 
195
                return
 
196
 
 
197
            nonl = False
 
198
 
 
199
            if oldlines and (oldlines[-1][-1] != '\n'):
 
200
                oldlines[-1] += '\n'
 
201
                nonl = True
 
202
            if newlines and (newlines[-1][-1] != '\n'):
 
203
                newlines[-1] += '\n'
 
204
                nonl = True
 
205
 
 
206
            ud = difflib.unified_diff(oldlines, newlines, **kw)
 
207
 
 
208
            # work-around for difflib being too smart for its own good
 
209
            # if /dev/null is "1,0", patch won't recognize it as /dev/null
 
210
            if not oldlines:
 
211
                ud = list(ud)
 
212
                ud[2] = ud[2].replace('-1,0', '-0,0')
 
213
            elif not newlines:
 
214
                ud = list(ud)
 
215
                ud[2] = ud[2].replace('+1,0', '+0,0')
 
216
            
 
217
            sys.stdout.writelines(ud)
 
218
            if nonl:
 
219
                print "\\ No newline at end of file"
 
220
            sys.stdout.write('\n')
 
221
        
 
222
        if file_state in ['.', '?', 'I']:
 
223
            continue
 
224
        elif file_state == 'A':
 
225
            print '*** added %s %r' % (kind, new_name)
 
226
            if kind == 'file':
 
227
                diffit([],
 
228
                       new_tree.get_file(fid).readlines(),
 
229
                       fromfile=DEVNULL,
 
230
                       tofile=new_label + new_name + idlabel)
 
231
        elif file_state == 'D':
 
232
            assert isinstance(old_name, types.StringTypes)
 
233
            print '*** deleted %s %r' % (kind, old_name)
 
234
            if kind == 'file':
 
235
                diffit(old_tree.get_file(fid).readlines(), [],
 
236
                       fromfile=old_label + old_name + idlabel,
 
237
                       tofile=DEVNULL)
 
238
        elif file_state in ['M', 'R']:
 
239
            if file_state == 'M':
 
240
                assert kind == 'file'
 
241
                assert old_name == new_name
 
242
                print '*** modified %s %r' % (kind, new_name)
 
243
            elif file_state == 'R':
 
244
                print '*** renamed %s %r => %r' % (kind, old_name, new_name)
 
245
 
 
246
            if kind == 'file':
 
247
                diffit(old_tree.get_file(fid).readlines(),
 
248
                       new_tree.get_file(fid).readlines(),
 
249
                       fromfile=old_label + old_name + idlabel,
 
250
                       tofile=new_label + new_name)
 
251
        else:
 
252
            raise BzrError("can't represent state %s {%s}" % (file_state, fid))
 
253
 
 
254
 
 
255
 
 
256
class TreeDelta:
 
257
    """Describes changes from one tree to another.
 
258
 
 
259
    Contains four lists:
 
260
 
 
261
    added
 
262
        (path, id)
 
263
    removed
 
264
        (path, id)
 
265
    renamed
 
266
        (oldpath, newpath, id)
 
267
    modified
 
268
        (path, id)
 
269
 
 
270
    A path may occur in more than one list if it was e.g. deleted
 
271
    under an old id and renamed into place in a new id.
 
272
 
 
273
    Files are listed in either modified or renamed, not both.  In
 
274
    other words, renamed files may also be modified.
 
275
    """
 
276
    def __init__(self):
 
277
        self.added = []
 
278
        self.removed = []
 
279
        self.renamed = []
 
280
        self.modified = []
 
281
 
 
282
 
 
283
def compare_inventories(old_inv, new_inv):
 
284
    """Return a TreeDelta object describing changes between inventories.
 
285
 
 
286
    This only describes changes in the shape of the tree, not the
 
287
    actual texts.
 
288
 
 
289
    This is an alternative to diff_trees() and should probably
 
290
    eventually replace it.
 
291
    """
 
292
    old_ids = old_inv.id_set()
 
293
    new_ids = new_inv.id_set()
 
294
    delta = TreeDelta()
 
295
 
 
296
    delta.removed = [(old_inv.id2path(fid), fid) for fid in (old_ids - new_ids)]
 
297
    delta.removed.sort()
 
298
 
 
299
    delta.added = [(new_inv.id2path(fid), fid) for fid in (new_ids - old_ids)]
 
300
    delta.added.sort()
 
301
 
 
302
    for fid in old_ids & new_ids:
 
303
        old_ie = old_inv[fid]
 
304
        new_ie = new_inv[fid]
 
305
        old_path = old_inv.id2path(fid)
 
306
        new_path = new_inv.id2path(fid)
 
307
 
 
308
        if old_path != new_path:
 
309
            delta.renamed.append((old_path, new_path, fid))
 
310
        elif old_ie.text_sha1 != new_ie.text_sha1:
 
311
            delta.modified.append((new_path, fid))
 
312
 
 
313
    delta.modified.sort()
 
314
    delta.renamed.sort()    
 
315
 
 
316
    return delta