198
165
def adjust_path(self, name, parent, trans_id):
199
166
"""Change the path that is assigned to a transaction id."""
168
raise ValueError("Parent trans-id may not be None")
200
169
if trans_id == self._new_root:
201
170
raise CantMoveRoot
202
previous_parent = self._new_parent.get(trans_id)
203
previous_name = self._new_name.get(trans_id)
204
171
self._new_name[trans_id] = name
205
172
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
174
def adjust_root_path(self, name, parent):
235
175
"""Emulate moving the root by moving all children, instead.
237
177
We do this by undoing the association of root's transaction id with the
238
178
current tree. This allows us to create a new directory with that
239
transaction id. We unversion the root directory and version the
179
transaction id. We unversion the root directory and version the
240
180
physically new directory, and hope someone versions the tree root
263
203
self.version_file(old_root_file_id, old_root)
264
204
self.unversion_file(self._new_root)
206
def fixup_new_roots(self):
207
"""Reinterpret requests to change the root directory
209
Instead of creating a root directory, or moving an existing directory,
210
all the attributes and children of the new root are applied to the
211
existing root directory.
213
This means that the old root trans-id becomes obsolete, so it is
214
recommended only to invoke this after the root trans-id has become
217
new_roots = [k for k, v in self._new_parent.iteritems() if v is
219
if len(new_roots) < 1:
221
if len(new_roots) != 1:
222
raise ValueError('A tree cannot have two roots!')
223
if self._new_root is None:
224
self._new_root = new_roots[0]
226
old_new_root = new_roots[0]
227
# TODO: What to do if a old_new_root is present, but self._new_root is
228
# not listed as being removed? This code explicitly unversions
229
# the old root and versions it with the new file_id. Though that
230
# seems like an incomplete delta
232
# unversion the new root's directory.
233
file_id = self.final_file_id(old_new_root)
234
if old_new_root in self._new_id:
235
self.cancel_versioning(old_new_root)
237
self.unversion_file(old_new_root)
238
# if, at this stage, root still has an old file_id, zap it so we can
239
# stick a new one in.
240
if (self.tree_file_id(self._new_root) is not None and
241
self._new_root not in self._removed_id):
242
self.unversion_file(self._new_root)
243
self.version_file(file_id, self._new_root)
245
# Now move children of new root into old root directory.
246
# Ensure all children are registered with the transaction, but don't
247
# use directly-- some tree children have new parents
248
list(self.iter_tree_children(old_new_root))
249
# Move all children of new root into old root directory.
250
for child in self.by_parent().get(old_new_root, []):
251
self.adjust_path(self.final_name(child), self._new_root, child)
253
# Ensure old_new_root has no directory.
254
if old_new_root in self._new_contents:
255
self.cancel_creation(old_new_root)
257
self.delete_contents(old_new_root)
259
# prevent deletion of root directory.
260
if self._new_root in self._removed_contents:
261
self.cancel_deletion(self._new_root)
263
# destroy path info for old_new_root.
264
del self._new_parent[old_new_root]
265
del self._new_name[old_new_root]
266
267
def trans_id_tree_file_id(self, inventory_id):
267
268
"""Determine the transaction id of a working tree file.
269
270
This reflects only files that already exist, not ones that will be
270
271
added by transactions.
331
313
return ROOT_PARENT
332
314
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
316
def delete_contents(self, trans_id):
442
317
"""Schedule the contents of a path entry for deletion"""
318
# Ensure that the object exists in the WorkingTree, this will raise an
319
# exception if there is a problem
443
320
self.tree_kind(trans_id)
444
321
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
715
def _set_executability(self, path, trans_id):
914
716
"""Set the executability of versioned files """
915
717
if supports_executable():
1121
923
def get_preview_tree(self):
1122
924
"""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.
926
The tree is a snapshot, and altering the TreeTransform will invalidate
1127
929
return _PreviewTree(self)
931
def commit(self, branch, message, merge_parents=None, strict=False,
932
timestamp=None, timezone=None, committer=None, authors=None,
933
revprops=None, revision_id=None):
934
"""Commit the result of this TreeTransform to a branch.
936
:param branch: The branch to commit to.
937
:param message: The message to attach to the commit.
938
:param merge_parents: Additional parent revision-ids specified by
940
:param strict: If True, abort the commit if there are unversioned
942
:param timestamp: if not None, seconds-since-epoch for the time and
943
date. (May be a float.)
944
:param timezone: Optional timezone for timestamp, as an offset in
946
:param committer: Optional committer in email-id format.
947
(e.g. "J Random Hacker <jrandom@example.com>")
948
:param authors: Optional list of authors in email-id format.
949
:param revprops: Optional dictionary of revision properties.
950
:param revision_id: Optional revision id. (Specifying a revision-id
951
may reduce performance for some non-native formats.)
952
:return: The revision_id of the revision committed.
954
self._check_malformed()
956
unversioned = set(self._new_contents).difference(set(self._new_id))
957
for trans_id in unversioned:
958
if self.final_file_id(trans_id) is None:
959
raise errors.StrictCommitFailed()
961
revno, last_rev_id = branch.last_revision_info()
962
if last_rev_id == _mod_revision.NULL_REVISION:
963
if merge_parents is not None:
964
raise ValueError('Cannot supply merge parents for first'
968
parent_ids = [last_rev_id]
969
if merge_parents is not None:
970
parent_ids.extend(merge_parents)
971
if self._tree.get_revision_id() != last_rev_id:
972
raise ValueError('TreeTransform not based on branch basis: %s' %
973
self._tree.get_revision_id())
974
revprops = commit.Commit.update_revprops(revprops, branch, authors)
975
builder = branch.get_commit_builder(parent_ids,
980
revision_id=revision_id)
981
preview = self.get_preview_tree()
982
list(builder.record_iter_changes(preview, last_rev_id,
983
self.iter_changes()))
984
builder.finish_inventory()
985
revision_id = builder.commit(message)
986
branch.set_last_revision_info(revno + 1, revision_id)
1129
989
def _text_parent(self, trans_id):
1130
990
file_id = self.tree_file_id(trans_id)
1226
1082
self.create_symlink(content.decode('utf-8'), trans_id)
1229
class TreeTransform(TreeTransformBase):
1085
class DiskTreeTransform(TreeTransformBase):
1086
"""Tree transform storing its contents on disk."""
1088
def __init__(self, tree, limbodir, pb=None,
1089
case_sensitive=True):
1091
:param tree: The tree that will be transformed, but not necessarily
1093
:param limbodir: A directory where new files can be stored until
1094
they are installed in their proper places
1096
:param case_sensitive: If True, the target of the transform is
1097
case sensitive, not just case preserving.
1099
TreeTransformBase.__init__(self, tree, pb, case_sensitive)
1100
self._limbodir = limbodir
1101
self._deletiondir = None
1102
# A mapping of transform ids to their limbo filename
1103
self._limbo_files = {}
1104
# A mapping of transform ids to a set of the transform ids of children
1105
# that their limbo directory has
1106
self._limbo_children = {}
1107
# Map transform ids to maps of child filename to child transform id
1108
self._limbo_children_names = {}
1109
# List of transform ids that need to be renamed from limbo into place
1110
self._needs_rename = set()
1111
self._creation_mtime = None
1114
"""Release the working tree lock, if held, clean up limbo dir.
1116
This is required if apply has not been invoked, but can be invoked
1119
if self._tree is None:
1122
entries = [(self._limbo_name(t), t, k) for t, k in
1123
self._new_contents.iteritems()]
1124
entries.sort(reverse=True)
1125
for path, trans_id, kind in entries:
1128
delete_any(self._limbodir)
1130
# We don't especially care *why* the dir is immortal.
1131
raise ImmortalLimbo(self._limbodir)
1133
if self._deletiondir is not None:
1134
delete_any(self._deletiondir)
1136
raise errors.ImmortalPendingDeletion(self._deletiondir)
1138
TreeTransformBase.finalize(self)
1140
def _limbo_name(self, trans_id):
1141
"""Generate the limbo name of a file"""
1142
limbo_name = self._limbo_files.get(trans_id)
1143
if limbo_name is None:
1144
limbo_name = self._generate_limbo_path(trans_id)
1145
self._limbo_files[trans_id] = limbo_name
1148
def _generate_limbo_path(self, trans_id):
1149
"""Generate a limbo path using the trans_id as the relative path.
1151
This is suitable as a fallback, and when the transform should not be
1152
sensitive to the path encoding of the limbo directory.
1154
self._needs_rename.add(trans_id)
1155
return pathjoin(self._limbodir, trans_id)
1157
def adjust_path(self, name, parent, trans_id):
1158
previous_parent = self._new_parent.get(trans_id)
1159
previous_name = self._new_name.get(trans_id)
1160
TreeTransformBase.adjust_path(self, name, parent, trans_id)
1161
if (trans_id in self._limbo_files and
1162
trans_id not in self._needs_rename):
1163
self._rename_in_limbo([trans_id])
1164
if previous_parent != parent:
1165
self._limbo_children[previous_parent].remove(trans_id)
1166
if previous_parent != parent or previous_name != name:
1167
del self._limbo_children_names[previous_parent][previous_name]
1169
def _rename_in_limbo(self, trans_ids):
1170
"""Fix limbo names so that the right final path is produced.
1172
This means we outsmarted ourselves-- we tried to avoid renaming
1173
these files later by creating them with their final names in their
1174
final parents. But now the previous name or parent is no longer
1175
suitable, so we have to rename them.
1177
Even for trans_ids that have no new contents, we must remove their
1178
entries from _limbo_files, because they are now stale.
1180
for trans_id in trans_ids:
1181
old_path = self._limbo_files.pop(trans_id)
1182
if trans_id not in self._new_contents:
1184
new_path = self._limbo_name(trans_id)
1185
osutils.rename(old_path, new_path)
1186
for descendant in self._limbo_descendants(trans_id):
1187
desc_path = self._limbo_files[descendant]
1188
desc_path = new_path + desc_path[len(old_path):]
1189
self._limbo_files[descendant] = desc_path
1191
def _limbo_descendants(self, trans_id):
1192
"""Return the set of trans_ids whose limbo paths descend from this."""
1193
descendants = set(self._limbo_children.get(trans_id, []))
1194
for descendant in list(descendants):
1195
descendants.update(self._limbo_descendants(descendant))
1198
def create_file(self, contents, trans_id, mode_id=None):
1199
"""Schedule creation of a new file.
1203
Contents is an iterator of strings, all of which will be written
1204
to the target destination.
1206
New file takes the permissions of any existing file with that id,
1207
unless mode_id is specified.
1209
name = self._limbo_name(trans_id)
1210
f = open(name, 'wb')
1213
unique_add(self._new_contents, trans_id, 'file')
1215
# Clean up the file, it never got registered so
1216
# TreeTransform.finalize() won't clean it up.
1221
f.writelines(contents)
1224
self._set_mtime(name)
1225
self._set_mode(trans_id, mode_id, S_ISREG)
1227
def _read_file_chunks(self, trans_id):
1228
cur_file = open(self._limbo_name(trans_id), 'rb')
1230
return cur_file.readlines()
1234
def _read_symlink_target(self, trans_id):
1235
return os.readlink(self._limbo_name(trans_id))
1237
def _set_mtime(self, path):
1238
"""All files that are created get the same mtime.
1240
This time is set by the first object to be created.
1242
if self._creation_mtime is None:
1243
self._creation_mtime = time.time()
1244
os.utime(path, (self._creation_mtime, self._creation_mtime))
1246
def create_hardlink(self, path, trans_id):
1247
"""Schedule creation of a hard link"""
1248
name = self._limbo_name(trans_id)
1252
if e.errno != errno.EPERM:
1254
raise errors.HardLinkNotSupported(path)
1256
unique_add(self._new_contents, trans_id, 'file')
1258
# Clean up the file, it never got registered so
1259
# TreeTransform.finalize() won't clean it up.
1263
def create_directory(self, trans_id):
1264
"""Schedule creation of a new directory.
1266
See also new_directory.
1268
os.mkdir(self._limbo_name(trans_id))
1269
unique_add(self._new_contents, trans_id, 'directory')
1271
def create_symlink(self, target, trans_id):
1272
"""Schedule creation of a new symbolic link.
1274
target is a bytestring.
1275
See also new_symlink.
1278
os.symlink(target, self._limbo_name(trans_id))
1279
unique_add(self._new_contents, trans_id, 'symlink')
1282
path = FinalPaths(self).get_path(trans_id)
1285
raise UnableCreateSymlink(path=path)
1287
def cancel_creation(self, trans_id):
1288
"""Cancel the creation of new file contents."""
1289
del self._new_contents[trans_id]
1290
children = self._limbo_children.get(trans_id)
1291
# if this is a limbo directory with children, move them before removing
1293
if children is not None:
1294
self._rename_in_limbo(children)
1295
del self._limbo_children[trans_id]
1296
del self._limbo_children_names[trans_id]
1297
delete_any(self._limbo_name(trans_id))
1300
class TreeTransform(DiskTreeTransform):
1230
1301
"""Represent a tree transformation.
1232
1303
This object is designed to support incremental generation of the transform,
1321
TreeTransformBase.__init__(self, tree, limbodir, pb,
1392
# Cache of realpath results, to speed up canonical_path
1393
self._realpaths = {}
1394
# Cache of relpath results, to speed up canonical_path
1396
DiskTreeTransform.__init__(self, tree, limbodir, pb,
1322
1397
tree.case_sensitive)
1323
1398
self._deletiondir = deletiondir
1400
def canonical_path(self, path):
1401
"""Get the canonical tree-relative path"""
1402
# don't follow final symlinks
1403
abs = self._tree.abspath(path)
1404
if abs in self._relpaths:
1405
return self._relpaths[abs]
1406
dirname, basename = os.path.split(abs)
1407
if dirname not in self._realpaths:
1408
self._realpaths[dirname] = os.path.realpath(dirname)
1409
dirname = self._realpaths[dirname]
1410
abs = pathjoin(dirname, basename)
1411
if dirname in self._relpaths:
1412
relpath = pathjoin(self._relpaths[dirname], basename)
1413
relpath = relpath.rstrip('/\\')
1415
relpath = self._tree.relpath(abs)
1416
self._relpaths[abs] = relpath
1419
def tree_kind(self, trans_id):
1420
"""Determine the file kind in the working tree.
1422
Raises NoSuchFile if the file does not exist
1424
path = self._tree_id_paths.get(trans_id)
1426
raise NoSuchFile(None)
1428
return file_kind(self._tree.abspath(path))
1430
if e.errno != errno.ENOENT:
1433
raise NoSuchFile(path)
1435
def _set_mode(self, trans_id, mode_id, typefunc):
1436
"""Set the mode of new file contents.
1437
The mode_id is the existing file to get the mode from (often the same
1438
as trans_id). The operation is only performed if there's a mode match
1439
according to typefunc.
1444
old_path = self._tree_id_paths[mode_id]
1448
mode = os.stat(self._tree.abspath(old_path)).st_mode
1450
if e.errno in (errno.ENOENT, errno.ENOTDIR):
1451
# Either old_path doesn't exist, or the parent of the
1452
# target is not a directory (but will be one eventually)
1453
# Either way, we know it doesn't exist *right now*
1454
# See also bug #248448
1459
os.chmod(self._limbo_name(trans_id), mode)
1461
def iter_tree_children(self, parent_id):
1462
"""Iterate through the entry's tree children, if any"""
1464
path = self._tree_id_paths[parent_id]
1468
children = os.listdir(self._tree.abspath(path))
1470
if not (osutils._is_error_enotdir(e)
1471
or e.errno in (errno.ENOENT, errno.ESRCH)):
1475
for child in children:
1476
childpath = joinpath(path, child)
1477
if self._tree.is_control_filename(childpath):
1479
yield self.trans_id_tree_path(childpath)
1481
def _generate_limbo_path(self, trans_id):
1482
"""Generate a limbo path using the final path if possible.
1484
This optimizes the performance of applying the tree transform by
1485
avoiding renames. These renames can be avoided only when the parent
1486
directory is already scheduled for creation.
1488
If the final path cannot be used, falls back to using the trans_id as
1491
parent = self._new_parent.get(trans_id)
1492
# if the parent directory is already in limbo (e.g. when building a
1493
# tree), choose a limbo name inside the parent, to reduce further
1495
use_direct_path = False
1496
if self._new_contents.get(parent) == 'directory':
1497
filename = self._new_name.get(trans_id)
1498
if filename is not None:
1499
if parent not in self._limbo_children:
1500
self._limbo_children[parent] = set()
1501
self._limbo_children_names[parent] = {}
1502
use_direct_path = True
1503
# the direct path can only be used if no other file has
1504
# already taken this pathname, i.e. if the name is unused, or
1505
# if it is already associated with this trans_id.
1506
elif self._case_sensitive_target:
1507
if (self._limbo_children_names[parent].get(filename)
1508
in (trans_id, None)):
1509
use_direct_path = True
1511
for l_filename, l_trans_id in\
1512
self._limbo_children_names[parent].iteritems():
1513
if l_trans_id == trans_id:
1515
if l_filename.lower() == filename.lower():
1518
use_direct_path = True
1520
if not use_direct_path:
1521
return DiskTreeTransform._generate_limbo_path(self, trans_id)
1523
limbo_name = pathjoin(self._limbo_files[parent], filename)
1524
self._limbo_children[parent].add(trans_id)
1525
self._limbo_children_names[parent][filename] = trans_id
1325
1529
def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1326
1530
"""Apply all changes to the inventory and filesystem.
1753
1962
ordered_ids = self._list_files_by_dir()
1754
1963
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."""
1964
specific_file_ids, yield_parents=yield_parents):
1965
yield unicode(self._final_paths.get_path(trans_id)), entry
1967
def _iter_entries_for_dir(self, dir_path):
1968
"""Return path, entry for items in a directory without recursing down."""
1969
dir_file_id = self.path2id(dir_path)
1971
for file_id in self.iter_children(dir_file_id):
1972
trans_id = self._transform.trans_id_file_id(file_id)
1973
ordered_ids.append((trans_id, file_id))
1974
for entry, trans_id in self._make_inv_entries(ordered_ids):
1975
yield unicode(self._final_paths.get_path(trans_id)), entry
1977
def list_files(self, include_root=False, from_dir=None, recursive=True):
1978
"""See WorkingTree.list_files."""
1760
1979
# XXX This should behave like WorkingTree.list_files, but is really
1761
1980
# 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
1984
prefix = from_dir + '/'
1985
entries = self.iter_entries_by_dir()
1986
for path, entry in entries:
1987
if entry.name == '' and not include_root:
1990
if not path.startswith(prefix):
1992
path = path[len(prefix):]
1993
yield path, 'V', entry.kind, entry.file_id, entry
1995
if from_dir is None and include_root is True:
1996
root_entry = inventory.make_entry('directory', '',
1997
ROOT_PARENT, self.get_root_id())
1998
yield '', 'V', 'directory', root_entry.file_id, root_entry
1999
entries = self._iter_entries_for_dir(from_dir or '')
2000
for path, entry in entries:
2001
yield path, 'V', entry.kind, entry.file_id, entry
1767
2003
def kind(self, file_id):
1768
2004
trans_id = self._transform.trans_id_file_id(file_id)
2150
2402
def _create_files(tt, tree, desired_files, pb, offset, accelerator_tree,
2152
2404
total = len(desired_files) + offset
2153
2406
if accelerator_tree is None:
2154
2407
new_desired_files = desired_files
2156
2409
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]))
2410
unchanged = [(f, p[1]) for (f, p, c, v, d, n, k, e)
2411
in iter if not (c or e[0] != e[1])]
2412
if accelerator_tree.supports_content_filtering():
2413
unchanged = [(f, p) for (f, p) in unchanged
2414
if not accelerator_tree.iter_search_rules([p]).next()]
2415
unchanged = dict(unchanged)
2159
2416
new_desired_files = []
2161
for file_id, trans_id in desired_files:
2418
for file_id, (trans_id, tree_path) in desired_files:
2162
2419
accelerator_path = unchanged.get(file_id)
2163
2420
if accelerator_path is None:
2164
new_desired_files.append((file_id, trans_id))
2421
new_desired_files.append((file_id, (trans_id, tree_path)))
2166
2423
pb.update('Adding file contents', count + offset, total)
2477
2760
parent_trans = ROOT_PARENT
2479
2762
parent_trans = tt.trans_id_file_id(parent[1])
2480
tt.adjust_path(name[1], parent_trans, trans_id)
2763
if parent[0] is None and versioned[0]:
2764
tt.adjust_root_path(name[1], parent_trans)
2766
tt.adjust_path(name[1], parent_trans, trans_id)
2481
2767
if executable[0] != executable[1] and kind[1] == "file":
2482
2768
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)
2769
if working_tree.supports_content_filtering():
2770
for index, ((trans_id, mode_id), bytes) in enumerate(
2771
target_tree.iter_files_bytes(deferred_files)):
2772
file_id = deferred_files[index][0]
2773
# We're reverting a tree to the target tree so using the
2774
# target tree to find the file path seems the best choice
2775
# here IMO - Ian C 27/Oct/2009
2776
filter_tree_path = target_tree.id2path(file_id)
2777
filters = working_tree._content_filter_stack(filter_tree_path)
2778
bytes = filtered_output_bytes(bytes, filters,
2779
ContentFilterContext(filter_tree_path, working_tree))
2780
tt.create_file(bytes, trans_id, mode_id)
2782
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2784
tt.create_file(bytes, trans_id, mode_id)
2785
tt.fixup_new_roots()
2487
2787
if basis_tree is not None:
2488
2788
basis_tree.unlock()
2489
2789
return merge_modified
2492
def resolve_conflicts(tt, pb=DummyProgress(), pass_func=None):
2792
def resolve_conflicts(tt, pb=None, pass_func=None):
2493
2793
"""Make many conflict-resolution attempts, but die if they fail"""
2494
2794
if pass_func is None:
2495
2795
pass_func = conflict_pass
2496
2796
new_conflicts = set()
2797
pb = ui.ui_factory.nested_progress_bar()
2498
2799
for n in range(10):
2499
2800
pb.update('Resolution pass', n+1, 10)
added
removed
bzrlib/transform.py
