177
198
The yield order (ignoring root) would be::
179
199
a, f, a/b, a/d, a/b/c, a/d/e, f/g
181
:param yield_parents: If True, yield the parents from the root leading
182
down to specific_file_ids that have been requested. This has no
183
impact if specific_file_ids is None.
185
raise NotImplementedError(self.iter_entries_by_dir)
187
def list_files(self, include_root=False, from_dir=None, recursive=True):
188
"""List all files in this tree.
190
:param include_root: Whether to include the entry for the tree root
191
:param from_dir: Directory under which to list files
192
:param recursive: Whether to list files recursively
193
:return: iterator over tuples of (path, versioned, kind, file_id,
196
raise NotImplementedError(self.list_files)
201
return self.inventory.iter_entries_by_dir(
202
specific_file_ids=specific_file_ids)
198
204
def iter_references(self):
199
if self.supports_tree_reference():
200
for path, entry in self.iter_entries_by_dir():
201
if entry.kind == 'tree-reference':
202
yield path, entry.file_id
205
for path, entry in self.iter_entries_by_dir():
206
if entry.kind == 'tree-reference':
207
yield path, entry.file_id
204
209
def kind(self, file_id):
205
210
raise NotImplementedError("Tree subclass %s must implement kind"
363
333
cur_file = (self.get_file_text(file_id),)
364
334
yield identifier, cur_file
366
def get_symlink_target(self, file_id, path=None):
336
def get_symlink_target(self, file_id):
367
337
"""Get the target for a given file_id.
369
339
It is assumed that the caller already knows that file_id is referencing
371
341
:param file_id: Handle for the symlink entry.
372
:param path: The path of the file.
373
If both file_id and path are supplied, an implementation may use
375
342
:return: The path the symlink points to.
377
344
raise NotImplementedError(self.get_symlink_target)
346
def get_canonical_inventory_paths(self, paths):
347
"""Like get_canonical_inventory_path() but works on multiple items.
349
:param paths: A sequence of paths relative to the root of the tree.
350
:return: A list of paths, with each item the corresponding input path
351
adjusted to account for existing elements that match case
354
return list(self._yield_canonical_inventory_paths(paths))
356
def get_canonical_inventory_path(self, path):
357
"""Returns the first inventory item that case-insensitively matches path.
359
If a path matches exactly, it is returned. If no path matches exactly
360
but more than one path matches case-insensitively, it is implementation
361
defined which is returned.
363
If no path matches case-insensitively, the input path is returned, but
364
with as many path entries that do exist changed to their canonical
367
If you need to resolve many names from the same tree, you should
368
use get_canonical_inventory_paths() to avoid O(N) behaviour.
370
:param path: A paths relative to the root of the tree.
371
:return: The input path adjusted to account for existing elements
372
that match case insensitively.
374
return self._yield_canonical_inventory_paths([path]).next()
376
def _yield_canonical_inventory_paths(self, paths):
378
# First, if the path as specified exists exactly, just use it.
379
if self.path2id(path) is not None:
383
cur_id = self.get_root_id()
385
bit_iter = iter(path.split("/"))
388
for child in self.iter_children(cur_id):
390
child_base = os.path.basename(self.id2path(child))
391
if child_base.lower() == lelt:
393
cur_path = osutils.pathjoin(cur_path, child_base)
396
# before a change is committed we can see this error...
399
# got to the end of this directory and no entries matched.
400
# Return what matched so far, plus the rest as specified.
401
cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
379
406
def get_root_id(self):
380
407
"""Return the file_id for the root of this tree."""
381
408
raise NotImplementedError(self.get_root_id)
439
466
except errors.NoSuchRevisionInTree:
440
467
yield self.repository.revision_tree(revision_id)
470
def _file_revision(revision_tree, file_id):
471
"""Determine the revision associated with a file in a given tree."""
472
revision_tree.lock_read()
474
return revision_tree.inventory[file_id].revision
476
revision_tree.unlock()
442
478
def _get_file_revision(self, file_id, vf, tree_revision):
443
479
"""Ensure that file_id, tree_revision is in vf to plan the merge."""
445
481
if getattr(self, '_repository', None) is None:
446
482
last_revision = tree_revision
447
parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
483
parent_keys = [(file_id, self._file_revision(t, file_id)) for t in
448
484
self._iter_parent_trees()]
449
485
vf.add_lines((file_id, last_revision), parent_keys,
450
self.get_file_lines(file_id))
486
self.get_file(file_id).readlines())
451
487
repo = self.branch.repository
452
488
base_vf = repo.texts
454
last_revision = self.get_file_revision(file_id)
490
last_revision = self._file_revision(self, file_id)
455
491
base_vf = self._repository.texts
456
492
if base_vf not in vf.fallback_versionedfiles:
457
493
vf.fallback_versionedfiles.append(base_vf)
458
494
return last_revision
496
inventory = property(_get_inventory,
497
doc="Inventory of this Tree")
460
499
def _check_retrieved(self, ie, f):
461
500
if not __debug__:
463
fp = osutils.fingerprint_file(f)
502
fp = fingerprint_file(f)
466
505
if ie.text_size is not None:
467
506
if ie.text_size != fp['size']:
468
raise errors.BzrError(
469
"mismatched size for file %r in %r" %
470
(ie.file_id, self._store),
507
raise BzrError("mismatched size for file %r in %r" % (ie.file_id, self._store),
471
508
["inventory expects %d bytes" % ie.text_size,
472
509
"file is actually %d bytes" % fp['size'],
473
510
"store is probably damaged/corrupt"])
475
512
if ie.text_sha1 != fp['sha1']:
476
raise errors.BzrError("wrong SHA-1 for file %r in %r" %
477
(ie.file_id, self._store),
513
raise BzrError("wrong SHA-1 for file %r in %r" % (ie.file_id, self._store),
478
514
["inventory expects %s" % ie.text_sha1,
479
515
"file is actually %s" % fp['sha1'],
480
516
"store is probably damaged/corrupt"])
482
519
def path2id(self, path):
483
520
"""Return the id for path in this tree."""
484
raise NotImplementedError(self.path2id)
521
return self._inventory.path2id(path)
486
523
def paths2ids(self, paths, trees=[], require_versioned=True):
487
524
"""Return all the ids that can be reached by walking from paths.
641
676
for path in path_names:
642
677
yield searcher.get_items(path)
644
680
def _get_rules_searcher(self, default_searcher):
645
681
"""Get the RulesSearcher for this tree given the default one."""
646
682
searcher = default_searcher
650
class InventoryTree(Tree):
651
"""A tree that relies on an inventory for its metadata.
653
Trees contain an `Inventory` object, and also know how to retrieve
654
file texts mentioned in the inventory, either from a working
655
directory or from a store.
657
It is possible for trees to contain files that are not described
658
in their inventory or vice versa; for this use `filenames()`.
660
Subclasses should set the _inventory attribute, which is considered
661
private to external API users.
686
######################################################################
689
# TODO: Merge these two functions into a single one that can operate
690
# on either a whole tree or a set of files.
692
# TODO: Return the diff in order by filename, not by category or in
693
# random order. Can probably be done by lock-stepping through the
694
# filenames from both trees.
697
def file_status(filename, old_tree, new_tree):
698
"""Return single-letter status, old and new names for a file.
700
The complexity here is in deciding how to represent renames;
701
many complex cases are possible.
664
def get_canonical_inventory_paths(self, paths):
665
"""Like get_canonical_inventory_path() but works on multiple items.
667
:param paths: A sequence of paths relative to the root of the tree.
668
:return: A list of paths, with each item the corresponding input path
669
adjusted to account for existing elements that match case
672
return list(self._yield_canonical_inventory_paths(paths))
674
def get_canonical_inventory_path(self, path):
675
"""Returns the first inventory item that case-insensitively matches path.
677
If a path matches exactly, it is returned. If no path matches exactly
678
but more than one path matches case-insensitively, it is implementation
679
defined which is returned.
681
If no path matches case-insensitively, the input path is returned, but
682
with as many path entries that do exist changed to their canonical
685
If you need to resolve many names from the same tree, you should
686
use get_canonical_inventory_paths() to avoid O(N) behaviour.
688
:param path: A paths relative to the root of the tree.
689
:return: The input path adjusted to account for existing elements
690
that match case insensitively.
692
return self._yield_canonical_inventory_paths([path]).next()
694
def _yield_canonical_inventory_paths(self, paths):
696
# First, if the path as specified exists exactly, just use it.
697
if self.path2id(path) is not None:
701
cur_id = self.get_root_id()
703
bit_iter = iter(path.split("/"))
707
for child in self.iter_children(cur_id):
709
# XXX: it seem like if the child is known to be in the
710
# tree, we shouldn't need to go from its id back to
711
# its path -- mbp 2010-02-11
713
# XXX: it seems like we could be more efficient
714
# by just directly looking up the original name and
715
# only then searching all children; also by not
716
# chopping paths so much. -- mbp 2010-02-11
717
child_base = os.path.basename(self.id2path(child))
718
if (child_base == elt):
719
# if we found an exact match, we can stop now; if
720
# we found an approximate match we need to keep
721
# searching because there might be an exact match
724
new_path = osutils.pathjoin(cur_path, child_base)
726
elif child_base.lower() == lelt:
728
new_path = osutils.pathjoin(cur_path, child_base)
729
except errors.NoSuchId:
730
# before a change is committed we can see this error...
735
# got to the end of this directory and no entries matched.
736
# Return what matched so far, plus the rest as specified.
737
cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
742
def _get_inventory(self):
743
return self._inventory
745
inventory = property(_get_inventory,
746
doc="Inventory of this Tree")
749
def path2id(self, path):
750
"""Return the id for path in this tree."""
751
return self._inventory.path2id(path)
753
def id2path(self, file_id):
754
"""Return the path for a file id.
758
return self.inventory.id2path(file_id)
760
def has_id(self, file_id):
761
return self.inventory.has_id(file_id)
763
def has_or_had_id(self, file_id):
764
return self.inventory.has_id(file_id)
766
def all_file_ids(self):
767
return set(self.inventory)
769
@deprecated_method(deprecated_in((2, 4, 0)))
771
return iter(self.inventory)
773
def filter_unversioned_files(self, paths):
774
"""Filter out paths that are versioned.
776
:return: set of paths.
778
# NB: we specifically *don't* call self.has_filename, because for
779
# WorkingTrees that can indicate files that exist on disk but that
781
pred = self.inventory.has_filename
782
return set((p for p in paths if not pred(p)))
785
def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
786
"""Walk the tree in 'by_dir' order.
788
This will yield each entry in the tree as a (path, entry) tuple.
789
The order that they are yielded is:
791
See Tree.iter_entries_by_dir for details.
793
:param yield_parents: If True, yield the parents from the root leading
794
down to specific_file_ids that have been requested. This has no
795
impact if specific_file_ids is None.
797
return self.inventory.iter_entries_by_dir(
798
specific_file_ids=specific_file_ids, yield_parents=yield_parents)
800
def get_file_by_path(self, path):
801
return self.get_file(self._inventory.path2id(path), path)
703
old_inv = old_tree.inventory
704
new_inv = new_tree.inventory
705
new_id = new_inv.path2id(filename)
706
old_id = old_inv.path2id(filename)
708
if not new_id and not old_id:
709
# easy: doesn't exist in either; not versioned at all
710
if new_tree.is_ignored(filename):
711
return 'I', None, None
713
return '?', None, None
715
# There is now a file of this name, great.
718
# There is no longer a file of this name, but we can describe
719
# what happened to the file that used to have
720
# this name. There are two possibilities: either it was
721
# deleted entirely, or renamed.
722
if new_inv.has_id(old_id):
723
return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
725
return 'D', old_inv.id2path(old_id), None
727
# if the file_id is new in this revision, it is added
728
if new_id and not old_inv.has_id(new_id):
731
# if there used to be a file of this name, but that ID has now
732
# disappeared, it is deleted
733
if old_id and not new_inv.has_id(old_id):
739
@deprecated_function(deprecated_in((1, 9, 0)))
740
def find_renames(old_inv, new_inv):
741
for file_id in old_inv:
742
if file_id not in new_inv:
744
old_name = old_inv.id2path(file_id)
745
new_name = new_inv.id2path(file_id)
746
if old_name != new_name:
747
yield (old_name, new_name)
804
750
def find_ids_across_trees(filenames, trees, require_versioned=True):
885
831
will pass through to InterTree as appropriate.
888
# Formats that will be used to test this InterTree. If both are
889
# None, this InterTree will not be tested (e.g. because a complex
891
_matching_from_tree_format = None
892
_matching_to_tree_format = None
897
def is_compatible(kls, source, target):
898
# The default implementation is naive and uses the public API, so
899
# it works for all trees.
902
def _changes_from_entries(self, source_entry, target_entry,
903
source_path=None, target_path=None):
904
"""Generate a iter_changes tuple between source_entry and target_entry.
906
:param source_entry: An inventory entry from self.source, or None.
907
:param target_entry: An inventory entry from self.target, or None.
908
:param source_path: The path of source_entry, if known. If not known
909
it will be looked up.
910
:param target_path: The path of target_entry, if known. If not known
911
it will be looked up.
912
:return: A tuple, item 0 of which is an iter_changes result tuple, and
913
item 1 is True if there are any changes in the result tuple.
915
if source_entry is None:
916
if target_entry is None:
918
file_id = target_entry.file_id
920
file_id = source_entry.file_id
921
if source_entry is not None:
922
source_versioned = True
923
source_name = source_entry.name
924
source_parent = source_entry.parent_id
925
if source_path is None:
926
source_path = self.source.id2path(file_id)
927
source_kind, source_executable, source_stat = \
928
self.source._comparison_data(source_entry, source_path)
930
source_versioned = False
934
source_executable = None
935
if target_entry is not None:
936
target_versioned = True
937
target_name = target_entry.name
938
target_parent = target_entry.parent_id
939
if target_path is None:
940
target_path = self.target.id2path(file_id)
941
target_kind, target_executable, target_stat = \
942
self.target._comparison_data(target_entry, target_path)
944
target_versioned = False
948
target_executable = None
949
versioned = (source_versioned, target_versioned)
950
kind = (source_kind, target_kind)
951
changed_content = False
952
if source_kind != target_kind:
953
changed_content = True
954
elif source_kind == 'file':
955
if (self.source.get_file_sha1(file_id, source_path, source_stat) !=
956
self.target.get_file_sha1(file_id, target_path, target_stat)):
957
changed_content = True
958
elif source_kind == 'symlink':
959
if (self.source.get_symlink_target(file_id) !=
960
self.target.get_symlink_target(file_id)):
961
changed_content = True
962
# XXX: Yes, the indentation below is wrong. But fixing it broke
963
# test_merge.TestMergerEntriesLCAOnDisk.
964
# test_nested_tree_subtree_renamed_and_modified. We'll wait for
965
# the fix from bzr.dev -- vila 2009026
966
elif source_kind == 'tree-reference':
967
if (self.source.get_reference_revision(file_id, source_path)
968
!= self.target.get_reference_revision(file_id, target_path)):
969
changed_content = True
970
parent = (source_parent, target_parent)
971
name = (source_name, target_name)
972
executable = (source_executable, target_executable)
973
if (changed_content is not False or versioned[0] != versioned[1]
974
or parent[0] != parent[1] or name[0] != name[1] or
975
executable[0] != executable[1]):
979
return (file_id, (source_path, target_path), changed_content,
980
versioned, parent, name, kind, executable), changes
983
837
def compare(self, want_unchanged=False, specific_files=None,
984
838
extra_trees=None, require_versioned=False, include_root=False,
1094
932
# the unversioned path lookup only occurs on real trees - where there
1095
933
# can be extras. So the fake_entry is solely used to look up
1096
934
# executable it values when execute is not supported.
1097
fake_entry = inventory.InventoryFile('unused', 'unused', 'unused')
1098
for target_path, target_entry in to_entries_by_dir:
1099
while (all_unversioned and
1100
all_unversioned[0][0] < target_path.split('/')):
935
fake_entry = InventoryFile('unused', 'unused', 'unused')
936
for to_path, to_entry in to_entries_by_dir:
937
while all_unversioned and all_unversioned[0][0] < to_path.split('/'):
1101
938
unversioned_path = all_unversioned.popleft()
1102
target_kind, target_executable, target_stat = \
939
to_kind, to_executable, to_stat = \
1103
940
self.target._comparison_data(fake_entry, unversioned_path[1])
1104
941
yield (None, (None, unversioned_path[1]), True, (False, False),
1106
943
(None, unversioned_path[0][-1]),
1107
(None, target_kind),
1108
(None, target_executable))
1109
source_path, source_entry = from_data.get(target_entry.file_id,
1111
result, changes = self._changes_from_entries(source_entry,
1112
target_entry, source_path=source_path, target_path=target_path)
1113
to_paths[result[0]] = result[1][1]
945
(None, to_executable))
946
file_id = to_entry.file_id
947
to_paths[file_id] = to_path
1114
948
entry_count += 1
949
changed_content = False
950
from_path, from_entry = from_data.get(file_id, (None, None))
951
from_versioned = (from_entry is not None)
952
if from_entry is not None:
953
from_versioned = True
954
from_name = from_entry.name
955
from_parent = from_entry.parent_id
956
from_kind, from_executable, from_stat = \
957
self.source._comparison_data(from_entry, from_path)
1116
958
entry_count += 1
960
from_versioned = False
964
from_executable = None
965
versioned = (from_versioned, True)
966
to_kind, to_executable, to_stat = \
967
self.target._comparison_data(to_entry, to_path)
968
kind = (from_kind, to_kind)
969
if kind[0] != kind[1]:
970
changed_content = True
971
elif from_kind == 'file':
972
if (self.source.get_file_sha1(file_id, from_path, from_stat) !=
973
self.target.get_file_sha1(file_id, to_path, to_stat)):
974
changed_content = True
975
elif from_kind == 'symlink':
976
if (self.source.get_symlink_target(file_id) !=
977
self.target.get_symlink_target(file_id)):
978
changed_content = True
979
# XXX: Yes, the indentation below is wrong. But fixing it broke
980
# test_merge.TestMergerEntriesLCAOnDisk.
981
# test_nested_tree_subtree_renamed_and_modified. We'll wait for
982
# the fix from bzr.dev -- vila 2009026
983
elif from_kind == 'tree-reference':
984
if (self.source.get_reference_revision(file_id, from_path)
985
!= self.target.get_reference_revision(file_id, to_path)):
986
changed_content = True
987
parent = (from_parent, to_entry.parent_id)
988
name = (from_name, to_entry.name)
989
executable = (from_executable, to_executable)
1117
990
if pb is not None:
1118
991
pb.update('comparing files', entry_count, num_entries)
1119
if changes or include_unchanged:
1120
if specific_file_ids is not None:
1121
new_parent_id = result[4][1]
1122
precise_file_ids.add(new_parent_id)
1123
changed_file_ids.append(result[0])
1125
# Ensure correct behaviour for reparented/added specific files.
1126
if specific_files is not None:
1127
# Record output dirs
1128
if result[6][1] == 'directory':
1129
seen_dirs.add(result[0])
1130
# Record parents of reparented/added entries.
1131
versioned = result[3]
1133
if not versioned[0] or parents[0] != parents[1]:
1134
seen_parents.add(parents[1])
992
if (changed_content is not False or versioned[0] != versioned[1]
993
or parent[0] != parent[1] or name[0] != name[1] or
994
executable[0] != executable[1] or include_unchanged):
995
yield (file_id, (from_path, to_path), changed_content,
996
versioned, parent, name, kind, executable)
1135
998
while all_unversioned:
1136
999
# yield any trailing unversioned paths
1137
1000
unversioned_path = all_unversioned.popleft()
1166
1041
executable = (from_executable, None)
1167
1042
changed_content = from_kind is not None
1168
1043
# the parent's path is necessarily known at this point.
1169
changed_file_ids.append(file_id)
1170
1044
yield(file_id, (path, to_path), changed_content, versioned, parent,
1171
1045
name, kind, executable)
1172
changed_file_ids = set(changed_file_ids)
1173
if specific_file_ids is not None:
1174
for result in self._handle_precise_ids(precise_file_ids,
1178
def _get_entry(self, tree, file_id):
1179
"""Get an inventory entry from a tree, with missing entries as None.
1181
If the tree raises NotImplementedError on accessing .inventory, then
1182
this is worked around using iter_entries_by_dir on just the file id
1185
:param tree: The tree to lookup the entry in.
1186
:param file_id: The file_id to lookup.
1189
inventory = tree.inventory
1190
except NotImplementedError:
1191
# No inventory available.
1193
iterator = tree.iter_entries_by_dir(specific_file_ids=[file_id])
1194
return iterator.next()[1]
1195
except StopIteration:
1199
return inventory[file_id]
1200
except errors.NoSuchId:
1203
def _handle_precise_ids(self, precise_file_ids, changed_file_ids,
1204
discarded_changes=None):
1205
"""Fill out a partial iter_changes to be consistent.
1207
:param precise_file_ids: The file ids of parents that were seen during
1209
:param changed_file_ids: The file ids of already emitted items.
1210
:param discarded_changes: An optional dict of precalculated
1211
iter_changes items which the partial iter_changes had not output
1213
:return: A generator of iter_changes items to output.
1215
# process parents of things that had changed under the users
1216
# requested paths to prevent incorrect paths or parent ids which
1217
# aren't in the tree.
1218
while precise_file_ids:
1219
precise_file_ids.discard(None)
1220
# Don't emit file_ids twice
1221
precise_file_ids.difference_update(changed_file_ids)
1222
if not precise_file_ids:
1224
# If the there was something at a given output path in source, we
1225
# have to include the entry from source in the delta, or we would
1226
# be putting this entry into a used path.
1228
for parent_id in precise_file_ids:
1230
paths.append(self.target.id2path(parent_id))
1231
except errors.NoSuchId:
1232
# This id has been dragged in from the source by delta
1233
# expansion and isn't present in target at all: we don't
1234
# need to check for path collisions on it.
1237
old_id = self.source.path2id(path)
1238
precise_file_ids.add(old_id)
1239
precise_file_ids.discard(None)
1240
current_ids = precise_file_ids
1241
precise_file_ids = set()
1242
# We have to emit all of precise_file_ids that have been altered.
1243
# We may have to output the children of some of those ids if any
1244
# directories have stopped being directories.
1245
for file_id in current_ids:
1247
if discarded_changes:
1248
result = discarded_changes.get(file_id)
1253
old_entry = self._get_entry(self.source, file_id)
1254
new_entry = self._get_entry(self.target, file_id)
1255
result, changes = self._changes_from_entries(
1256
old_entry, new_entry)
1259
# Get this parents parent to examine.
1260
new_parent_id = result[4][1]
1261
precise_file_ids.add(new_parent_id)
1263
if (result[6][0] == 'directory' and
1264
result[6][1] != 'directory'):
1265
# This stopped being a directory, the old children have
1267
if old_entry is None:
1268
# Reusing a discarded change.
1269
old_entry = self._get_entry(self.source, file_id)
1270
for child in old_entry.children.values():
1271
precise_file_ids.add(child.file_id)
1272
changed_file_ids.add(result[0])
1276
InterTree.register_optimiser(InterTree)
1279
1048
class MultiWalker(object):
added
removed
bzrlib/tree.py
