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

  • Committer: Aaron Bentley
  • Date: 2008-08-12 03:33:29 UTC
  • mto: This revision was merged to the branch mainline in revision 3623.
  • Revision ID: aaron@aaronbentley.com-20080812033329-9t2sw9fve78ri7hy
Refactor inventory delta generation out of apply_insersions/removals

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/transform.py
1204
1204
            if len(conflicts) != 0:
1205
1205
                raise MalformedTransform(conflicts=conflicts)
1206
1206
        if precomputed_delta is None:
1207
 
            new_inventory_delta = []
1208
 
            inventory_delta = new_inventory_delta
 
1207
            inventory_delta = self._generate_inventory_delta()
1209
1208
        else:
1210
 
            new_inventory_delta = None
1211
1209
            inventory_delta = precomputed_delta
1212
1210
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1213
1211
        try:
1217
1215
                mover = _mover
1218
1216
            try:
1219
1217
                child_pb.update('Apply phase', 0, 2)
1220
 
                kind_changes = self._apply_removals(new_inventory_delta, mover)
 
1218
                self._apply_removals(mover)
1221
1219
                child_pb.update('Apply phase', 1, 2)
1222
 
                modified_paths = self._apply_insertions(new_inventory_delta,
1223
 
                                                        mover, kind_changes)
 
1220
                modified_paths = self._apply_insertions(mover)
1224
1221
            except:
1225
1222
                mover.rollback()
1226
1223
                raise
1233
1230
        self.finalize()
1234
1231
        return _TransformResults(modified_paths, self.rename_count)
1235
1232
 
1236
 
    def _apply_removals(self, inventory_delta, mover):
 
1233
    def _generate_inventory_delta(self):
 
1234
        inventory_delta = []
 
1235
        tree_paths = list(self._tree_path_ids.iteritems())
 
1236
        tree_paths.sort(reverse=True)
 
1237
        kind_changes = set()
 
1238
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1239
        try:
 
1240
            for num, data in enumerate(tree_paths):
 
1241
                path, trans_id = data
 
1242
                child_pb.update('removing file', num, len(tree_paths))
 
1243
                if trans_id in self._removed_contents:
 
1244
                    try:
 
1245
                        if (self.tree_kind(trans_id)
 
1246
                            != self.final_kind(trans_id)):
 
1247
                            kind_changes.add(trans_id)
 
1248
                    except NoSuchFile:
 
1249
                        pass
 
1250
                if (trans_id in self._removed_id):
 
1251
                    if trans_id == self._new_root:
 
1252
                        file_id = self._tree.get_root_id()
 
1253
                    else:
 
1254
                        file_id = self.tree_file_id(trans_id)
 
1255
                    # File-id isn't really being deleted, just moved
 
1256
                    if file_id in self._r_new_id:
 
1257
                        continue
 
1258
                    inventory_delta.append((path, None, file_id, None))
 
1259
        finally:
 
1260
            child_pb.finished()
 
1261
        new_paths = self.new_paths(filesystem_only=False)
 
1262
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
 
1263
                                 new_paths)
 
1264
        entries = self._tree.iter_entries_by_dir(
 
1265
            new_path_file_ids.values())
 
1266
        old_paths = dict((e.file_id, p) for p, e in entries)
 
1267
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
 
1268
        try:
 
1269
            for num, (path, trans_id) in enumerate(new_paths):
 
1270
                new_entry = None
 
1271
                if (num % 10) == 0:
 
1272
                    child_pb.update('adding file', num, len(new_paths))
 
1273
                file_id = new_path_file_ids[trans_id]
 
1274
                if file_id is not None and (trans_id in self._new_id or
 
1275
                    trans_id in self._new_name or
 
1276
                    trans_id in self._new_parent
 
1277
                    or trans_id in self._new_executability
 
1278
                    or trans_id in kind_changes):
 
1279
                    try:
 
1280
                        kind = self.final_kind(trans_id)
 
1281
                    except NoSuchFile:
 
1282
                        kind = self._tree.stored_kind(file_id)
 
1283
                    parent_trans_id = self.final_parent(trans_id)
 
1284
                    parent_file_id = new_path_file_ids.get(parent_trans_id)
 
1285
                    if parent_file_id is None:
 
1286
                        parent_file_id = self.final_file_id(
 
1287
                            parent_trans_id)
 
1288
                    if trans_id in self._new_reference_revision:
 
1289
                        new_entry = inventory.TreeReference(
 
1290
                            file_id,
 
1291
                            self._new_name[trans_id],
 
1292
                            self.final_file_id(self._new_parent[trans_id]),
 
1293
                            None, self._new_reference_revision[trans_id])
 
1294
                    else:
 
1295
                        new_entry = inventory.make_entry(kind,
 
1296
                            self.final_name(trans_id),
 
1297
                            parent_file_id, file_id)
 
1298
                    old_path = old_paths.get(new_entry.file_id)
 
1299
                    inventory_delta.append(
 
1300
                        (old_path, path, new_entry.file_id, new_entry))
 
1301
        finally:
 
1302
            child_pb.finished()
 
1303
        return inventory_delta
 
1304
 
 
1305
    def _apply_removals(self, mover):
