288
288
if not PyString_CheckExact(path2):
289
289
raise TypeError("'path2' must be a plain string, not %s: %r"
290
290
% (type(path2), path2))
291
return _cmp_path_by_dirblock_intern(PyString_AsString(path1),
292
PyString_Size(path1),
293
PyString_AsString(path2),
294
PyString_Size(path2))
297
cdef int _cmp_path_by_dirblock_intern(char *path1, int path1_len,
298
char *path2, int path2_len): # cannot_raise
291
return _cmp_path_by_dirblock(PyString_AsString(path1),
292
PyString_Size(path1),
293
PyString_AsString(path2),
294
PyString_Size(path2))
297
cdef int _cmp_path_by_dirblock(char *path1, int path1_len,
298
char *path2, int path2_len):
299
299
"""Compare two paths by what directory they are in.
301
see ``_cmp_path_by_dirblock`` for details.
301
see ``_cmp_path_by_dirblock_c`` for details.
303
303
cdef char *dirname1
304
304
cdef int dirname1_len
965
962
cdef class ProcessEntryC:
967
cdef int doing_consistency_expansion
968
964
cdef object old_dirname_to_file_id # dict
969
965
cdef object new_dirname_to_file_id # dict
966
cdef readonly object uninteresting
970
967
cdef object last_source_parent
971
968
cdef object last_target_parent
972
cdef int include_unchanged
969
cdef object include_unchanged
974
970
cdef object use_filesystem_for_exec
975
971
cdef object utf8_decode
976
972
cdef readonly object searched_specific_files
977
cdef readonly object searched_exact_paths
978
973
cdef object search_specific_files
979
# The parents up to the root of the paths we are searching.
980
# After all normal paths are returned, these specific items are returned.
981
cdef object search_specific_file_parents
982
974
cdef object state
983
975
# Current iteration variables:
984
976
cdef object current_root
996
988
cdef object current_block_list
997
989
cdef object current_dir_info
998
990
cdef object current_dir_list
999
cdef object _pending_consistent_entries # list
1000
991
cdef int path_index
1001
992
cdef object root_dir_info
1002
993
cdef object bisect_left
1003
994
cdef object pathjoin
1004
995
cdef object fstat
1005
# A set of the ids we've output when doing partial output.
1006
cdef object seen_ids
1007
996
cdef object sha_file
1009
998
def __init__(self, include_unchanged, use_filesystem_for_exec,
1010
999
search_specific_files, state, source_index, target_index,
1011
1000
want_unversioned, tree):
1012
self.doing_consistency_expansion = 0
1013
1001
self.old_dirname_to_file_id = {}
1014
1002
self.new_dirname_to_file_id = {}
1015
# Are we doing a partial iter_changes?
1016
self.partial = set(['']).__ne__(search_specific_files)
1003
# Just a sentry, so that _process_entry can say that this
1004
# record is handled, but isn't interesting to process (unchanged)
1005
self.uninteresting = object()
1017
1006
# Using a list so that we can access the values and change them in
1018
1007
# nested scope. Each one is [path, file_id, entry]
1019
1008
self.last_source_parent = [None, None]
1020
1009
self.last_target_parent = [None, None]
1021
if include_unchanged is None:
1022
self.include_unchanged = False
1024
self.include_unchanged = int(include_unchanged)
1010
self.include_unchanged = include_unchanged
1025
1011
self.use_filesystem_for_exec = use_filesystem_for_exec
1026
1012
self.utf8_decode = cache_utf8._utf8_decode
1027
1013
# for all search_indexs in each path at or under each element of
1028
# search_specific_files, if the detail is relocated: add the id, and
1029
# add the relocated path as one to search if its not searched already.
1030
# If the detail is not relocated, add the id.
1014
# search_specific_files, if the detail is relocated: add the id, and add the
1015
# relocated path as one to search if its not searched already. If the
1016
# detail is not relocated, add the id.
1031
1017
self.searched_specific_files = set()
1032
# When we search exact paths without expanding downwards, we record
1034
self.searched_exact_paths = set()
1035
1018
self.search_specific_files = search_specific_files
1036
# The parents up to the root of the paths we are searching.
1037
# After all normal paths are returned, these specific items are returned.
1038
self.search_specific_file_parents = set()
1039
# The ids we've sent out in the delta.
1040
self.seen_ids = set()
1041
1019
self.state = state
1042
1020
self.current_root = None
1043
1021
self.current_root_unicode = None
1059
1037
self.current_block_pos = -1
1060
1038
self.current_dir_info = None
1061
1039
self.current_dir_list = None
1062
self._pending_consistent_entries = []
1063
1040
self.path_index = 0
1064
1041
self.root_dir_info = None
1065
1042
self.bisect_left = bisect.bisect_left
1066
1043
self.pathjoin = osutils.pathjoin
1067
1044
self.fstat = os.fstat
1068
1045
self.sha_file = osutils.sha_file
1069
if target_index != 0:
1070
# A lot of code in here depends on target_index == 0
1071
raise errors.BzrError('unsupported target index')
1073
1047
cdef _process_entry(self, entry, path_info):
1074
1048
"""Compare an entry and real disk to generate delta information.
1076
1050
:param path_info: top_relpath, basename, kind, lstat, abspath for
1077
the path of entry. If None, then the path is considered absent in
1078
the target (Perhaps we should pass in a concrete entry for this ?)
1051
the path of entry. If None, then the path is considered absent.
1052
(Perhaps we should pass in a concrete entry for this ?)
1079
1053
Basename is returned as a utf8 string because we expect this
1080
1054
tuple will be ignored, and don't want to take the time to
1082
:return: (iter_changes_result, changed). If the entry has not been
1083
handled then changed is None. Otherwise it is False if no content
1084
or metadata changes have occured, and True if any content or
1085
metadata change has occurred. If self.include_unchanged is True then
1086
if changed is not None, iter_changes_result will always be a result
1087
tuple. Otherwise, iter_changes_result is None unless changed is
1056
:return: None if the these don't match
1057
A tuple of information about the change, or
1058
the object 'uninteresting' if these match, but are
1059
basically identical.
1090
1061
cdef char target_minikind
1091
1062
cdef char source_minikind
1172
1140
if source_minikind != c'f':
1173
1141
content_change = 1
1175
# Check the sha. We can't just rely on the size as
1176
# content filtering may mean differ sizes actually
1177
# map to the same content
1178
if link_or_sha1 is None:
1180
statvalue, link_or_sha1 = \
1181
self.state._sha1_provider.stat_and_sha1(
1183
self.state._observed_sha1(entry, link_or_sha1,
1185
content_change = (link_or_sha1 != source_details[1])
1143
# If the size is the same, check the sha:
1144
if target_details[2] == source_details[2]:
1145
if link_or_sha1 is None:
1147
statvalue, link_or_sha1 = \
1148
self.state._sha1_provider.stat_and_sha1(
1150
self.state._observed_sha1(entry, link_or_sha1,
1152
content_change = (link_or_sha1 != source_details[1])
1154
# Size changed, so must be different
1186
1156
# Target details is updated at update_entry time
1187
1157
if self.use_filesystem_for_exec:
1188
1158
# We don't need S_ISREG here, because we are sure
1342
1308
(parent_id, None),
1343
1309
(self.utf8_decode(entry[0][1])[0], None),
1344
1310
(_minikind_to_kind(source_minikind), None),
1345
(source_details[3], None)), True
1311
(source_details[3], None))
1346
1312
elif _versioned_minikind(source_minikind) and target_minikind == c'r':
1347
1313
# a rename; could be a true rename, or a rename inherited from
1348
1314
# a renamed parent. TODO: handle this efficiently. Its not
1349
1315
# common case to rename dirs though, so a correct but slow
1350
1316
# implementation will do.
1351
if (not self.doing_consistency_expansion and
1352
not osutils.is_inside_any(self.searched_specific_files,
1353
target_details[1])):
1317
if not osutils.is_inside_any(self.searched_specific_files, target_details[1]):
1354
1318
self.search_specific_files.add(target_details[1])
1355
# We don't expand the specific files parents list here as
1356
# the path is absent in target and won't create a delta with
1358
1319
elif ((source_minikind == c'r' or source_minikind == c'a') and
1359
1320
(target_minikind == c'r' or target_minikind == c'a')):
1360
1321
# neither of the selected trees contain this path,
1374
1335
def iter_changes(self):
1377
cdef int _gather_result_for_consistency(self, result) except -1:
1378
"""Check a result we will yield to make sure we are consistent later.
1380
This gathers result's parents into a set to output later.
1382
:param result: A result tuple.
1384
if not self.partial or not result[0]:
1386
self.seen_ids.add(result[0])
1387
new_path = result[1][1]
1389
# Not the root and not a delete: queue up the parents of the path.
1390
self.search_specific_file_parents.update(
1391
osutils.parent_directories(new_path.encode('utf8')))
1392
# Add the root directory which parent_directories does not
1394
self.search_specific_file_parents.add('')
1397
cdef int _update_current_block(self) except -1:
1338
cdef void _update_current_block(self):
1398
1339
if (self.block_index < len(self.state._dirblocks) and
1399
1340
osutils.is_inside(self.current_root, self.state._dirblocks[self.block_index][0])):
1400
1341
self.current_block = self.state._dirblocks[self.block_index]
1461
1401
cdef char * current_dirname_c, * current_blockname_c
1462
1402
cdef int advance_entry, advance_path
1463
1403
cdef int path_handled
1404
uninteresting = self.uninteresting
1464
1405
searched_specific_files = self.searched_specific_files
1465
1406
# Are we walking a root?
1466
1407
while self.root_entries_pos < self.root_entries_len:
1467
1408
entry = self.root_entries[self.root_entries_pos]
1468
1409
self.root_entries_pos = self.root_entries_pos + 1
1469
result, changed = self._process_entry(entry, self.root_dir_info)
1470
if changed is not None:
1472
self._gather_result_for_consistency(result)
1473
if changed or self.include_unchanged:
1410
result = self._process_entry(entry, self.root_dir_info)
1411
if result is not None and result is not self.uninteresting:
1475
1413
# Have we finished the prior root, or never started one ?
1476
1414
if self.current_root is None:
1477
1415
# TODO: the pending list should be lexically sorted? the
1478
1416
# interface doesn't require it.
1480
1418
self.current_root = self.search_specific_files.pop()
1482
1420
raise StopIteration()
1421
self.current_root_unicode = self.current_root.decode('utf8')
1483
1422
self.searched_specific_files.add(self.current_root)
1484
1423
# process the entries for this containing directory: the rest will be
1485
1424
# found by their parents recursively.
1486
1425
self.root_entries = self.state._entries_for_path(self.current_root)
1487
1426
self.root_entries_len = len(self.root_entries)
1488
self.current_root_unicode = self.current_root.decode('utf8')
1489
1427
self.root_abspath = self.tree.abspath(self.current_root_unicode)
1491
1429
root_stat = os.lstat(self.root_abspath)
1852
1775
self.current_dir_info = self.dir_iterator.next()
1853
1776
self.current_dir_list = self.current_dir_info[1]
1854
except StopIteration, _:
1777
except StopIteration:
1855
1778
self.current_dir_info = None
1857
cdef object _next_consistent_entries(self):
1858
"""Grabs the next specific file parent case to consider.
1860
:return: A list of the results, each of which is as for _process_entry.
1863
while self.search_specific_file_parents:
1864
# Process the parent directories for the paths we were iterating.
1865
# Even in extremely large trees this should be modest, so currently
1866
# no attempt is made to optimise.
1867
path_utf8 = self.search_specific_file_parents.pop()
1868
if path_utf8 in self.searched_exact_paths:
1869
# We've examined this path.
1871
if osutils.is_inside_any(self.searched_specific_files, path_utf8):
1872
# We've examined this path.
1874
path_entries = self.state._entries_for_path(path_utf8)
1875
# We need either one or two entries. If the path in
1876
# self.target_index has moved (so the entry in source_index is in
1877
# 'ar') then we need to also look for the entry for this path in
1878
# self.source_index, to output the appropriate delete-or-rename.
1879
selected_entries = []
1881
for candidate_entry in path_entries:
1882
# Find entries present in target at this path:
1883
if candidate_entry[1][self.target_index][0] not in 'ar':
1885
selected_entries.append(candidate_entry)
1886
# Find entries present in source at this path:
1887
elif (self.source_index is not None and
1888
candidate_entry[1][self.source_index][0] not in 'ar'):
1890
if candidate_entry[1][self.target_index][0] == 'a':
1891
# Deleted, emit it here.
1892
selected_entries.append(candidate_entry)
1894
# renamed, emit it when we process the directory it
1896
self.search_specific_file_parents.add(
1897
candidate_entry[1][self.target_index][1])
1899
raise AssertionError(
1900
"Missing entry for specific path parent %r, %r" % (
1901
path_utf8, path_entries))
1902
path_info = self._path_info(path_utf8, path_utf8.decode('utf8'))
1903
for entry in selected_entries:
1904
if entry[0][2] in self.seen_ids:
1906
result, changed = self._process_entry(entry, path_info)
1908
raise AssertionError(
1909
"Got entry<->path mismatch for specific path "
1910
"%r entry %r path_info %r " % (
1911
path_utf8, entry, path_info))
1912
# Only include changes - we're outside the users requested
1915
self._gather_result_for_consistency(result)
1916
if (result[6][0] == 'directory' and
1917
result[6][1] != 'directory'):
1918
# This stopped being a directory, the old children have
1920
if entry[1][self.source_index][0] == 'r':
1921
# renamed, take the source path
1922
entry_path_utf8 = entry[1][self.source_index][1]
1924
entry_path_utf8 = path_utf8
1925
initial_key = (entry_path_utf8, '', '')
1926
block_index, _ = self.state._find_block_index_from_key(
1928
if block_index == 0:
1929
# The children of the root are in block index 1.
1930
block_index = block_index + 1
1931
current_block = None
1932
if block_index < len(self.state._dirblocks):
1933
current_block = self.state._dirblocks[block_index]
1934
if not osutils.is_inside(
1935
entry_path_utf8, current_block[0]):
1936
# No entries for this directory at all.
1937
current_block = None
1938
if current_block is not None:
1939
for entry in current_block[1]:
1940
if entry[1][self.source_index][0] in 'ar':
1941
# Not in the source tree, so doesn't have to be
1944
# Path of the entry itself.
1945
self.search_specific_file_parents.add(
1946
self.pathjoin(*entry[0][:2]))
1947
if changed or self.include_unchanged:
1948
results.append((result, changed))
1949
self.searched_exact_paths.add(path_utf8)
1952
cdef object _path_info(self, utf8_path, unicode_path):
1953
"""Generate path_info for unicode_path.
1955
:return: None if unicode_path does not exist, or a path_info tuple.
1957
abspath = self.tree.abspath(unicode_path)
1959
stat = os.lstat(abspath)
1961
if e.errno == errno.ENOENT:
1962
# the path does not exist.
1966
utf8_basename = utf8_path.rsplit('/', 1)[-1]
1967
dir_info = (utf8_path, utf8_basename,
1968
osutils.file_kind_from_stat_mode(stat.st_mode), stat,
1970
if dir_info[2] == 'directory':
1971
if self.tree._directory_is_tree_reference(
1973
self.root_dir_info = self.root_dir_info[:2] + \
1974
('tree-reference',) + self.root_dir_info[3:]
added
removed
bzrlib/_dirstate_helpers_c.pyx
