~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: Martin Pool
  • Date: 2005-05-10 08:15:58 UTC
  • Revision ID: mbp@sourcefrog.net-20050510081558-9a38e2c46ba4ebc4
- Patch from Fredrik Lundh to check Python version and 
  try to find a better one if it's too old.

  Patched to try to prevent infinite loops in wierd configurations,
  and to log to stderr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
18
18
from sets import Set
19
19
 
20
20
from trace import mutter
21
 
 
22
 
 
23
 
 
24
 
 
 
21
from errors import BzrError
25
22
 
26
23
 
27
24
def diff_trees(old_tree, new_tree):
142
139
            old_item = next(old_it)
143
140
 
144
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))
 
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 = ''
 
156
 
 
157
    DEVNULL = '/dev/null'
 
158
    # Windows users, don't panic about this filename -- it is a
 
159
    # special signal to GNU patch that the file should be created or
 
160
    # deleted respectively.
 
161
 
 
162
    # TODO: Generation of pseudo-diffs for added/deleted files could
 
163
    # be usefully made into a much faster special case.
 
164
 
 
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
        def diffit(oldlines, newlines, **kw):
 
183
            
 
184
            # FIXME: difflib is wrong if there is no trailing newline.
 
185
            # The syntax used by patch seems to be "\ No newline at
 
186
            # end of file" following the last diff line from that
 
187
            # file.  This is not trivial to insert into the
 
188
            # unified_diff output and it might be better to just fix
 
189
            # or replace that function.
 
190
 
 
191
            # In the meantime we at least make sure the patch isn't
 
192
            # mangled.
 
193
            
 
194
 
 
195
            # Special workaround for Python2.3, where difflib fails if
 
196
            # both sequences are empty.
 
197
            if not oldlines and not newlines:
 
198
                return
 
199
 
 
200
            nonl = False
 
201
 
 
202
            if oldlines and (oldlines[-1][-1] != '\n'):
 
203
                oldlines[-1] += '\n'
 
204
                nonl = True
 
205
            if newlines and (newlines[-1][-1] != '\n'):
 
206
                newlines[-1] += '\n'
 
207
                nonl = True
 
208
 
 
209
            ud = difflib.unified_diff(oldlines, newlines, **kw)
 
210
 
 
211
            # work-around for difflib being too smart for its own good
 
212
            # if /dev/null is "1,0", patch won't recognize it as /dev/null
 
213
            if not oldlines:
 
214
                ud = list(ud)
 
215
                ud[2] = ud[2].replace('-1,0', '-0,0')
 
216
            elif not newlines:
 
217
                ud = list(ud)
 
218
                ud[2] = ud[2].replace('+1,0', '+0,0')
 
219
            
 
220
            sys.stdout.writelines(ud)
 
221
            if nonl:
 
222
                print "\\ No newline at end of file"
 
223
            sys.stdout.write('\n')
 
224
        
 
225
        if file_state in ['.', '?', 'I']:
 
226
            continue
 
227
        elif file_state == 'A':
 
228
            print '*** added %s %r' % (kind, new_name)
 
229
            if kind == 'file':
 
230
                diffit([],
 
231
                       new_tree.get_file(fid).readlines(),
 
232
                       fromfile=DEVNULL,
 
233
                       tofile=new_label + new_name + idlabel)
 
234
        elif file_state == 'D':
 
235
            assert isinstance(old_name, types.StringTypes)
 
236
            print '*** deleted %s %r' % (kind, old_name)
 
237
            if kind == 'file':
 
238
                diffit(old_tree.get_file(fid).readlines(), [],
 
239
                       fromfile=old_label + old_name + idlabel,
 
240
                       tofile=DEVNULL)
 
241
        elif file_state in ['M', 'R']:
 
242
            if file_state == 'M':
 
243
                assert kind == 'file'
 
244
                assert old_name == new_name
 
245
                print '*** modified %s %r' % (kind, new_name)
 
246
            elif file_state == 'R':
 
247
                print '*** renamed %s %r => %r' % (kind, old_name, new_name)
 
248
 
 
249
            if kind == 'file':
 
250
                diffit(old_tree.get_file(fid).readlines(),
 
251
                       new_tree.get_file(fid).readlines(),
 
252
                       fromfile=old_label + old_name + idlabel,
 
253
                       tofile=new_label + new_name)
 
254
        else:
 
255
            raise BzrError("can't represent state %s {%s}" % (file_state, fid))
 
256
 
 
257
 
 
258
 
 
259
class TreeDelta:
 
260
    """Describes changes from one tree to another.
 
261
 
 
262
    Contains four lists:
 
263
 
 
264
    added
 
265
        (path, id)
 
266
    removed
 
267
        (path, id)
 
268
    renamed
 
269
        (oldpath, newpath, id)
 
270
    modified
 
271
        (path, id)
 
272
 
 
273
    A path may occur in more than one list if it was e.g. deleted
 
274
    under an old id and renamed into place in a new id.
 
275
 
 
276
    Files are listed in either modified or renamed, not both.  In
 
277
    other words, renamed files may also be modified.
 
278
    """
 
279
    def __init__(self):
 
280
        self.added = []
 
281
        self.removed = []
 
282
        self.renamed = []
 
283
        self.modified = []
 
284
 
 
285
 
 
286
def compare_inventories(old_inv, new_inv):
 
287
    """Return a TreeDelta object describing changes between inventories.
 
288
 
 
289
    This only describes changes in the shape of the tree, not the
 
290
    actual texts.
 
291
 
 
292
    This is an alternative to diff_trees() and should probably
 
293
    eventually replace it.
 
294
    """
 
295
    old_ids = old_inv.id_set()
 
296
    new_ids = new_inv.id_set()
 
297
    delta = TreeDelta()
 
298
 
 
299
    delta.removed = [(old_inv.id2path(fid), fid) for fid in (old_ids - new_ids)]
 
300
    delta.removed.sort()
 
301
 
 
302
    delta.added = [(new_inv.id2path(fid), fid) for fid in (new_ids - old_ids)]
 
303
    delta.added.sort()
 
304
 
 
305
    for fid in old_ids & new_ids:
 
306
        old_ie = old_inv[fid]
 
307
        new_ie = new_inv[fid]
 
308
        old_path = old_inv.id2path(fid)
 
309
        new_path = new_inv.id2path(fid)
 
310
 
 
311
        if old_path != new_path:
 
312
            delta.renamed.append((old_path, new_path, fid))
 
313
        elif old_ie.text_sha1 != new_ie.text_sha1:
 
314
            delta.modified.append((new_path, fid))
 
315
 
 
316
    delta.modified.sort()
 
317
    delta.renamed.sort()    
 
318
 
 
319
    return delta