« back to all changes in this revision
Viewing changes to bzrlib/tree.py
- browse files at revision 4641.5.14
- compare with another revision
- compare with revision 6170
- download diff
- download tarball
- view history from revision 4641.5.14
- Committer: John Arbash Meinel
- Date: 2009-09-02 13:32:52 UTC
- mfrom: (4634.6.14 2.0)
- mto: (4634.6.15 2.0)
- mto: This revision was merged to the branch mainline in revision 4667.
- Revision ID: john@arbash-meinel.com-20090902133252-t2t94xtckoliv2th
Merge lp:bzr/2.0 to resolve NEWS issues.
- files added:
- doc/developers/content-filtering.txt
- files removed:
- doc/en/migration
- files modified:
- NEWS
added
removed
bzrlib/tree.py
170
170
return self.bzrdir.is_control_filename(filename)
171
171
172
172
@needs_read_lock
173
def iter_entries_by_dir(self, specific_file_ids=None):
173
def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
174
174
"""Walk the tree in 'by_dir' order.
175
175
176
176
This will yield each entry in the tree as a (path, entry) tuple.
193
193
194
194
The yield order (ignoring root) would be::
195
195
a, f, a/b, a/d, a/b/c, a/d/e, f/g
196
197
:param yield_parents: If True, yield the parents from the root leading
198
down to specific_file_ids that have been requested. This has no
199
impact if specific_file_ids is None.
196
200
"""
197
201
return self.inventory.iter_entries_by_dir(
198
specific_file_ids=specific_file_ids)
202
specific_file_ids=specific_file_ids, yield_parents=yield_parents)
199
203
200
204
def iter_references(self):
201
205
if self.supports_tree_reference():
218
222
def path_content_summary(self, path):
219
223
"""Get a summary of the information about path.
220
224
225
All the attributes returned are for the canonical form, not the
226
convenient form (if content filters are in use.)
227
221
228
:param path: A relative path within the tree.
222
229
:return: A tuple containing kind, size, exec, sha1-or-link.
223
230
Kind is always present (see tree.kind()).
224
size is present if kind is file, None otherwise.
231
size is present if kind is file and the size of the
232
canonical form can be cheaply determined, None otherwise.
225
233
exec is None unless kind is file and the platform supports the 'x'
226
234
bit.
227
235
sha1-or-link is the link target if kind is symlink, or the sha1 if
846
854
847
855
_optimisers = []
848
856
857
def _changes_from_entries(self, source_entry, target_entry,
858
source_path=None, target_path=None):
859
"""Generate a iter_changes tuple between source_entry and target_entry.
860
861
:param source_entry: An inventory entry from self.source, or None.
862
:param target_entry: An inventory entry from self.target, or None.
863
:param source_path: The path of source_entry, if known. If not known
864
it will be looked up.
865
:param target_path: The path of target_entry, if known. If not known
866
it will be looked up.
867
:return: A tuple, item 0 of which is an iter_changes result tuple, and
868
item 1 is True if there are any changes in the result tuple.
869
"""
870
if source_entry is None:
871
if target_entry is None:
872
return None
873
file_id = target_entry.file_id
874
else:
875
file_id = source_entry.file_id
876
if source_entry is not None:
877
source_versioned = True
878
source_name = source_entry.name
879
source_parent = source_entry.parent_id
880
if source_path is None:
881
source_path = self.source.id2path(file_id)
882
source_kind, source_executable, source_stat = \
883
self.source._comparison_data(source_entry, source_path)
884
else:
885
source_versioned = False
886
source_name = None
887
source_parent = None
888
source_kind = None
889
source_executable = None
890
if target_entry is not None:
891
target_versioned = True
892
target_name = target_entry.name
893
target_parent = target_entry.parent_id
894
if target_path is None:
895
target_path = self.target.id2path(file_id)
896
target_kind, target_executable, target_stat = \
897
self.target._comparison_data(target_entry, target_path)
898
else:
899
target_versioned = False
900
target_name = None
901
target_parent = None
902
target_kind = None
903
target_executable = None
904
versioned = (source_versioned, target_versioned)
905
kind = (source_kind, target_kind)
906
changed_content = False
907
if source_kind != target_kind:
908
changed_content = True
909
elif source_kind == 'file':
910
if (self.source.get_file_sha1(file_id, source_path, source_stat) !=
911
self.target.get_file_sha1(file_id, target_path, target_stat)):
912
changed_content = True
913
elif source_kind == 'symlink':
914
if (self.source.get_symlink_target(file_id) !=
915
self.target.get_symlink_target(file_id)):
916
changed_content = True
917
# XXX: Yes, the indentation below is wrong. But fixing it broke
918
# test_merge.TestMergerEntriesLCAOnDisk.
919
# test_nested_tree_subtree_renamed_and_modified. We'll wait for
920
# the fix from bzr.dev -- vila 2009026
921
elif source_kind == 'tree-reference':
922
if (self.source.get_reference_revision(file_id, source_path)
923
!= self.target.get_reference_revision(file_id, target_path)):
924
changed_content = True
925
parent = (source_parent, target_parent)
926
name = (source_name, target_name)
927
executable = (source_executable, target_executable)
928
if (changed_content is not False or versioned[0] != versioned[1]
929
or parent[0] != parent[1] or name[0] != name[1] or
930
executable[0] != executable[1]):
931
changes = True
932
else:
933
changes = False
934
return (file_id, (source_path, target_path), changed_content,
935
versioned, parent, name, kind, executable), changes
936
849
937
@needs_read_lock
850
938
def compare(self, want_unchanged=False, specific_files=None,
851
939
extra_trees=None, require_versioned=False, include_root=False,
914
1002
:param require_versioned: Raise errors.PathsNotVersionedError if a
915
1003
path in the specific_files list is not versioned in one of
916
1004
source, target or extra_trees.
1005
:param specific_files: An optional list of file paths to restrict the
1006
comparison to. When mapping filenames to ids, all matches in all
1007
trees (including optional extra_trees) are used, and all children
1008
of matched directories are included. The parents in the target tree
1009
of the specific files up to and including the root of the tree are
1010
always evaluated for changes too.
917
1011
:param want_unversioned: Should unversioned files be returned in the
918
1012
output. An unversioned file is defined as one with (False, False)
919
1013
for the versioned pair.
921
1015
lookup_trees = [self.source]
922
1016
if extra_trees:
923
1017
lookup_trees.extend(extra_trees)
1018
# The ids of items we need to examine to insure delta consistency.
1019
precise_file_ids = set()
1020
changed_file_ids = []
924
1021
if specific_files == []:
925
1022
specific_file_ids = []
926
1023
else:
927
1024
specific_file_ids = self.target.paths2ids(specific_files,
928
1025
lookup_trees, require_versioned=require_versioned)
1026
if specific_files is not None:
1027
# reparented or added entries must have their parents included
1028
# so that valid deltas can be created. The seen_parents set
1029
# tracks the parents that we need to have.
1030
# The seen_dirs set tracks directory entries we've yielded.
1031
# After outputting version object in to_entries we set difference
1032
# the two seen sets and start checking parents.
1033
seen_parents = set()
1034
seen_dirs = set()
929
1035
if want_unversioned:
930
1036
all_unversioned = sorted([(p.split('/'), p) for p in
931
1037
self.target.extras()
946
1052
# can be extras. So the fake_entry is solely used to look up
947
1053
# executable it values when execute is not supported.
948
1054
fake_entry = InventoryFile('unused', 'unused', 'unused')
949
for to_path, to_entry in to_entries_by_dir:
950
while all_unversioned and all_unversioned[0][0] < to_path.split('/'):
1055
for target_path, target_entry in to_entries_by_dir:
1056
while (all_unversioned and
1057
all_unversioned[0][0] < target_path.split('/')):
951
1058
unversioned_path = all_unversioned.popleft()
952
to_kind, to_executable, to_stat = \
1059
target_kind, target_executable, target_stat = \
953
1060
self.target._comparison_data(fake_entry, unversioned_path[1])
954
1061
yield (None, (None, unversioned_path[1]), True, (False, False),
955
1062
(None, None),
956
1063
(None, unversioned_path[0][-1]),
957
(None, to_kind),
958
(None, to_executable))
959
file_id = to_entry.file_id
960
to_paths[file_id] = to_path
1064
(None, target_kind),
1065
(None, target_executable))
1066
source_path, source_entry = from_data.get(target_entry.file_id,
1067
(None, None))
1068
result, changes = self._changes_from_entries(source_entry,
1069
target_entry, source_path=source_path, target_path=target_path)
1070
to_paths[result[0]] = result[1][1]
961
1071
entry_count += 1
962
changed_content = False
963
from_path, from_entry = from_data.get(file_id, (None, None))
964
from_versioned = (from_entry is not None)
965
if from_entry is not None:
966
from_versioned = True
967
from_name = from_entry.name
968
from_parent = from_entry.parent_id
969
from_kind, from_executable, from_stat = \
970
self.source._comparison_data(from_entry, from_path)
1072
if result[3][0]:
971
1073
entry_count += 1
972
else:
973
from_versioned = False
974
from_kind = None
975
from_parent = None
976
from_name = None
977
from_executable = None
978
versioned = (from_versioned, True)
979
to_kind, to_executable, to_stat = \
980
self.target._comparison_data(to_entry, to_path)
981
kind = (from_kind, to_kind)
982
if kind[0] != kind[1]:
983
changed_content = True
984
elif from_kind == 'file':
985
if (self.source.get_file_sha1(file_id, from_path, from_stat) !=
986
self.target.get_file_sha1(file_id, to_path, to_stat)):
987
changed_content = True
988
elif from_kind == 'symlink':
989
if (self.source.get_symlink_target(file_id) !=
990
self.target.get_symlink_target(file_id)):
991
changed_content = True
992
# XXX: Yes, the indentation below is wrong. But fixing it broke
993
# test_merge.TestMergerEntriesLCAOnDisk.
994
# test_nested_tree_subtree_renamed_and_modified. We'll wait for
995
# the fix from bzr.dev -- vila 2009026
996
elif from_kind == 'tree-reference':
997
if (self.source.get_reference_revision(file_id, from_path)
998
!= self.target.get_reference_revision(file_id, to_path)):
999
changed_content = True
1000
parent = (from_parent, to_entry.parent_id)
1001
name = (from_name, to_entry.name)
1002
executable = (from_executable, to_executable)
1003
1074
if pb is not None:
1004
1075
pb.update('comparing files', entry_count, num_entries)
1005
if (changed_content is not False or versioned[0] != versioned[1]
1006
or parent[0] != parent[1] or name[0] != name[1] or
1007
executable[0] != executable[1] or include_unchanged):
1008
yield (file_id, (from_path, to_path), changed_content,
1009
versioned, parent, name, kind, executable)
1010
1076
if changes or include_unchanged:
1077
if specific_file_ids is not None:
1078
new_parent_id = result[4][1]
1079
precise_file_ids.add(new_parent_id)
1080
changed_file_ids.append(result[0])
1081
yield result
1082
# Ensure correct behaviour for reparented/added specific files.
1083
if specific_files is not None:
1084
# Record output dirs
1085
if result[6][1] == 'directory':
1086
seen_dirs.add(result[0])
1087
# Record parents of reparented/added entries.
1088
versioned = result[3]
1089
parents = result[4]
1090
if not versioned[0] or parents[0] != parents[1]:
1091
seen_parents.add(parents[1])
1011
1092
while all_unversioned:
1012
1093
# yield any trailing unversioned paths
1013
1094
unversioned_path = all_unversioned.popleft()
1018
1099
(None, unversioned_path[0][-1]),
1019
1100
(None, to_kind),
1020
1101
(None, to_executable))
1021
1022
def get_to_path(to_entry):
1023
if to_entry.parent_id is None:
1024
to_path = '' # the root
1025
else:
1026
if to_entry.parent_id not in to_paths:
1027
# recurse up
1028
return get_to_path(self.target.inventory[to_entry.parent_id])
1029
to_path = osutils.pathjoin(to_paths[to_entry.parent_id],
1030
to_entry.name)
1031
to_paths[to_entry.file_id] = to_path
1032
return to_path
1033
1102
# Yield all remaining source paths
1034
1103
for path, from_entry in from_entries_by_dir:
1035
1104
file_id = from_entry.file_id
1036
1105
if file_id in to_paths:
1037
1106
# already returned
1038
1107
continue
1039
if not file_id in self.target.all_file_ids():
1108
if file_id not in self.target.all_file_ids():
1040
1109
# common case - paths we have not emitted are not present in
1041
1110
# target.
1042
1111
to_path = None
1043
1112
else:
1044
to_path = get_to_path(self.target.inventory[file_id])
1113
to_path = self.target.id2path(file_id)
1045
1114
entry_count += 1
1046
1115
if pb is not None:
1047
1116
pb.update('comparing files', entry_count, num_entries)
1054
1123
executable = (from_executable, None)
1055
1124
changed_content = from_kind is not None
1056
1125
# the parent's path is necessarily known at this point.
1126
changed_file_ids.append(file_id)
1057
1127
yield(file_id, (path, to_path), changed_content, versioned, parent,
1058
1128
name, kind, executable)
1129
changed_file_ids = set(changed_file_ids)
1130
if specific_file_ids is not None:
1131
for result in self._handle_precise_ids(precise_file_ids,
1132
changed_file_ids):
1133
yield result
1134
1135
def _get_entry(self, tree, file_id):
1136
"""Get an inventory entry from a tree, with missing entries as None.
1137
1138
If the tree raises NotImplementedError on accessing .inventory, then
1139
this is worked around using iter_entries_by_dir on just the file id
1140
desired.
1141
1142
:param tree: The tree to lookup the entry in.
1143
:param file_id: The file_id to lookup.
1144
"""
1145
try:
1146
inventory = tree.inventory
1147
except NotImplementedError:
1148
# No inventory available.
1149
try:
1150
iterator = tree.iter_entries_by_dir(specific_file_ids=[file_id])
1151
return iterator.next()[1]
1152
except StopIteration:
1153
return None
1154
else:
1155
try:
1156
return inventory[file_id]
1157
except errors.NoSuchId:
1158
return None
1159
1160
def _handle_precise_ids(self, precise_file_ids, changed_file_ids,
1161
discarded_changes=None):
1162
"""Fill out a partial iter_changes to be consistent.
1163
1164
:param precise_file_ids: The file ids of parents that were seen during
1165
the iter_changes.
1166
:param changed_file_ids: The file ids of already emitted items.
1167
:param discarded_changes: An optional dict of precalculated
1168
iter_changes items which the partial iter_changes had not output
1169
but had calculated.
1170
:return: A generator of iter_changes items to output.
1171
"""
1172
# process parents of things that had changed under the users
1173
# requested paths to prevent incorrect paths or parent ids which
1174
# aren't in the tree.
1175
while precise_file_ids:
1176
precise_file_ids.discard(None)
1177
# Don't emit file_ids twice
1178
precise_file_ids.difference_update(changed_file_ids)
1179
if not precise_file_ids:
1180
break
1181
# If the there was something at a given output path in source, we
1182
# have to include the entry from source in the delta, or we would
1183
# be putting this entry into a used path.
1184
paths = []
1185
for parent_id in precise_file_ids:
1186
try:
1187
paths.append(self.target.id2path(parent_id))
1188
except errors.NoSuchId:
1189
# This id has been dragged in from the source by delta
1190
# expansion and isn't present in target at all: we don't
1191
# need to check for path collisions on it.
1192
pass
1193
for path in paths:
1194
old_id = self.source.path2id(path)
1195
precise_file_ids.add(old_id)
1196
precise_file_ids.discard(None)
1197
current_ids = precise_file_ids
1198
precise_file_ids = set()
1199
# We have to emit all of precise_file_ids that have been altered.
1200
# We may have to output the children of some of those ids if any
1201
# directories have stopped being directories.
1202
for file_id in current_ids:
1203
# Examine file_id
1204
if discarded_changes:
1205
result = discarded_changes.get(file_id)
1206
old_entry = None
1207
else:
1208
result = None
1209
if result is None:
1210
old_entry = self._get_entry(self.source, file_id)
1211
new_entry = self._get_entry(self.target, file_id)
1212
result, changes = self._changes_from_entries(
1213
old_entry, new_entry)
1214
else:
1215
changes = True
1216
# Get this parents parent to examine.
1217
new_parent_id = result[4][1]
1218
precise_file_ids.add(new_parent_id)
1219
if changes:
1220
if (result[6][0] == 'directory' and
1221
result[6][1] != 'directory'):
1222
# This stopped being a directory, the old children have
1223
# to be included.
1224
if old_entry is None:
1225
# Reusing a discarded change.
1226
old_entry = self._get_entry(self.source, file_id)
1227
for child in old_entry.children.values():
1228
precise_file_ids.add(child.file_id)
1229
changed_file_ids.add(result[0])
1230
yield result
1059
1231
1060
1232
1061
1233
class MultiWalker(object):
Loggerhead is a web-based interface for Breezy
Version: 2.0.1