/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/delta.py

  • Committer: John Arbash Meinel
  • Date: 2006-05-27 04:48:39 UTC
  • mto: (1711.2.26 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1734.
  • Revision ID: john@arbash-meinel.com-20060527044839-83fdd64ce7d708bb
Instead of iterating randomly in both trees, _compare_trees now iterates in order on both trees simultaneously.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/delta.py
188
188
    # Perhaps should take a list of file-ids instead?   Need to indicate any
189
189
    # ids or names which were not found in the trees.
190
190
 
191
 
    for file_id in old_tree:
192
 
        if file_id in new_tree:
193
 
            old_ie = old_inv[file_id]
194
 
            new_ie = new_inv[file_id]
195
 
 
196
 
            kind = old_ie.kind
197
 
            assert kind == new_ie.kind
198
 
            
199
 
            assert kind in InventoryEntry.known_kinds, \
200
 
                   'invalid file kind %r' % kind
201
 
 
202
 
            if kind == 'root_directory':
203
 
                continue
204
 
            
205
 
            if specific_files:
206
 
                if (not is_inside_any(specific_files, old_inv.id2path(file_id)) 
207
 
                    and not is_inside_any(specific_files, new_inv.id2path(file_id))):
208
 
                    continue
209
 
 
210
 
            # temporary hack until all entries are populated before clients 
211
 
            # get them
212
 
            old_path = old_inv.id2path(file_id)
213
 
            new_path = new_inv.id2path(file_id)
214
 
            old_ie._read_tree_state(old_path, old_tree)
215
 
            new_ie._read_tree_state(new_path, new_tree)
216
 
            text_modified, meta_modified = new_ie.detect_changes(old_ie)
217
 
 
218
 
            # TODO: Can possibly avoid calculating path strings if the
219
 
            # two files are unchanged and their names and parents are
220
 
            # the same and the parents are unchanged all the way up.
221
 
            # May not be worthwhile.
222
 
            
223
 
            if (old_ie.name != new_ie.name
224
 
                or old_ie.parent_id != new_ie.parent_id):
225
 
                delta.renamed.append((old_path,
226
 
                                      new_path,
227
 
                                      file_id, kind,
228
 
                                      text_modified, meta_modified))
229
 
            elif text_modified or meta_modified:
230
 
                delta.modified.append((new_path, file_id, kind,
231
 
                                       text_modified, meta_modified))
232
 
            elif want_unchanged:
233
 
                delta.unchanged.append((new_path, file_id, kind))
234
 
        else:
235
 
            kind = old_inv.get_file_kind(file_id)
236
 
            if kind == 'root_directory':
237
 
                continue
238
 
            old_path = old_inv.id2path(file_id)
239
 
            if specific_files:
240
 
                if not is_inside_any(specific_files, old_path):
241
 
                    continue
242
 
            delta.removed.append((old_path, file_id, kind))
243
 
 
244
 
    mutter('start looking for new files')
245
 
    for file_id in new_inv:
246
 
        if file_id in old_inv or file_id not in new_tree:
247
 
            continue
248
 
        kind = new_inv.get_file_kind(file_id)
249
 
        if kind == 'root_directory':
250
 
            continue
251
 
        new_path = new_inv.id2path(file_id)
252
 
        if specific_files:
253
 
            if not is_inside_any(specific_files, new_path):
254
 
                continue
255
 
        delta.added.append((new_path, file_id, kind))
256
 
            
 
191
    old_files = old_tree.list_files()
 
192
    new_files = new_tree.list_files()
 
193
 
 
194
    more_old = True
 
195
    more_new = True
 
196
 
 
197
    added = {}
 
198
    removed = {}
 
199
 
 
200
    def get_next(iter):
 
201
        try:
 
202
            return iter.next()
 
203
        except StopIteration:
 
204
            return None, None, None, None, None
 
205
    old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
 
206
    new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
 
207
 
 
208
 
 
209
    def check_matching(old_path, old_entry, new_path, new_entry):
 
210
        """We have matched up 2 file_ids, check for changes."""
 
211
        assert old_entry.kind == new_entry.kind
 
212
 
 
213
        if old_entry.kind == 'root_directory':
 
214
            return
 
215
 
 
216
        old_entry._read_tree_state(old_path, old_tree)
 
217
        new_entry._read_tree_state(new_path, new_tree)
 
218
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
 
219
        
 
220
        # Even though the files are at the same path, the parent ids
 
221
        # changed, so apparently someone created a new path with the
 
222
        # same name as the old one, and moved files into it. 
 
223
        # Weird, but still counts as a rename
 
224
        if (old_entry.name != new_entry.name 
 
225
            or old_entry.parent_id != new_entry.parent_id):
 
226
            delta.renamed.append((old_path,
 
227
                                  new_path,
 
228
                                  old_entry.file_id, old_entry.kind,
 
229
                                  text_modified, meta_modified))
 
230
        elif text_modified or meta_modified:
 
231
            delta.modified.append((new_path, new_entry.file_id, new_entry.kind,
 
232
                                   text_modified, meta_modified))
 
233
        elif want_unchanged:
 
234
            delta.unchanged.append((new_path, new_entry.file_id, new_entry.kind))
 
235
 
 
236
 
 
237
    def handle_old(path, entry):
 
238
        """old entry without a new entry match"""
 
239
        if entry.file_id in added:
 
240
            # Actually this is a rename, we found a new file_id earlier
 
241
            # at a different location, so it is no-longer added
 
242
            x_new_path, x_new_entry = added.pop(entry.file_id)
 
243
            check_matching(path, entry, x_new_path, x_new_entry)
 
244
        else:
 
245
            # We have an old_file_id which doesn't line up with a new_file_id
 
246
            # So this file looks to be removed
 
247
            assert entry.file_id not in removed
 
248
            removed[entry.file_id] = path, entry
 
249
 
 
250
    def handle_new(path, entry):
 
251
        """new entry without an old entry match"""
 
252
        if entry.file_id in removed:
 
253
            # We saw this file_id earlier at an old different location
 
254
            # it is no longer removed, just renamed
 
255
            x_old_path, x_old_entry = removed.pop(entry.file_id)
 
256
            check_matching(x_old_path, x_old_entry, path, entry)
 
257
        else:
 
258
            # We have a new file which does not match an old file
 
259
            # mark it as added
 
260
            assert entry.file_id not in added
 
261
            added[entry.file_id] = path, entry
 
262
 
 
263
    while old_path or new_path:
 
264
        # list_files() returns files in alphabetical path sorted order
 
265
        if old_path == new_path:
 
266
            if old_file_id == new_file_id:
 
267
                # This is the common case, the files are in the same place
 
268
                # check if there were any content changes
 
269
 
 
270
                if old_file_id is None:
 
271
                    # We have 2 unversioned files, no deltas possible???
 
272
                    pass
 
273
                else:
 
274
                    check_matching(old_path, old_entry, new_path, new_entry)
 
275
            else:
 
276
                # The ids don't match, so we have to handle them both
 
277
                # separately.
 
278
                if old_file_id is not None:
 
279
                    handle_old(old_path, old_entry)
 
280
 
 
281
                if new_file_id is not None:
 
282
                    handle_new(new_path, new_entry)
 
283
 
 
284
            # The two entries were at the same path, so increment both sides
 
285
            old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
 
286
            new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
 
287
        elif new_path is None or (old_path is not None and old_path < new_path):
 
288
            # Assume we don't match, only process old_path
 
289
            if old_file_id is not None:
 
290
                handle_old(old_path, old_entry)
 
291
            # old_path came first, so increment it, trying to match up
 
292
            old_path, old_class, old_kind, old_file_id, old_entry = get_next(old_files)
 
293
        elif new_path is not None:
 
294
            # new_path came first, so increment it, trying to match up
 
295
            if new_file_id is not None:
 
296
                handle_new(new_path, new_entry)
 
297
            new_path, new_class, new_kind, new_file_id, new_entry = get_next(new_files)
 
298
 
 
299
    # Now we have a set of added and removed files, mark them all
 
300
    for old_path, old_entry in removed.itervalues():
 
301
        delta.removed.append((old_path, old_entry.file_id, old_entry.kind))
 
302
    for new_path, new_entry in added.itervalues():
 
303
        delta.added.append((new_path, new_entry.file_id, new_entry.kind))
 
304
 
257
305
    delta.removed.sort()
258
306
    delta.added.sort()
259
307
    delta.renamed.sort()