← 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 06:09:42 UTC
  • Revision ID: mbp@sourcefrog.net-20050509060942-d9c9efd7feed0894
- more indicators at top of test output
- tidy up remotebranch stuff

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/diff.py
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
        # 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