346
303
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))
408
305
def get_root_id(self):
409
306
"""Return the file_id for the root of this tree."""
410
307
raise NotImplementedError(self.get_root_id)
460
357
return vf.plan_lca_merge(last_revision_a, last_revision_b,
461
358
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()
480
360
def _get_file_revision(self, file_id, vf, tree_revision):
481
361
"""Ensure that file_id, tree_revision is in vf to plan the merge."""
362
def file_revision(revision_tree):
363
revision_tree.lock_read()
365
return revision_tree.inventory[file_id].revision
367
revision_tree.unlock()
369
def iter_parent_trees():
370
for revision_id in self.get_parent_ids():
372
yield self.revision_tree(revision_id)
374
yield self.repository.revision_tree(revision_id)
483
376
if getattr(self, '_repository', None) is None:
484
377
last_revision = tree_revision
485
parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
486
self._iter_parent_trees()]
378
parent_keys = [(file_id, file_revision(t)) for t in
487
380
vf.add_lines((file_id, last_revision), parent_keys,
488
381
self.get_file(file_id).readlines())
489
382
repo = self.branch.repository
490
383
base_vf = repo.texts
492
last_revision = self._file_revision(self, file_id)
385
last_revision = file_revision(self)
493
386
base_vf = self._repository.texts
494
387
if base_vf not in vf.fallback_versionedfiles:
495
388
vf.fallback_versionedfiles.append(base_vf)
1041
901
self.source._comparison_data(from_entry, path)
1042
902
kind = (from_kind, None)
1043
903
executable = (from_executable, None)
1044
changed_content = from_kind is not None
904
changed_content = True
1045
905
# the parent's path is necessarily known at this point.
1046
906
yield(file_id, (path, to_path), changed_content, versioned, parent,
1047
907
name, kind, executable)
1050
class MultiWalker(object):
1051
"""Walk multiple trees simultaneously, getting combined results."""
1053
# Note: This could be written to not assume you can do out-of-order
1054
# lookups. Instead any nodes that don't match in all trees could be
1055
# marked as 'deferred', and then returned in the final cleanup loop.
1056
# For now, I think it is "nicer" to return things as close to the
1057
# "master_tree" order as we can.
1059
def __init__(self, master_tree, other_trees):
1060
"""Create a new MultiWalker.
1062
All trees being walked must implement "iter_entries_by_dir()", such
1063
that they yield (path, object) tuples, where that object will have a
1064
'.file_id' member, that can be used to check equality.
1066
:param master_tree: All trees will be 'slaved' to the master_tree such
1067
that nodes in master_tree will be used as 'first-pass' sync points.
1068
Any nodes that aren't in master_tree will be merged in a second
1070
:param other_trees: A list of other trees to walk simultaneously.
1072
self._master_tree = master_tree
1073
self._other_trees = other_trees
1075
# Keep track of any nodes that were properly processed just out of
1076
# order, that way we don't return them at the end, we don't have to
1077
# track *all* processed file_ids, just the out-of-order ones
1078
self._out_of_order_processed = set()
1081
def _step_one(iterator):
1082
"""Step an iter_entries_by_dir iterator.
1084
:return: (has_more, path, ie)
1085
If has_more is False, path and ie will be None.
1088
path, ie = iterator.next()
1089
except StopIteration:
1090
return False, None, None
1092
return True, path, ie
1095
def _cmp_path_by_dirblock(path1, path2):
1096
"""Compare two paths based on what directory they are in.
1098
This generates a sort order, such that all children of a directory are
1099
sorted together, and grandchildren are in the same order as the
1100
children appear. But all grandchildren come after all children.
1102
:param path1: first path
1103
:param path2: the second path
1104
:return: negative number if ``path1`` comes first,
1105
0 if paths are equal
1106
and a positive number if ``path2`` sorts first
1108
# Shortcut this special case
1111
# This is stolen from _dirstate_helpers_py.py, only switching it to
1112
# Unicode objects. Consider using encode_utf8() and then using the
1113
# optimized versions, or maybe writing optimized unicode versions.
1114
if not isinstance(path1, unicode):
1115
raise TypeError("'path1' must be a unicode string, not %s: %r"
1116
% (type(path1), path1))
1117
if not isinstance(path2, unicode):
1118
raise TypeError("'path2' must be a unicode string, not %s: %r"
1119
% (type(path2), path2))
1120
return cmp(MultiWalker._path_to_key(path1),
1121
MultiWalker._path_to_key(path2))
1124
def _path_to_key(path):
1125
dirname, basename = osutils.split(path)
1126
return (dirname.split(u'/'), basename)
1128
def _lookup_by_file_id(self, extra_entries, other_tree, file_id):
1129
"""Lookup an inventory entry by file_id.
1131
This is called when an entry is missing in the normal order.
1132
Generally this is because a file was either renamed, or it was
1133
deleted/added. If the entry was found in the inventory and not in
1134
extra_entries, it will be added to self._out_of_order_processed
1136
:param extra_entries: A dictionary of {file_id: (path, ie)}. This
1137
should be filled with entries that were found before they were
1138
used. If file_id is present, it will be removed from the
1140
:param other_tree: The Tree to search, in case we didn't find the entry
1142
:param file_id: The file_id to look for
1143
:return: (path, ie) if found or (None, None) if not present.
1145
if file_id in extra_entries:
1146
return extra_entries.pop(file_id)
1147
# TODO: Is id2path better as the first call, or is
1148
# inventory[file_id] better as a first check?
1150
cur_path = other_tree.id2path(file_id)
1151
except errors.NoSuchId:
1153
if cur_path is None:
1156
self._out_of_order_processed.add(file_id)
1157
cur_ie = other_tree.inventory[file_id]
1158
return (cur_path, cur_ie)
1161
"""Match up the values in the different trees."""
1162
for result in self._walk_master_tree():
1164
self._finish_others()
1165
for result in self._walk_others():
1168
def _walk_master_tree(self):
1169
"""First pass, walk all trees in lock-step.
1171
When we are done, all nodes in the master_tree will have been
1172
processed. _other_walkers, _other_entries, and _others_extra will be
1173
set on 'self' for future processing.
1175
# This iterator has the most "inlining" done, because it tends to touch
1176
# every file in the tree, while the others only hit nodes that don't
1178
master_iterator = self._master_tree.iter_entries_by_dir()
1180
other_walkers = [other.iter_entries_by_dir()
1181
for other in self._other_trees]
1182
other_entries = [self._step_one(walker) for walker in other_walkers]
1183
# Track extra nodes in the other trees
1184
others_extra = [{} for i in xrange(len(self._other_trees))]
1186
master_has_more = True
1187
step_one = self._step_one
1188
lookup_by_file_id = self._lookup_by_file_id
1189
out_of_order_processed = self._out_of_order_processed
1191
while master_has_more:
1192
(master_has_more, path, master_ie) = step_one(master_iterator)
1193
if not master_has_more:
1196
file_id = master_ie.file_id
1198
other_values_append = other_values.append
1199
next_other_entries = []
1200
next_other_entries_append = next_other_entries.append
1201
for idx, (other_has_more, other_path, other_ie) in enumerate(other_entries):
1202
if not other_has_more:
1203
other_values_append(lookup_by_file_id(
1204
others_extra[idx], self._other_trees[idx], file_id))
1205
next_other_entries_append((False, None, None))
1206
elif file_id == other_ie.file_id:
1207
# This is the critical code path, as most of the entries
1208
# should match between most trees.
1209
other_values_append((other_path, other_ie))
1210
next_other_entries_append(step_one(other_walkers[idx]))
1212
# This walker did not match, step it until it either
1213
# matches, or we know we are past the current walker.
1214
other_walker = other_walkers[idx]
1215
other_extra = others_extra[idx]
1216
while (other_has_more and
1217
self._cmp_path_by_dirblock(other_path, path) < 0):
1218
other_file_id = other_ie.file_id
1219
if other_file_id not in out_of_order_processed:
1220
other_extra[other_file_id] = (other_path, other_ie)
1221
other_has_more, other_path, other_ie = \
1222
step_one(other_walker)
1223
if other_has_more and other_ie.file_id == file_id:
1224
# We ended up walking to this point, match and step
1226
other_values_append((other_path, other_ie))
1227
other_has_more, other_path, other_ie = \
1228
step_one(other_walker)
1230
# This record isn't in the normal order, see if it
1232
other_values_append(lookup_by_file_id(
1233
other_extra, self._other_trees[idx], file_id))
1234
next_other_entries_append((other_has_more, other_path,
1236
other_entries = next_other_entries
1238
# We've matched all the walkers, yield this datapoint
1239
yield path, file_id, master_ie, other_values
1240
self._other_walkers = other_walkers
1241
self._other_entries = other_entries
1242
self._others_extra = others_extra
1244
def _finish_others(self):
1245
"""Finish walking the other iterators, so we get all entries."""
1246
for idx, info in enumerate(self._other_entries):
1247
other_extra = self._others_extra[idx]
1248
(other_has_more, other_path, other_ie) = info
1249
while other_has_more:
1250
other_file_id = other_ie.file_id
1251
if other_file_id not in self._out_of_order_processed:
1252
other_extra[other_file_id] = (other_path, other_ie)
1253
other_has_more, other_path, other_ie = \
1254
self._step_one(self._other_walkers[idx])
1255
del self._other_entries
1257
def _walk_others(self):
1258
"""Finish up by walking all the 'deferred' nodes."""
1259
# TODO: One alternative would be to grab all possible unprocessed
1260
# file_ids, and then sort by path, and then yield them. That
1261
# might ensure better ordering, in case a caller strictly
1262
# requires parents before children.
1263
for idx, other_extra in enumerate(self._others_extra):
1264
others = sorted(other_extra.itervalues(),
1265
key=lambda x: self._path_to_key(x[0]))
1266
for other_path, other_ie in others:
1267
file_id = other_ie.file_id
1268
# We don't need to check out_of_order_processed here, because
1269
# the lookup_by_file_id will be removing anything processed
1270
# from the extras cache
1271
other_extra.pop(file_id)
1272
other_values = [(None, None) for i in xrange(idx)]
1273
other_values.append((other_path, other_ie))
1274
for alt_idx, alt_extra in enumerate(self._others_extra[idx+1:]):
1275
alt_idx = alt_idx + idx + 1
1276
alt_extra = self._others_extra[alt_idx]
1277
alt_tree = self._other_trees[alt_idx]
1278
other_values.append(self._lookup_by_file_id(
1279
alt_extra, alt_tree, file_id))
1280
yield other_path, file_id, None, other_values
added
removed
bzrlib/tree.py