1237
1306
        """Perform tree operations that remove directory/inventory names.
1238
1307
 
1239
1308
        That is, delete files that are to be deleted, and put any files that
1252
1321
                child_pb.update('removing file', num, len(tree_paths))
1253
1322
                full_path = self._tree.abspath(path)
1254
1323
                if trans_id in self._removed_contents:
1255
 
                    try:
1256
 
                        if (self.tree_kind(trans_id)
1257
 
                                != self.final_kind(trans_id)):
1258
 
                            kind_changes.add(trans_id)
1259
 
                    except NoSuchFile:
1260
 
                        pass
1261
1324
                    mover.pre_delete(full_path, os.path.join(self._deletiondir,
1262
1325
                                     trans_id))
1263
1326
                elif trans_id in self._new_name or trans_id in \
1269
1332
                            raise
1270
1333
                    else:
1271
1334
                        self.rename_count += 1
1272
 
                if (trans_id in self._removed_id
1273
 
                    and inventory_delta is not None):
1274
 
                    if trans_id == self._new_root:
1275
 
                        file_id = self._tree.get_root_id()
1276
 
                    else:
1277
 
                        file_id = self.tree_file_id(trans_id)
1278
 
                    # File-id isn't really being deleted, just moved
1279
 
                    if file_id in self._r_new_id:
1280
 
                        continue
1281
 
                    inventory_delta.append((path, None, file_id, None))
1282
1335
        finally:
1283
1336
            child_pb.finished()
1284
1337
        return kind_changes
1285
1338
 
1286
 
    def _apply_insertions(self, inventory_delta, mover, kind_changes):
 
1339
    def _apply_insertions(self, mover):
1287
1340
        """Perform tree operations that insert directory/inventory names.
1288
1341
 
1289
1342
        That is, create any files that need to be created, and restore from
1296
1349
        kind_changes is a set of trans ids where the entry has changed
1297
1350
        kind, and so an inventory delta entry should be created for them.
1298
1351
        """
1299
 
        new_paths = self.new_paths(filesystem_only=(inventory_delta is None))
 
1352
        new_paths = self.new_paths(filesystem_only=True)
1300
1353
        modified_paths = []
1301
 
        completed_new = []
1302
1354
        new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1303
1355
                                 new_paths)
1304
 
        if inventory_delta is not None:
1305
 
            entries = self._tree.iter_entries_by_dir(
1306
 
                new_path_file_ids.values())
1307
 
            old_paths = dict((e.file_id, p) for p, e in entries)
1308
1356
        child_pb = bzrlib.ui.ui_factory.nested_progress_bar()
1309
1357
        try:
1310
1358
            for num, (path, trans_id) in enumerate(new_paths):
1311
 
                new_entry = None
1312
1359
                if (num % 10) == 0:
1313
1360
                    child_pb.update('adding file', num, len(new_paths))
1314
1361
                full_path = self._tree.abspath(path)
1321
1368
                            raise
1322
1369
                    else:
1323
1370
                        self.rename_count += 1
1324
 
                if inventory_delta is not None:
1325
 
                    if (trans_id in self._new_contents or
1326
 
                        self.path_changed(trans_id)):
1327
 
                        if trans_id in self._new_contents:
1328
 
                            modified_paths.append(full_path)
1329
 
                            completed_new.append(trans_id)
1330
 
                    file_id = new_path_file_ids[trans_id]
1331
 
                    if file_id is not None and (trans_id in self._new_id or
1332
 
                        trans_id in self._new_name or
1333
 
                        trans_id in self._new_parent
1334
 
                        or trans_id in self._new_executability
1335
 
                        or trans_id in kind_changes):
1336
 
                        try:
1337
 
                            kind = self.final_kind(trans_id)
1338
 
                        except NoSuchFile:
1339
 
                            kind = self._tree.stored_kind(file_id)
1340
 
                        parent_trans_id = self.final_parent(trans_id)
1341
 
                        parent_file_id = new_path_file_ids.get(parent_trans_id)
1342
 
                        if parent_file_id is None:
1343
 
                            parent_file_id = self.final_file_id(
1344
 
                                parent_trans_id)
1345
 
                        if trans_id in self._new_reference_revision:
1346
 
                            new_entry = inventory.TreeReference(
1347
 
                                file_id,
1348
 
                                self._new_name[trans_id],
1349
 
                                self.final_file_id(self._new_parent[trans_id]),
1350
 
                                None, self._new_reference_revision[trans_id])
1351
 
                        else:
1352
 
                            new_entry = inventory.make_entry(kind,
1353
 
                                self.final_name(trans_id),
1354
 
                                parent_file_id, file_id)
1355
 
                        old_path = old_paths.get(new_entry.file_id)
1356
 
                        inventory_delta.append(
1357
 
                            (old_path, path, new_entry.file_id, new_entry))
1358
 
 
 
1371
                if (trans_id in self._new_contents or
 
1372
                    self.path_changed(trans_id)):
 
1373
                    if trans_id in self._new_contents:
 
1374
                        modified_paths.append(full_path)
1359
1375
                if trans_id in self._new_executability:
1360
 
                    self._set_executability(path, new_entry, trans_id)
 
1376
                    self._set_executability(path, None, trans_id)
1361
1377
        finally:
1362
1378
            child_pb.finished()
1363
 
        if inventory_delta is None:
1364
 
            self._new_contents.clear()
1365
 
        else:
1366
 
            for trans_id in completed_new:
1367
 
                del self._new_contents[trans_id]
 
1379
        self._new_contents.clear()
1368
1380
        return modified_paths
1369
1381
 
1370
1382