1176
def update_by_delta(self, delta):
1177
"""Apply an inventory delta to the dirstate for tree 0
1179
:param delta: An inventory delta. See Inventory.apply_delta for
1182
self._read_dirblocks_if_needed()
1185
for old_path, new_path, file_id, inv_entry in sorted(delta, reverse=True):
1186
if (file_id in insertions) or (file_id in removals):
1187
raise AssertionError("repeated file id in delta %r" % (file_id,))
1188
if old_path is not None:
1189
old_path = old_path.encode('utf-8')
1190
removals[file_id] = old_path
1191
if new_path is not None:
1192
new_path = new_path.encode('utf-8')
1193
dirname, basename = osutils.split(new_path)
1194
key = (dirname, basename, file_id)
1195
minikind = DirState._kind_to_minikind[inv_entry.kind]
1197
fingerprint = inv_entry.reference_revision
1200
insertions[file_id] = (key, minikind, inv_entry.executable,
1201
fingerprint, new_path)
1202
# Transform moves into delete+add pairs
1203
if None not in (old_path, new_path):
1204
for child in self._iter_child_entries(0, old_path):
1205
if child[0][2] in insertions or child[0][2] in removals:
1207
child_dirname = child[0][0]
1208
child_basename = child[0][1]
1209
minikind = child[1][0][0]
1210
fingerprint = child[1][0][4]
1211
executable = child[1][0][3]
1212
old_child_path = osutils.pathjoin(child[0][0],
1214
removals[child[0][2]] = old_child_path
1215
child_suffix = child_dirname[len(old_path):]
1216
new_child_dirname = (new_path + child_suffix)
1217
key = (new_child_dirname, child_basename, child[0][2])
1218
new_child_path = os.path.join(new_child_dirname,
1220
insertions[child[0][2]] = (key, minikind, executable,
1221
fingerprint, new_child_path)
1222
self._apply_removals(removals.values())
1223
self._apply_insertions(insertions.values())
1225
def _apply_removals(self, removals):
1226
for path in sorted(removals, reverse=True):
1227
dirname, basename = osutils.split(path)
1228
block_i, entry_i, d_present, f_present = \
1229
self._get_block_entry_index(dirname, basename, 0)
1230
entry = self._dirblocks[block_i][1][entry_i]
1231
self._make_absent(entry)
1232
# See if we have a malformed delta: deleting a directory must not
1233
# leave crud behind. This increases the number of bisects needed
1234
# substantially, but deletion or renames of large numbers of paths
1235
# is rare enough it shouldn't be an issue (famous last words?) RBC
1237
block_i, entry_i, d_present, f_present = \
1238
self._get_block_entry_index(path, '', 0)
1240
# The dir block is still present in the dirstate; this could
1241
# be due to it being in a parent tree, or a corrupt delta.
1242
for child_entry in self._dirblocks[block_i][1]:
1243
if child_entry[1][0][0] not in ('r', 'a'):
1244
raise errors.InconsistentDelta(path, entry[0][2],
1245
"The file id was deleted but its children were "
1248
def _apply_insertions(self, adds):
1249
for key, minikind, executable, fingerprint, path_utf8 in sorted(adds):
1250
self.update_minimal(key, minikind, executable, fingerprint,
1251
path_utf8=path_utf8)
1253
def update_basis_by_delta(self, delta, new_revid):
1254
"""Update the parents of this tree after a commit.
1256
This gives the tree one parent, with revision id new_revid. The
1257
inventory delta is applied to the current basis tree to generate the
1258
inventory for the parent new_revid, and all other parent trees are
1261
Note that an exception during the operation of this method will leave
1262
the dirstate in a corrupt state where it should not be saved.
1264
Finally, we expect all changes to be synchronising the basis tree with
1267
:param new_revid: The new revision id for the trees parent.
1268
:param delta: An inventory delta (see apply_inventory_delta) describing
1269
the changes from the current left most parent revision to new_revid.
1271
self._read_dirblocks_if_needed()
1272
self._discard_merge_parents()
1273
if self._ghosts != []:
1274
raise NotImplementedError(self.update_basis_by_delta)
1275
if len(self._parents) == 0:
1276
# setup a blank tree, the most simple way.
1277
empty_parent = DirState.NULL_PARENT_DETAILS
1278
for entry in self._iter_entries():
1279
entry[1].append(empty_parent)
1280
self._parents.append(new_revid)
1282
self._parents[0] = new_revid
1284
delta = sorted(delta, reverse=True)
1288
# The paths this function accepts are unicode and must be encoded as we
1290
encode = cache_utf8.encode
1291
inv_to_entry = self._inv_entry_to_details
1292
# delta is now (deletes, changes), (adds) in reverse lexographical
1294
# deletes in reverse lexographic order are safe to process in situ.
1295
# renames are not, as a rename from any path could go to a path
1296
# lexographically lower, so we transform renames into delete, add pairs,
1297
# expanding them recursively as needed.
1298
# At the same time, to reduce interface friction we convert the input
1299
# inventory entries to dirstate.
1300
root_only = ('', '')
1301
for old_path, new_path, file_id, inv_entry in delta:
1302
if old_path is None:
1303
adds.append((None, encode(new_path), file_id,
1304
inv_to_entry(inv_entry), True))
1305
elif new_path is None:
1306
deletes.append((encode(old_path), None, file_id, None, True))
1307
elif (old_path, new_path) != root_only:
1309
# Because renames must preserve their children we must have
1310
# processed all relocations and removes before hand. The sort
1311
# order ensures we've examined the child paths, but we also
1312
# have to execute the removals, or the split to an add/delete
1313
# pair will result in the deleted item being reinserted, or
1314
# renamed items being reinserted twice - and possibly at the
1315
# wrong place. Splitting into a delete/add pair also simplifies
1316
# the handling of entries with ('f', ...), ('r' ...) because
1317
# the target of the 'r' is old_path here, and we add that to
1318
# deletes, meaning that the add handler does not need to check
1319
# for 'r' items on every pass.
1320
self._update_basis_apply_deletes(deletes)
1322
new_path_utf8 = encode(new_path)
1323
# Split into an add/delete pair recursively.
1324
adds.append((None, new_path_utf8, file_id,
1325
inv_to_entry(inv_entry), False))
1326
# Expunge deletes that we've seen so that deleted/renamed
1327
# children of a rename directory are handled correctly.
1328
new_deletes = reversed(list(self._iter_child_entries(1,
1330
# Remove the current contents of the tree at orig_path, and
1331
# reinsert at the correct new path.
1332
for entry in new_deletes:
1334
source_path = entry[0][0] + '/' + entry[0][1]
1336
source_path = entry[0][1]
1338
target_path = new_path_utf8 + source_path[len(old_path):]
1341
raise AssertionError("cannot rename directory to"
1343
target_path = source_path[len(old_path) + 1:]
1344
adds.append((None, target_path, entry[0][2], entry[1][1], False))
1346
(source_path, target_path, entry[0][2], None, False))
1348
(encode(old_path), new_path, file_id, None, False))
1350
# changes to just the root should not require remove/insertion
1352
changes.append((encode(old_path), encode(new_path), file_id,
1353
inv_to_entry(inv_entry)))
1355
# Finish expunging deletes/first half of renames.
1356
self._update_basis_apply_deletes(deletes)
1357
# Reinstate second half of renames and new paths.
1358
self._update_basis_apply_adds(adds)
1359
# Apply in-situ changes.
1360
self._update_basis_apply_changes(changes)
1362
self._dirblock_state = DirState.IN_MEMORY_MODIFIED
1363
self._header_state = DirState.IN_MEMORY_MODIFIED
1364
self._id_index = None
1367
def _update_basis_apply_adds(self, adds):
1368
"""Apply a sequence of adds to tree 1 during update_basis_by_delta.
1370
They may be adds, or renames that have been split into add/delete
1373
:param adds: A sequence of adds. Each add is a tuple:
1374
(None, new_path_utf8, file_id, (entry_details), real_add). real_add
1375
is False when the add is the second half of a remove-and-reinsert
1376
pair created to handle renames and deletes.
1378
# Adds are accumulated partly from renames, so can be in any input
1381
# adds is now in lexographic order, which places all parents before
1382
# their children, so we can process it linearly.
1384
for old_path, new_path, file_id, new_details, real_add in adds:
1385
# the entry for this file_id must be in tree 0.
1386
entry = self._get_entry(0, file_id, new_path)
1387
if entry[0] is None or entry[0][2] != file_id:
1388
self._changes_aborted = True
1389
raise errors.InconsistentDelta(new_path, file_id,
1390
'working tree does not contain new entry')
1391
if real_add and entry[1][1][0] not in absent:
1392
self._changes_aborted = True
1393
raise errors.InconsistentDelta(new_path, file_id,
1394
'The entry was considered to be a genuinely new record,'
1395
' but there was already an old record for it.')
1396
# We don't need to update the target of an 'r' because the handling
1397
# of renames turns all 'r' situations into a delete at the original
1399
entry[1][1] = new_details
1401
def _update_basis_apply_changes(self, changes):
1402
"""Apply a sequence of changes to tree 1 during update_basis_by_delta.
1404
:param adds: A sequence of changes. Each change is a tuple:
1405
(path_utf8, path_utf8, file_id, (entry_details))
1408
for old_path, new_path, file_id, new_details in changes:
1409
# the entry for this file_id must be in tree 0.
1410
entry = self._get_entry(0, file_id, new_path)
1411
if entry[0] is None or entry[0][2] != file_id:
1412
self._changes_aborted = True
1413
raise errors.InconsistentDelta(new_path, file_id,
1414
'working tree does not contain new entry')
1415
if (entry[1][0][0] in absent or
1416
entry[1][1][0] in absent):
1417
self._changes_aborted = True
1418
raise errors.InconsistentDelta(new_path, file_id,
1419
'changed considered absent')
1420
entry[1][1] = new_details
1422
def _update_basis_apply_deletes(self, deletes):
1423
"""Apply a sequence of deletes to tree 1 during update_basis_by_delta.
1425
They may be deletes, or renames that have been split into add/delete
1428
:param deletes: A sequence of deletes. Each delete is a tuple:
1429
(old_path_utf8, new_path_utf8, file_id, None, real_delete).
1430
real_delete is True when the desired outcome is an actual deletion
1431
rather than the rename handling logic temporarily deleting a path
1432
during the replacement of a parent.
1434
null = DirState.NULL_PARENT_DETAILS
1435
for old_path, new_path, file_id, _, real_delete in deletes:
1436
if real_delete != (new_path is None):
1437
raise AssertionError("bad delete delta")
1438
# the entry for this file_id must be in tree 1.
1439
dirname, basename = osutils.split(old_path)
1440
block_index, entry_index, dir_present, file_present = \
1441
self._get_block_entry_index(dirname, basename, 1)
1442
if not file_present:
1443
self._changes_aborted = True
1444
raise errors.InconsistentDelta(old_path, file_id,
1445
'basis tree does not contain removed entry')
1446
entry = self._dirblocks[block_index][1][entry_index]
1447
if entry[0][2] != file_id:
1448
self._changes_aborted = True
1449
raise errors.InconsistentDelta(old_path, file_id,
1450
'mismatched file_id in tree 1')
1452
if entry[1][0][0] != 'a':
1453
self._changes_aborted = True
1454
raise errors.InconsistentDelta(old_path, file_id,
1455
'This was marked as a real delete, but the WT state'
1456
' claims that it still exists and is versioned.')
1457
del self._dirblocks[block_index][1][entry_index]
1459
if entry[1][0][0] == 'a':
1460
self._changes_aborted = True
1461
raise errors.InconsistentDelta(old_path, file_id,
1462
'The entry was considered a rename, but the source path'
1463
' is marked as absent.')
1464
# For whatever reason, we were asked to rename an entry
1465
# that was originally marked as deleted. This could be
1466
# because we are renaming the parent directory, and the WT
1467
# current state has the file marked as deleted.
1468
elif entry[1][0][0] == 'r':
1469
# implement the rename
1470
del self._dirblocks[block_index][1][entry_index]
1472
# it is being resurrected here, so blank it out temporarily.
1473
self._dirblocks[block_index][1][entry_index][1][1] = null
1475
1132
def update_entry(self, entry, abspath, stat_value,
1476
1133
_stat_to_minikind=_stat_to_minikind,
1477
1134
_pack_stat=pack_stat):
added
removed
bzrlib/dirstate.py
