~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/diff.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-09 06:49:00 UTC
  • Revision ID: mbp@sourcefrog.net-20050309064900-74935ffb7350b24b
import more files from baz

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
 
from errors import BzrError
 
21
 
 
22
 
 
23
 
 
24
 
22
25
 
23
26
 
24
27
def diff_trees(old_tree, new_tree):
118
121
            old_item = next(old_it)
119
122
        else:
120
123
            assert old_id == new_id
121
 
            assert old_id != None
122
124
            assert old_name == new_name
123
125
            assert old_kind == new_kind
124
126
 
139
141
            old_item = next(old_it)
140
142
 
141
143
 
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