198
163
def adjust_path(self, name, parent, trans_id):
199
164
"""Change the path that is assigned to a transaction id."""
166
raise ValueError("Parent trans-id may not be None")
200
167
if trans_id == self._new_root:
201
168
raise CantMoveRoot
202
previous_parent = self._new_parent.get(trans_id)
203
previous_name = self._new_name.get(trans_id)
204
169
self._new_name[trans_id] = name
205
170
self._new_parent[trans_id] = parent
206
if parent == ROOT_PARENT:
207
if self._new_root is not None:
208
raise ValueError("Cannot have multiple roots.")
209
self._new_root = trans_id
210
if (trans_id in self._limbo_files and
211
trans_id not in self._needs_rename):
212
self._rename_in_limbo([trans_id])
213
self._limbo_children[previous_parent].remove(trans_id)
214
del self._limbo_children_names[previous_parent][previous_name]
216
def _rename_in_limbo(self, trans_ids):
217
"""Fix limbo names so that the right final path is produced.
219
This means we outsmarted ourselves-- we tried to avoid renaming
220
these files later by creating them with their final names in their
221
final parents. But now the previous name or parent is no longer
222
suitable, so we have to rename them.
224
Even for trans_ids that have no new contents, we must remove their
225
entries from _limbo_files, because they are now stale.
227
for trans_id in trans_ids:
228
old_path = self._limbo_files.pop(trans_id)
229
if trans_id not in self._new_contents:
231
new_path = self._limbo_name(trans_id)
232
os.rename(old_path, new_path)
234
172
def adjust_root_path(self, name, parent):
235
173
"""Emulate moving the root by moving all children, instead.
237
175
We do this by undoing the association of root's transaction id with the
238
176
current tree. This allows us to create a new directory with that
239
transaction id. We unversion the root directory and version the
177
transaction id. We unversion the root directory and version the
240
178
physically new directory, and hope someone versions the tree root
263
201
self.version_file(old_root_file_id, old_root)
264
202
self.unversion_file(self._new_root)
204
def fixup_new_roots(self):
205
"""Reinterpret requests to change the root directory
207
Instead of creating a root directory, or moving an existing directory,
208
all the attributes and children of the new root are applied to the
209
existing root directory.
211
This means that the old root trans-id becomes obsolete, so it is
212
recommended only to invoke this after the root trans-id has become
215
new_roots = [k for k, v in self._new_parent.iteritems() if v is
217
if len(new_roots) < 1:
219
if len(new_roots) != 1:
220
raise ValueError('A tree cannot have two roots!')
221
if self._new_root is None:
222
self._new_root = new_roots[0]
224
old_new_root = new_roots[0]
225
# TODO: What to do if a old_new_root is present, but self._new_root is
226
# not listed as being removed? This code explicitly unversions
227
# the old root and versions it with the new file_id. Though that
228
# seems like an incomplete delta
230
# unversion the new root's directory.
231
file_id = self.final_file_id(old_new_root)
232
if old_new_root in self._new_id:
233
self.cancel_versioning(old_new_root)
235
self.unversion_file(old_new_root)
236
# if, at this stage, root still has an old file_id, zap it so we can
237
# stick a new one in.
238
if (self.tree_file_id(self._new_root) is not None and
239
self._new_root not in self._removed_id):
240
self.unversion_file(self._new_root)
241
self.version_file(file_id, self._new_root)
243
# Now move children of new root into old root directory.
244
# Ensure all children are registered with the transaction, but don't
245
# use directly-- some tree children have new parents
246
list(self.iter_tree_children(old_new_root))
247
# Move all children of new root into old root directory.
248
for child in self.by_parent().get(old_new_root, []):
249
self.adjust_path(self.final_name(child), self._new_root, child)
251
# Ensure old_new_root has no directory.
252
if old_new_root in self._new_contents:
253
self.cancel_creation(old_new_root)
255
self.delete_contents(old_new_root)
257
# prevent deletion of root directory.
258
if self._new_root in self._removed_contents:
259
self.cancel_deletion(self._new_root)
261
# destroy path info for old_new_root.
262
del self._new_parent[old_new_root]
263
del self._new_name[old_new_root]
266
265
def trans_id_tree_file_id(self, inventory_id):
267
266
"""Determine the transaction id of a working tree file.
269
268
This reflects only files that already exist, not ones that will be
270
269
added by transactions.
331
311
return ROOT_PARENT
332
312
return self.trans_id_tree_path(os.path.dirname(path))
334
def create_file(self, contents, trans_id, mode_id=None):
335
"""Schedule creation of a new file.
339
Contents is an iterator of strings, all of which will be written
340
to the target destination.
342
New file takes the permissions of any existing file with that id,
343
unless mode_id is specified.
345
name = self._limbo_name(trans_id)
349
unique_add(self._new_contents, trans_id, 'file')
351
# Clean up the file, it never got registered so
352
# TreeTransform.finalize() won't clean it up.
357
f.writelines(contents)
360
self._set_mode(trans_id, mode_id, S_ISREG)
362
def _set_mode(self, trans_id, mode_id, typefunc):
363
"""Set the mode of new file contents.
364
The mode_id is the existing file to get the mode from (often the same
365
as trans_id). The operation is only performed if there's a mode match
366
according to typefunc.
371
old_path = self._tree_id_paths[mode_id]
375
mode = os.stat(self._tree.abspath(old_path)).st_mode
377
if e.errno in (errno.ENOENT, errno.ENOTDIR):
378
# Either old_path doesn't exist, or the parent of the
379
# target is not a directory (but will be one eventually)
380
# Either way, we know it doesn't exist *right now*
381
# See also bug #248448
386
os.chmod(self._limbo_name(trans_id), mode)
388
def create_hardlink(self, path, trans_id):
389
"""Schedule creation of a hard link"""
390
name = self._limbo_name(trans_id)
394
if e.errno != errno.EPERM:
396
raise errors.HardLinkNotSupported(path)
398
unique_add(self._new_contents, trans_id, 'file')
400
# Clean up the file, it never got registered so
401
# TreeTransform.finalize() won't clean it up.
405
def create_directory(self, trans_id):
406
"""Schedule creation of a new directory.
408
See also new_directory.
410
os.mkdir(self._limbo_name(trans_id))
411
unique_add(self._new_contents, trans_id, 'directory')
413
def create_symlink(self, target, trans_id):
414
"""Schedule creation of a new symbolic link.
416
target is a bytestring.
417
See also new_symlink.
420
os.symlink(target, self._limbo_name(trans_id))
421
unique_add(self._new_contents, trans_id, 'symlink')
424
path = FinalPaths(self).get_path(trans_id)
427
raise UnableCreateSymlink(path=path)
429
def cancel_creation(self, trans_id):
430
"""Cancel the creation of new file contents."""
431
del self._new_contents[trans_id]
432
children = self._limbo_children.get(trans_id)
433
# if this is a limbo directory with children, move them before removing
435
if children is not None:
436
self._rename_in_limbo(children)
437
del self._limbo_children[trans_id]
438
del self._limbo_children_names[trans_id]
439
delete_any(self._limbo_name(trans_id))
441
314
def delete_contents(self, trans_id):
442
315
"""Schedule the contents of a path entry for deletion"""
316
# Ensure that the object exists in the WorkingTree, this will raise an
317
# exception if there is a problem
443
318
self.tree_kind(trans_id)
444
319
self._removed_contents.add(trans_id)
869
def _limbo_name(self, trans_id):
870
"""Generate the limbo name of a file"""
871
limbo_name = self._limbo_files.get(trans_id)
872
if limbo_name is not None:
874
parent = self._new_parent.get(trans_id)
875
# if the parent directory is already in limbo (e.g. when building a
876
# tree), choose a limbo name inside the parent, to reduce further
878
use_direct_path = False
879
if self._new_contents.get(parent) == 'directory':
880
filename = self._new_name.get(trans_id)
881
if filename is not None:
882
if parent not in self._limbo_children:
883
self._limbo_children[parent] = set()
884
self._limbo_children_names[parent] = {}
885
use_direct_path = True
886
# the direct path can only be used if no other file has
887
# already taken this pathname, i.e. if the name is unused, or
888
# if it is already associated with this trans_id.
889
elif self._case_sensitive_target:
890
if (self._limbo_children_names[parent].get(filename)
891
in (trans_id, None)):
892
use_direct_path = True
894
for l_filename, l_trans_id in\
895
self._limbo_children_names[parent].iteritems():
896
if l_trans_id == trans_id:
898
if l_filename.lower() == filename.lower():
901
use_direct_path = True
904
limbo_name = pathjoin(self._limbo_files[parent], filename)
905
self._limbo_children[parent].add(trans_id)
906
self._limbo_children_names[parent][filename] = trans_id
908
limbo_name = pathjoin(self._limbodir, trans_id)
909
self._needs_rename.add(trans_id)
910
self._limbo_files[trans_id] = limbo_name
913
713
def _set_executability(self, path, trans_id):
914
714
"""Set the executability of versioned files """
915
715
if supports_executable():
1121
921
def get_preview_tree(self):
1122
922
"""Return a tree representing the result of the transform.
1124
This tree only supports the subset of Tree functionality required
1125
by show_diff_trees. It must only be compared to tt._tree.
924
The tree is a snapshot, and altering the TreeTransform will invalidate
1127
927
return _PreviewTree(self)
929
def commit(self, branch, message, merge_parents=None, strict=False):
930
"""Commit the result of this TreeTransform to a branch.
932
:param branch: The branch to commit to.
933
:param message: The message to attach to the commit.
934
:param merge_parents: Additional parents specified by pending merges.
935
:return: The revision_id of the revision committed.
937
self._check_malformed()
939
unversioned = set(self._new_contents).difference(set(self._new_id))
940
for trans_id in unversioned:
941
if self.final_file_id(trans_id) is None:
942
raise errors.StrictCommitFailed()
944
revno, last_rev_id = branch.last_revision_info()
945
if last_rev_id == _mod_revision.NULL_REVISION:
946
if merge_parents is not None:
947
raise ValueError('Cannot supply merge parents for first'
951
parent_ids = [last_rev_id]
952
if merge_parents is not None:
953
parent_ids.extend(merge_parents)
954
if self._tree.get_revision_id() != last_rev_id:
955
raise ValueError('TreeTransform not based on branch basis: %s' %
956
self._tree.get_revision_id())
957
builder = branch.get_commit_builder(parent_ids)
958
preview = self.get_preview_tree()
959
list(builder.record_iter_changes(preview, last_rev_id,
960
self.iter_changes()))
961
builder.finish_inventory()
962
revision_id = builder.commit(message)
963
branch.set_last_revision_info(revno + 1, revision_id)
1129
966
def _text_parent(self, trans_id):
1130
967
file_id = self.tree_file_id(trans_id)
1226
1059
self.create_symlink(content.decode('utf-8'), trans_id)
1229
class TreeTransform(TreeTransformBase):
1062
class DiskTreeTransform(TreeTransformBase):
1063
"""Tree transform storing its contents on disk."""
1065
def __init__(self, tree, limbodir, pb=DummyProgress(),
1066
case_sensitive=True):
1068
:param tree: The tree that will be transformed, but not necessarily
1070
:param limbodir: A directory where new files can be stored until
1071
they are installed in their proper places
1072
:param pb: A ProgressBar indicating how much progress is being made
1073
:param case_sensitive: If True, the target of the transform is
1074
case sensitive, not just case preserving.
1076
TreeTransformBase.__init__(self, tree, pb, case_sensitive)
1077
self._limbodir = limbodir
1078
self._deletiondir = None
1079
# A mapping of transform ids to their limbo filename
1080
self._limbo_files = {}
1081
# A mapping of transform ids to a set of the transform ids of children
1082
# that their limbo directory has
1083
self._limbo_children = {}
1084
# Map transform ids to maps of child filename to child transform id
1085
self._limbo_children_names = {}
1086
# List of transform ids that need to be renamed from limbo into place
1087
self._needs_rename = set()
1088
self._creation_mtime = None
1091
"""Release the working tree lock, if held, clean up limbo dir.
1093
This is required if apply has not been invoked, but can be invoked
1096
if self._tree is None:
1099
entries = [(self._limbo_name(t), t, k) for t, k in
1100
self._new_contents.iteritems()]
1101
entries.sort(reverse=True)
1102
for path, trans_id, kind in entries:
1105
delete_any(self._limbodir)
1107
# We don't especially care *why* the dir is immortal.
1108
raise ImmortalLimbo(self._limbodir)
1110
if self._deletiondir is not None:
1111
delete_any(self._deletiondir)
1113
raise errors.ImmortalPendingDeletion(self._deletiondir)
1115
TreeTransformBase.finalize(self)
1117
def _limbo_name(self, trans_id):
1118
"""Generate the limbo name of a file"""
1119
limbo_name = self._limbo_files.get(trans_id)
1120
if limbo_name is None:
1121
limbo_name = self._generate_limbo_path(trans_id)
1122
self._limbo_files[trans_id] = limbo_name
1125
def _generate_limbo_path(self, trans_id):
1126
"""Generate a limbo path using the trans_id as the relative path.
1128
This is suitable as a fallback, and when the transform should not be
1129
sensitive to the path encoding of the limbo directory.
1131
self._needs_rename.add(trans_id)
1132
return pathjoin(self._limbodir, trans_id)
1134
def adjust_path(self, name, parent, trans_id):
1135
previous_parent = self._new_parent.get(trans_id)
1136
previous_name = self._new_name.get(trans_id)
1137
TreeTransformBase.adjust_path(self, name, parent, trans_id)
1138
if (trans_id in self._limbo_files and
1139
trans_id not in self._needs_rename):
1140
self._rename_in_limbo([trans_id])
1141
if previous_parent != parent:
1142
self._limbo_children[previous_parent].remove(trans_id)
1143
if previous_parent != parent or previous_name != name:
1144
del self._limbo_children_names[previous_parent][previous_name]
1146
def _rename_in_limbo(self, trans_ids):
1147
"""Fix limbo names so that the right final path is produced.
1149
This means we outsmarted ourselves-- we tried to avoid renaming
1150
these files later by creating them with their final names in their
1151
final parents. But now the previous name or parent is no longer
1152
suitable, so we have to rename them.
1154
Even for trans_ids that have no new contents, we must remove their
1155
entries from _limbo_files, because they are now stale.
1157
for trans_id in trans_ids:
1158
old_path = self._limbo_files.pop(trans_id)
1159
if trans_id not in self._new_contents:
1161
new_path = self._limbo_name(trans_id)
1162
os.rename(old_path, new_path)
1163
for descendant in self._limbo_descendants(trans_id):
1164
desc_path = self._limbo_files[descendant]
1165
desc_path = new_path + desc_path[len(old_path):]
1166
self._limbo_files[descendant] = desc_path
1168
def _limbo_descendants(self, trans_id):
1169
"""Return the set of trans_ids whose limbo paths descend from this."""
1170
descendants = set(self._limbo_children.get(trans_id, []))
1171
for descendant in list(descendants):
1172
descendants.update(self._limbo_descendants(descendant))
1175
def create_file(self, contents, trans_id, mode_id=None):
1176
"""Schedule creation of a new file.
1180
Contents is an iterator of strings, all of which will be written
1181
to the target destination.
1183
New file takes the permissions of any existing file with that id,
1184
unless mode_id is specified.
1186
name = self._limbo_name(trans_id)
1187
f = open(name, 'wb')
1190
unique_add(self._new_contents, trans_id, 'file')
1192
# Clean up the file, it never got registered so
1193
# TreeTransform.finalize() won't clean it up.
1198
f.writelines(contents)
1201
self._set_mtime(name)
1202
self._set_mode(trans_id, mode_id, S_ISREG)
1204
def _read_file_chunks(self, trans_id):
1205
cur_file = open(self._limbo_name(trans_id), 'rb')
1207
return cur_file.readlines()
1211
def _read_symlink_target(self, trans_id):
1212
return os.readlink(self._limbo_name(trans_id))
1214
def _set_mtime(self, path):
1215
"""All files that are created get the same mtime.
1217
This time is set by the first object to be created.
1219
if self._creation_mtime is None:
1220
self._creation_mtime = time.time()
1221
os.utime(path, (self._creation_mtime, self._creation_mtime))
1223
def create_hardlink(self, path, trans_id):
1224
"""Schedule creation of a hard link"""
1225
name = self._limbo_name(trans_id)
1229
if e.errno != errno.EPERM:
1231
raise errors.HardLinkNotSupported(path)
1233
unique_add(self._new_contents, trans_id, 'file')
1235
# Clean up the file, it never got registered so
1236
# TreeTransform.finalize() won't clean it up.
1240
def create_directory(self, trans_id):
1241
"""Schedule creation of a new directory.
1243
See also new_directory.
1245
os.mkdir(self._limbo_name(trans_id))
1246
unique_add(self._new_contents, trans_id, 'directory')
1248
def create_symlink(self, target, trans_id):
1249
"""Schedule creation of a new symbolic link.
1251
target is a bytestring.
1252
See also new_symlink.
1255
os.symlink(target, self._limbo_name(trans_id))
1256
unique_add(self._new_contents, trans_id, 'symlink')
1259
path = FinalPaths(self).get_path(trans_id)
1262
raise UnableCreateSymlink(path=path)
1264
def cancel_creation(self, trans_id):
1265
"""Cancel the creation of new file contents."""
1266
del self._new_contents[trans_id]
1267
children = self._limbo_children.get(trans_id)
1268
# if this is a limbo directory with children, move them before removing
1270
if children is not None:
1271
self._rename_in_limbo(children)
1272
del self._limbo_children[trans_id]
1273
del self._limbo_children_names[trans_id]
1274
delete_any(self._limbo_name(trans_id))
1277
class TreeTransform(DiskTreeTransform):
1230
1278
"""Represent a tree transformation.
1232
1280
This object is designed to support incremental generation of the transform,
1321
TreeTransformBase.__init__(self, tree, limbodir, pb,
1369
# Cache of realpath results, to speed up canonical_path
1370
self._realpaths = {}
1371
# Cache of relpath results, to speed up canonical_path
1373
DiskTreeTransform.__init__(self, tree, limbodir, pb,
1322
1374
tree.case_sensitive)
1323
1375
self._deletiondir = deletiondir
1377
def canonical_path(self, path):
1378
"""Get the canonical tree-relative path"""
1379
# don't follow final symlinks
1380
abs = self._tree.abspath(path)
1381
if abs in self._relpaths:
1382
return self._relpaths[abs]
1383
dirname, basename = os.path.split(abs)
1384
if dirname not in self._realpaths:
1385
self._realpaths[dirname] = os.path.realpath(dirname)
1386
dirname = self._realpaths[dirname]
1387
abs = pathjoin(dirname, basename)
1388
if dirname in self._relpaths:
1389
relpath = pathjoin(self._relpaths[dirname], basename)
1390
relpath = relpath.rstrip('/\\')
1392
relpath = self._tree.relpath(abs)
1393
self._relpaths[abs] = relpath
1396
def tree_kind(self, trans_id):
1397
"""Determine the file kind in the working tree.
1399
Raises NoSuchFile if the file does not exist
1401
path = self._tree_id_paths.get(trans_id)
1403
raise NoSuchFile(None)
1405
return file_kind(self._tree.abspath(path))
1407
if e.errno != errno.ENOENT:
1410
raise NoSuchFile(path)
1412
def _set_mode(self, trans_id, mode_id, typefunc):
1413
"""Set the mode of new file contents.
1414
The mode_id is the existing file to get the mode from (often the same
1415
as trans_id). The operation is only performed if there's a mode match
1416
according to typefunc.
1421
old_path = self._tree_id_paths[mode_id]
1425
mode = os.stat(self._tree.abspath(old_path)).st_mode
1427
if e.errno in (errno.ENOENT, errno.ENOTDIR):
1428
# Either old_path doesn't exist, or the parent of the
1429
# target is not a directory (but will be one eventually)
1430
# Either way, we know it doesn't exist *right now*
1431
# See also bug #248448
1436
os.chmod(self._limbo_name(trans_id), mode)
1438
def iter_tree_children(self, parent_id):
1439
"""Iterate through the entry's tree children, if any"""
1441
path = self._tree_id_paths[parent_id]
1445
children = os.listdir(self._tree.abspath(path))
1447
if not (osutils._is_error_enotdir(e)
1448
or e.errno in (errno.ENOENT, errno.ESRCH)):
1452
for child in children:
1453
childpath = joinpath(path, child)
1454
if self._tree.is_control_filename(childpath):
1456
yield self.trans_id_tree_path(childpath)
1458
def _generate_limbo_path(self, trans_id):
1459
"""Generate a limbo path using the final path if possible.
1461
This optimizes the performance of applying the tree transform by
1462
avoiding renames. These renames can be avoided only when the parent
1463
directory is already scheduled for creation.
1465
If the final path cannot be used, falls back to using the trans_id as
1468
parent = self._new_parent.get(trans_id)
1469
# if the parent directory is already in limbo (e.g. when building a
1470
# tree), choose a limbo name inside the parent, to reduce further
1472
use_direct_path = False
1473
if self._new_contents.get(parent) == 'directory':
1474
filename = self._new_name.get(trans_id)
1475
if filename is not None:
1476
if parent not in self._limbo_children:
1477
self._limbo_children[parent] = set()
1478
self._limbo_children_names[parent] = {}
1479
use_direct_path = True
1480
# the direct path can only be used if no other file has
1481
# already taken this pathname, i.e. if the name is unused, or
1482
# if it is already associated with this trans_id.
1483
elif self._case_sensitive_target:
1484
if (self._limbo_children_names[parent].get(filename)
1485
in (trans_id, None)):
1486
use_direct_path = True
1488
for l_filename, l_trans_id in\
1489
self._limbo_children_names[parent].iteritems():
1490
if l_trans_id == trans_id:
1492
if l_filename.lower() == filename.lower():
1495
use_direct_path = True
1497
if not use_direct_path:
1498
return DiskTreeTransform._generate_limbo_path(self, trans_id)
1500
limbo_name = pathjoin(self._limbo_files[parent], filename)
1501
self._limbo_children[parent].add(trans_id)
1502
self._limbo_children_names[parent][filename] = trans_id
1325
1506
def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1326
1507
"""Apply all changes to the inventory and filesystem.
1753
1936
ordered_ids = self._list_files_by_dir()
1754
1937
for entry, trans_id in self._make_inv_entries(ordered_ids,
1756
yield unicode(self._final_paths.get_path(trans_id)), entry
1758
def list_files(self, include_root=False):
1759
"""See Tree.list_files."""
1938
specific_file_ids, yield_parents=yield_parents):
1939
yield unicode(self._final_paths.get_path(trans_id)), entry
1941
def _iter_entries_for_dir(self, dir_path):
1942
"""Return path, entry for items in a directory without recursing down."""
1943
dir_file_id = self.path2id(dir_path)
1945
for file_id in self.iter_children(dir_file_id):
1946
trans_id = self._transform.trans_id_file_id(file_id)
1947
ordered_ids.append((trans_id, file_id))
1948
for entry, trans_id in self._make_inv_entries(ordered_ids):
1949
yield unicode(self._final_paths.get_path(trans_id)), entry
1951
def list_files(self, include_root=False, from_dir=None, recursive=True):
1952
"""See WorkingTree.list_files."""
1760
1953
# XXX This should behave like WorkingTree.list_files, but is really
1761
1954
# more like RevisionTree.list_files.
1762
for path, entry in self.iter_entries_by_dir():
1763
if entry.name == '' and not include_root:
1765
yield path, 'V', entry.kind, entry.file_id, entry
1958
prefix = from_dir + '/'
1959
entries = self.iter_entries_by_dir()
1960
for path, entry in entries:
1961
if entry.name == '' and not include_root:
1964
if not path.startswith(prefix):
1966
path = path[len(prefix):]
1967
yield path, 'V', entry.kind, entry.file_id, entry
1969
if from_dir is None and include_root is True:
1970
root_entry = inventory.make_entry('directory', '',
1971
ROOT_PARENT, self.get_root_id())
1972
yield '', 'V', 'directory', root_entry.file_id, root_entry
1973
entries = self._iter_entries_for_dir(from_dir or '')
1974
for path, entry in entries:
1975
yield path, 'V', entry.kind, entry.file_id, entry
1767
1977
def kind(self, file_id):
1768
1978
trans_id = self._transform.trans_id_file_id(file_id)
2150
2370
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
2152
2372
total = len(desired_files) + offset
2153
2374
if accelerator_tree is None:
2154
2375
new_desired_files = desired_files
2156
2377
iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2157
unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
2158
in iter if not (c or e[0] != e[1]))
2378
unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
2379
in iter if not (c or e[0] != e[1])]
2380
if accelerator_tree.supports_content_filtering():
2381
unchanged = [(f, p) for (f, p) in unchanged
2382
if not accelerator_tree.iter_search_rules([p]).next()]
2383
unchanged = dict(unchanged)
2159
2384
new_desired_files = []
2161
for file_id, trans_id in desired_files:
2386
for file_id, (trans_id, tree_path) in desired_files:
2162
2387
accelerator_path = unchanged.get(file_id)
2163
2388
if accelerator_path is None:
2164
new_desired_files.append((file_id, trans_id))
2389
new_desired_files.append((file_id, (trans_id, tree_path)))
2166
2391
pb.update('Adding file contents', count + offset, total)
2477
2725
parent_trans = ROOT_PARENT
2479
2727
parent_trans = tt.trans_id_file_id(parent[1])
2480
tt.adjust_path(name[1], parent_trans, trans_id)
2728
if parent[0] is None and versioned[0]:
2729
tt.adjust_root_path(name[1], parent_trans)
2731
tt.adjust_path(name[1], parent_trans, trans_id)
2481
2732
if executable[0] != executable[1] and kind[1] == "file":
2482
2733
tt.set_executability(executable[1], trans_id)
2483
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2485
tt.create_file(bytes, trans_id, mode_id)
2734
if working_tree.supports_content_filtering():
2735
for index, ((trans_id, mode_id), bytes) in enumerate(
2736
target_tree.iter_files_bytes(deferred_files)):
2737
file_id = deferred_files[index][0]
2738
# We're reverting a tree to the target tree so using the
2739
# target tree to find the file path seems the best choice
2740
# here IMO - Ian C 27/Oct/2009
2741
filter_tree_path = target_tree.id2path(file_id)
2742
filters = working_tree._content_filter_stack(filter_tree_path)
2743
bytes = filtered_output_bytes(bytes, filters,
2744
ContentFilterContext(filter_tree_path, working_tree))
2745
tt.create_file(bytes, trans_id, mode_id)
2747
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2749
tt.create_file(bytes, trans_id, mode_id)
2750
tt.fixup_new_roots()
2487
2752
if basis_tree is not None:
2488
2753
basis_tree.unlock()
added
removed
bzrlib/transform.py
