162
163
def adjust_path(self, name, parent, trans_id):
163
164
"""Change the path that is assigned to a transaction id."""
166
raise ValueError("Parent trans-id may not be None")
164
167
if trans_id == self._new_root:
165
168
raise CantMoveRoot
166
169
self._new_name[trans_id] = name
167
170
self._new_parent[trans_id] = parent
168
if parent == ROOT_PARENT:
169
if self._new_root is not None:
170
raise ValueError("Cannot have multiple roots.")
171
self._new_root = trans_id
173
172
def adjust_root_path(self, name, parent):
174
173
"""Emulate moving the root by moving all children, instead.
202
201
self.version_file(old_root_file_id, old_root)
203
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]
205
265
def trans_id_tree_file_id(self, inventory_id):
206
266
"""Determine the transaction id of a working tree file.
1054
1117
def _limbo_name(self, trans_id):
1055
1118
"""Generate the limbo name of a file"""
1056
1119
limbo_name = self._limbo_files.get(trans_id)
1057
if limbo_name is not None:
1059
parent = self._new_parent.get(trans_id)
1060
# if the parent directory is already in limbo (e.g. when building a
1061
# tree), choose a limbo name inside the parent, to reduce further
1063
use_direct_path = False
1064
if self._new_contents.get(parent) == 'directory':
1065
filename = self._new_name.get(trans_id)
1066
if filename is not None:
1067
if parent not in self._limbo_children:
1068
self._limbo_children[parent] = set()
1069
self._limbo_children_names[parent] = {}
1070
use_direct_path = True
1071
# the direct path can only be used if no other file has
1072
# already taken this pathname, i.e. if the name is unused, or
1073
# if it is already associated with this trans_id.
1074
elif self._case_sensitive_target:
1075
if (self._limbo_children_names[parent].get(filename)
1076
in (trans_id, None)):
1077
use_direct_path = True
1079
for l_filename, l_trans_id in\
1080
self._limbo_children_names[parent].iteritems():
1081
if l_trans_id == trans_id:
1083
if l_filename.lower() == filename.lower():
1086
use_direct_path = True
1089
limbo_name = pathjoin(self._limbo_files[parent], filename)
1090
self._limbo_children[parent].add(trans_id)
1091
self._limbo_children_names[parent][filename] = trans_id
1093
limbo_name = pathjoin(self._limbodir, trans_id)
1094
self._needs_rename.add(trans_id)
1095
self._limbo_files[trans_id] = limbo_name
1120
if limbo_name is None:
1121
limbo_name = self._generate_limbo_path(trans_id)
1122
self._limbo_files[trans_id] = limbo_name
1096
1123
return 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)
1098
1134
def adjust_path(self, name, parent, trans_id):
1099
1135
previous_parent = self._new_parent.get(trans_id)
1100
1136
previous_name = self._new_name.get(trans_id)
1102
1138
if (trans_id in self._limbo_files and
1103
1139
trans_id not in self._needs_rename):
1104
1140
self._rename_in_limbo([trans_id])
1105
self._limbo_children[previous_parent].remove(trans_id)
1106
del self._limbo_children_names[previous_parent][previous_name]
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]
1108
1146
def _rename_in_limbo(self, trans_ids):
1109
1147
"""Fix limbo names so that the right final path is produced.
1172
1211
def _read_symlink_target(self, trans_id):
1173
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))
1175
1223
def create_hardlink(self, path, trans_id):
1176
1224
"""Schedule creation of a hard link"""
1177
1225
name = self._limbo_name(trans_id)
1408
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
1410
1506
def apply(self, no_conflicts=False, precomputed_delta=None, _mover=None):
1411
1507
"""Apply all changes to the inventory and filesystem.
1532
1628
child_pb.update('removing file', num, len(tree_paths))
1533
1629
full_path = self._tree.abspath(path)
1534
1630
if trans_id in self._removed_contents:
1535
mover.pre_delete(full_path, os.path.join(self._deletiondir,
1537
elif trans_id in self._new_name or trans_id in \
1631
delete_path = os.path.join(self._deletiondir, trans_id)
1632
mover.pre_delete(full_path, delete_path)
1633
elif (trans_id in self._new_name
1634
or trans_id in self._new_parent):
1540
1636
mover.rename(full_path, self._limbo_name(trans_id))
1541
1637
except OSError, e:
1960
2056
executable = None
1961
2057
if kind == 'symlink':
1962
2058
link_or_sha1 = os.readlink(limbo_name).decode(osutils._fs_enc)
1963
if supports_executable():
1964
executable = tt._new_executability.get(trans_id, executable)
2059
executable = tt._new_executability.get(trans_id, executable)
1965
2060
return kind, size, executable, link_or_sha1
1967
2062
def iter_changes(self, from_tree, include_unchanged=False,
2280
2375
new_desired_files = desired_files
2282
2377
iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2283
unchanged = dict((f, p[1]) for (f, p, c, v, d, n, k, e)
2284
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)
2285
2384
new_desired_files = []
2287
2386
for file_id, (trans_id, tree_path) in desired_files:
2410
2509
tt.create_directory(trans_id)
2413
def create_from_tree(tt, trans_id, tree, file_id, bytes=None):
2414
"""Create new file contents according to tree contents."""
2512
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
2513
filter_tree_path=None):
2514
"""Create new file contents according to tree contents.
2516
:param filter_tree_path: the tree path to use to lookup
2517
content filters to apply to the bytes output in the working tree.
2518
This only applies if the working tree supports content filtering.
2415
2520
kind = tree.kind(file_id)
2416
2521
if kind == 'directory':
2417
2522
tt.create_directory(trans_id)
2422
2527
bytes = tree_file.readlines()
2424
2529
tree_file.close()
2531
if wt.supports_content_filtering() and filter_tree_path is not None:
2532
filters = wt._content_filter_stack(filter_tree_path)
2533
bytes = filtered_output_bytes(bytes, filters,
2534
ContentFilterContext(filter_tree_path, tree))
2425
2535
tt.create_file(bytes, trans_id)
2426
2536
elif kind == "symlink":
2427
2537
tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
2615
2725
parent_trans = ROOT_PARENT
2617
2727
parent_trans = tt.trans_id_file_id(parent[1])
2618
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)
2619
2732
if executable[0] != executable[1] and kind[1] == "file":
2620
2733
tt.set_executability(executable[1], trans_id)
2621
for (trans_id, mode_id), bytes in target_tree.iter_files_bytes(
2623
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()
2625
2752
if basis_tree is not None:
2626
2753
basis_tree.unlock()
added
removed
bzrlib/transform.py
