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
678
for path in path_names:
642
679
yield searcher.get_items(path)
644
682
def _get_rules_searcher(self, default_searcher):
645
683
"""Get the RulesSearcher for this tree given the default one."""
646
684
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.
688
######################################################################
691
# TODO: Merge these two functions into a single one that can operate
692
# on either a whole tree or a set of files.
694
# TODO: Return the diff in order by filename, not by category or in
695
# random order. Can probably be done by lock-stepping through the
696
# filenames from both trees.
699
def file_status(filename, old_tree, new_tree):
700
"""Return single-letter status, old and new names for a file.
702
The complexity here is in deciding how to represent renames;
703
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)
705
old_inv = old_tree.inventory
706
new_inv = new_tree.inventory
707
new_id = new_inv.path2id(filename)
708
old_id = old_inv.path2id(filename)
710
if not new_id and not old_id:
711
# easy: doesn't exist in either; not versioned at all
712
if new_tree.is_ignored(filename):
713
return 'I', None, None
715
return '?', None, None
717
# There is now a file of this name, great.
720
# There is no longer a file of this name, but we can describe
721
# what happened to the file that used to have
722
# this name. There are two possibilities: either it was
723
# deleted entirely, or renamed.
724
if new_inv.has_id(old_id):
725
return 'X', old_inv.id2path(old_id), new_inv.id2path(old_id)
727
return 'D', old_inv.id2path(old_id), None
729
# if the file_id is new in this revision, it is added
730
if new_id and not old_inv.has_id(new_id):
733
# if there used to be a file of this name, but that ID has now
734
# disappeared, it is deleted
735
if old_id and not new_inv.has_id(old_id):
741
@deprecated_function(deprecated_in((1, 9, 0)))
742
def find_renames(old_inv, new_inv):
743
for file_id in old_inv:
744
if file_id not in new_inv:
746
old_name = old_inv.id2path(file_id)
747
new_name = new_inv.id2path(file_id)
748
if old_name != new_name:
749
yield (old_name, new_name)
804
752
def find_ids_across_trees(filenames, trees, require_versioned=True):
885
833
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
839
def compare(self, want_unchanged=False, specific_files=None,
984
840
extra_trees=None, require_versioned=False, include_root=False,
1094
934
# the unversioned path lookup only occurs on real trees - where there
1095
935
# can be extras. So the fake_entry is solely used to look up
1096
936
# 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('/')):
937
fake_entry = InventoryFile('unused', 'unused', 'unused')
938
for to_path, to_entry in to_entries_by_dir:
939
while all_unversioned and all_unversioned[0][0] < to_path.split('/'):
1101
940
unversioned_path = all_unversioned.popleft()
1102
target_kind, target_executable, target_stat = \
941
to_kind, to_executable, to_stat = \
1103
942
self.target._comparison_data(fake_entry, unversioned_path[1])
1104
943
yield (None, (None, unversioned_path[1]), True, (False, False),
1106
945
(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]
947
(None, to_executable))
948
file_id = to_entry.file_id
949
to_paths[file_id] = to_path
1114
950
entry_count += 1
951
changed_content = False
952
from_path, from_entry = from_data.get(file_id, (None, None))
953
from_versioned = (from_entry is not None)
954
if from_entry is not None:
955
from_versioned = True
956
from_name = from_entry.name
957
from_parent = from_entry.parent_id
958
from_kind, from_executable, from_stat = \
959
self.source._comparison_data(from_entry, from_path)
1116
960
entry_count += 1
962
from_versioned = False
966
from_executable = None
967
versioned = (from_versioned, True)
968
to_kind, to_executable, to_stat = \
969
self.target._comparison_data(to_entry, to_path)
970
kind = (from_kind, to_kind)
971
if kind[0] != kind[1]:
972
changed_content = True
973
elif from_kind == 'file':
974
if (self.source.get_file_sha1(file_id, from_path, from_stat) !=
975
self.target.get_file_sha1(file_id, to_path, to_stat)):
976
changed_content = True
977
elif from_kind == 'symlink':
978
if (self.source.get_symlink_target(file_id) !=
979
self.target.get_symlink_target(file_id)):
980
changed_content = True
981
# XXX: Yes, the indentation below is wrong. But fixing it broke
982
# test_merge.TestMergerEntriesLCAOnDisk.
983
# test_nested_tree_subtree_renamed_and_modified. We'll wait for
984
# the fix from bzr.dev -- vila 2009026
985
elif from_kind == 'tree-reference':
986
if (self.source.get_reference_revision(file_id, from_path)
987
!= self.target.get_reference_revision(file_id, to_path)):
988
changed_content = True
989
parent = (from_parent, to_entry.parent_id)
990
name = (from_name, to_entry.name)
991
executable = (from_executable, to_executable)
1117
992
if pb is not None:
1118
993
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])
994
if (changed_content is not False or versioned[0] != versioned[1]
995
or parent[0] != parent[1] or name[0] != name[1] or
996
executable[0] != executable[1] or include_unchanged):
997
yield (file_id, (from_path, to_path), changed_content,
998
versioned, parent, name, kind, executable)
1135
1000
while all_unversioned:
1136
1001
# yield any trailing unversioned paths
1137
1002
unversioned_path = all_unversioned.popleft()
1166
1043
executable = (from_executable, None)
1167
1044
changed_content = from_kind is not None
1168
1045
# the parent's path is necessarily known at this point.
1169
changed_file_ids.append(file_id)
1170
1046
yield(file_id, (path, to_path), changed_content, versioned, parent,
1171
1047
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
1050
class MultiWalker(object):