303
346
raise NotImplementedError(self.get_symlink_target)
348
def get_canonical_inventory_paths(self, paths):
349
"""Like get_canonical_inventory_path() but works on multiple items.
351
:param paths: A sequence of paths relative to the root of the tree.
352
:return: A list of paths, with each item the corresponding input path
353
adjusted to account for existing elements that match case
356
return list(self._yield_canonical_inventory_paths(paths))
358
def get_canonical_inventory_path(self, path):
359
"""Returns the first inventory item that case-insensitively matches path.
361
If a path matches exactly, it is returned. If no path matches exactly
362
but more than one path matches case-insensitively, it is implementation
363
defined which is returned.
365
If no path matches case-insensitively, the input path is returned, but
366
with as many path entries that do exist changed to their canonical
369
If you need to resolve many names from the same tree, you should
370
use get_canonical_inventory_paths() to avoid O(N) behaviour.
372
:param path: A paths relative to the root of the tree.
373
:return: The input path adjusted to account for existing elements
374
that match case insensitively.
376
return self._yield_canonical_inventory_paths([path]).next()
378
def _yield_canonical_inventory_paths(self, paths):
380
# First, if the path as specified exists exactly, just use it.
381
if self.path2id(path) is not None:
385
cur_id = self.get_root_id()
387
bit_iter = iter(path.split("/"))
390
for child in self.iter_children(cur_id):
392
child_base = os.path.basename(self.id2path(child))
393
if child_base.lower() == lelt:
395
cur_path = osutils.pathjoin(cur_path, child_base)
398
# before a change is committed we can see this error...
401
# got to the end of this directory and no entries matched.
402
# Return what matched so far, plus the rest as specified.
403
cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
305
408
def get_root_id(self):
306
409
"""Return the file_id for the root of this tree."""
307
410
raise NotImplementedError(self.get_root_id)
357
460
return vf.plan_lca_merge(last_revision_a, last_revision_b,
358
461
last_revision_base)
463
def _iter_parent_trees(self):
464
"""Iterate through parent trees, defaulting to Tree.revision_tree."""
465
for revision_id in self.get_parent_ids():
467
yield self.revision_tree(revision_id)
468
except errors.NoSuchRevisionInTree:
469
yield self.repository.revision_tree(revision_id)
472
def _file_revision(revision_tree, file_id):
473
"""Determine the revision associated with a file in a given tree."""
474
revision_tree.lock_read()
476
return revision_tree.inventory[file_id].revision
478
revision_tree.unlock()
360
480
def _get_file_revision(self, file_id, vf, tree_revision):
361
def file_revision(revision_tree):
362
revision_tree.lock_read()
364
return revision_tree.inventory[file_id].revision
366
revision_tree.unlock()
368
def iter_parent_trees():
369
for revision_id in self.get_parent_ids():
371
yield self.revision_tree(revision_id)
373
yield self.repository.revision_tree(revision_id)
375
if getattr(self, '_get_weave', None) is None:
481
"""Ensure that file_id, tree_revision is in vf to plan the merge."""
483
if getattr(self, '_repository', None) is None:
376
484
last_revision = tree_revision
377
parent_revisions = [file_revision(t) for t in iter_parent_trees()]
378
vf.add_lines(last_revision, parent_revisions,
485
parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
486
self._iter_parent_trees()]
487
vf.add_lines((file_id, last_revision), parent_keys,
379
488
self.get_file(file_id).readlines())
380
489
repo = self.branch.repository
381
transaction = repo.get_transaction()
382
base_vf = repo.weave_store.get_weave(file_id, transaction)
384
last_revision = file_revision(self)
385
base_vf = self._get_weave(file_id)
386
vf.fallback_versionedfiles.append(base_vf)
492
last_revision = self._file_revision(self, file_id)
493
base_vf = self._repository.texts
494
if base_vf not in vf.fallback_versionedfiles:
495
vf.fallback_versionedfiles.append(base_vf)
387
496
return last_revision
389
498
inventory = property(_get_inventory,
898
1011
self.source._comparison_data(from_entry, path)
899
1012
kind = (from_kind, None)
900
1013
executable = (from_executable, None)
901
changed_content = True
1014
changed_content = from_kind is not None
902
1015
# the parent's path is necessarily known at this point.
903
1016
yield(file_id, (path, to_path), changed_content, versioned, parent,
904
1017
name, kind, executable)
1020
class MultiWalker(object):
1021
"""Walk multiple trees simultaneously, getting combined results."""
1023
# Note: This could be written to not assume you can do out-of-order
1024
# lookups. Instead any nodes that don't match in all trees could be
1025
# marked as 'deferred', and then returned in the final cleanup loop.
1026
# For now, I think it is "nicer" to return things as close to the
1027
# "master_tree" order as we can.
1029
def __init__(self, master_tree, other_trees):
1030
"""Create a new MultiWalker.
1032
All trees being walked must implement "iter_entries_by_dir()", such
1033
that they yield (path, object) tuples, where that object will have a
1034
'.file_id' member, that can be used to check equality.
1036
:param master_tree: All trees will be 'slaved' to the master_tree such
1037
that nodes in master_tree will be used as 'first-pass' sync points.
1038
Any nodes that aren't in master_tree will be merged in a second
1040
:param other_trees: A list of other trees to walk simultaneously.
1042
self._master_tree = master_tree
1043
self._other_trees = other_trees
1045
# Keep track of any nodes that were properly processed just out of
1046
# order, that way we don't return them at the end, we don't have to
1047
# track *all* processed file_ids, just the out-of-order ones
1048
self._out_of_order_processed = set()
1051
def _step_one(iterator):
1052
"""Step an iter_entries_by_dir iterator.
1054
:return: (has_more, path, ie)
1055
If has_more is False, path and ie will be None.
1058
path, ie = iterator.next()
1059
except StopIteration:
1060
return False, None, None
1062
return True, path, ie
1065
def _cmp_path_by_dirblock(path1, path2):
1066
"""Compare two paths based on what directory they are in.
1068
This generates a sort order, such that all children of a directory are
1069
sorted together, and grandchildren are in the same order as the
1070
children appear. But all grandchildren come after all children.
1072
:param path1: first path
1073
:param path2: the second path
1074
:return: negative number if ``path1`` comes first,
1075
0 if paths are equal
1076
and a positive number if ``path2`` sorts first
1078
# Shortcut this special case
1081
# This is stolen from _dirstate_helpers_py.py, only switching it to
1082
# Unicode objects. Consider using encode_utf8() and then using the
1083
# optimized versions, or maybe writing optimized unicode versions.
1084
if not isinstance(path1, unicode):
1085
raise TypeError("'path1' must be a unicode string, not %s: %r"
1086
% (type(path1), path1))
1087
if not isinstance(path2, unicode):
1088
raise TypeError("'path2' must be a unicode string, not %s: %r"
1089
% (type(path2), path2))
1090
return cmp(MultiWalker._path_to_key(path1),
1091
MultiWalker._path_to_key(path2))
1094
def _path_to_key(path):
1095
dirname, basename = osutils.split(path)
1096
return (dirname.split(u'/'), basename)
1098
def _lookup_by_file_id(self, extra_entries, other_tree, file_id):
1099
"""Lookup an inventory entry by file_id.
1101
This is called when an entry is missing in the normal order.
1102
Generally this is because a file was either renamed, or it was
1103
deleted/added. If the entry was found in the inventory and not in
1104
extra_entries, it will be added to self._out_of_order_processed
1106
:param extra_entries: A dictionary of {file_id: (path, ie)}. This
1107
should be filled with entries that were found before they were
1108
used. If file_id is present, it will be removed from the
1110
:param other_tree: The Tree to search, in case we didn't find the entry
1112
:param file_id: The file_id to look for
1113
:return: (path, ie) if found or (None, None) if not present.
1115
if file_id in extra_entries:
1116
return extra_entries.pop(file_id)
1117
# TODO: Is id2path better as the first call, or is
1118
# inventory[file_id] better as a first check?
1120
cur_path = other_tree.id2path(file_id)
1121
except errors.NoSuchId:
1123
if cur_path is None:
1126
self._out_of_order_processed.add(file_id)
1127
cur_ie = other_tree.inventory[file_id]
1128
return (cur_path, cur_ie)
1131
"""Match up the values in the different trees."""
1132
for result in self._walk_master_tree():
1134
self._finish_others()
1135
for result in self._walk_others():
1138
def _walk_master_tree(self):
1139
"""First pass, walk all trees in lock-step.
1141
When we are done, all nodes in the master_tree will have been
1142
processed. _other_walkers, _other_entries, and _others_extra will be
1143
set on 'self' for future processing.
1145
# This iterator has the most "inlining" done, because it tends to touch
1146
# every file in the tree, while the others only hit nodes that don't
1148
master_iterator = self._master_tree.iter_entries_by_dir()
1150
other_walkers = [other.iter_entries_by_dir()
1151
for other in self._other_trees]
1152
other_entries = [self._step_one(walker) for walker in other_walkers]
1153
# Track extra nodes in the other trees
1154
others_extra = [{} for i in xrange(len(self._other_trees))]
1156
master_has_more = True
1157
step_one = self._step_one
1158
lookup_by_file_id = self._lookup_by_file_id
1159
out_of_order_processed = self._out_of_order_processed
1161
while master_has_more:
1162
(master_has_more, path, master_ie) = step_one(master_iterator)
1163
if not master_has_more:
1166
file_id = master_ie.file_id
1168
other_values_append = other_values.append
1169
next_other_entries = []
1170
next_other_entries_append = next_other_entries.append
1171
for idx, (other_has_more, other_path, other_ie) in enumerate(other_entries):
1172
if not other_has_more:
1173
other_values_append(lookup_by_file_id(
1174
others_extra[idx], self._other_trees[idx], file_id))
1175
next_other_entries_append((False, None, None))
1176
elif file_id == other_ie.file_id:
1177
# This is the critical code path, as most of the entries
1178
# should match between most trees.
1179
other_values_append((other_path, other_ie))
1180
next_other_entries_append(step_one(other_walkers[idx]))
1182
# This walker did not match, step it until it either
1183
# matches, or we know we are past the current walker.
1184
other_walker = other_walkers[idx]
1185
other_extra = others_extra[idx]
1186
while (other_has_more and
1187
self._cmp_path_by_dirblock(other_path, path) < 0):
1188
other_file_id = other_ie.file_id
1189
if other_file_id not in out_of_order_processed:
1190
other_extra[other_file_id] = (other_path, other_ie)
1191
other_has_more, other_path, other_ie = \
1192
step_one(other_walker)
1193
if other_has_more and other_ie.file_id == file_id:
1194
# We ended up walking to this point, match and step
1196
other_values_append((other_path, other_ie))
1197
other_has_more, other_path, other_ie = \
1198
step_one(other_walker)
1200
# This record isn't in the normal order, see if it
1202
other_values_append(lookup_by_file_id(
1203
other_extra, self._other_trees[idx], file_id))
1204
next_other_entries_append((other_has_more, other_path,
1206
other_entries = next_other_entries
1208
# We've matched all the walkers, yield this datapoint
1209
yield path, file_id, master_ie, other_values
1210
self._other_walkers = other_walkers
1211
self._other_entries = other_entries
1212
self._others_extra = others_extra
1214
def _finish_others(self):
1215
"""Finish walking the other iterators, so we get all entries."""
1216
for idx, info in enumerate(self._other_entries):
1217
other_extra = self._others_extra[idx]
1218
(other_has_more, other_path, other_ie) = info
1219
while other_has_more:
1220
other_file_id = other_ie.file_id
1221
if other_file_id not in self._out_of_order_processed:
1222
other_extra[other_file_id] = (other_path, other_ie)
1223
other_has_more, other_path, other_ie = \
1224
self._step_one(self._other_walkers[idx])
1225
del self._other_entries
1227
def _walk_others(self):
1228
"""Finish up by walking all the 'deferred' nodes."""
1229
# TODO: One alternative would be to grab all possible unprocessed
1230
# file_ids, and then sort by path, and then yield them. That
1231
# might ensure better ordering, in case a caller strictly
1232
# requires parents before children.
1233
for idx, other_extra in enumerate(self._others_extra):
1234
others = sorted(other_extra.itervalues(),
1235
key=lambda x: self._path_to_key(x[0]))
1236
for other_path, other_ie in others:
1237
file_id = other_ie.file_id
1238
# We don't need to check out_of_order_processed here, because
1239
# the lookup_by_file_id will be removing anything processed
1240
# from the extras cache
1241
other_extra.pop(file_id)
1242
other_values = [(None, None) for i in xrange(idx)]
1243
other_values.append((other_path, other_ie))
1244
for alt_idx, alt_extra in enumerate(self._others_extra[idx+1:]):
1245
alt_idx = alt_idx + idx + 1
1246
alt_extra = self._others_extra[alt_idx]
1247
alt_tree = self._other_trees[alt_idx]
1248
other_values.append(self._lookup_by_file_id(
1249
alt_extra, alt_tree, file_id))
1250
yield other_path, file_id, None, other_values
added
removed
bzrlib/tree.py
