287
288
if not PyString_CheckExact(path2):
288
289
raise TypeError("'path2' must be a plain string, not %s: %r"
289
290
% (type(path2), path2))
290
return _cmp_path_by_dirblock(PyString_AsString(path1),
291
PyString_Size(path1),
292
PyString_AsString(path2),
293
PyString_Size(path2))
296
cdef int _cmp_path_by_dirblock(char *path1, int path1_len,
297
char *path2, int path2_len):
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
298
299
"""Compare two paths by what directory they are in.
300
see ``_cmp_path_by_dirblock_c`` for details.
301
see ``_cmp_path_by_dirblock`` for details.
302
303
cdef char *dirname1
303
304
cdef int dirname1_len
959
965
cdef class ProcessEntryC:
967
cdef int doing_consistency_expansion
961
968
cdef object old_dirname_to_file_id # dict
962
969
cdef object new_dirname_to_file_id # dict
963
cdef readonly object uninteresting
964
970
cdef object last_source_parent
965
971
cdef object last_target_parent
966
cdef object include_unchanged
972
cdef int include_unchanged
967
974
cdef object use_filesystem_for_exec
968
975
cdef object utf8_decode
969
976
cdef readonly object searched_specific_files
977
cdef readonly object searched_exact_paths
970
978
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
971
982
cdef object state
972
983
# Current iteration variables:
973
984
cdef object current_root
985
996
cdef object current_block_list
986
997
cdef object current_dir_info
987
998
cdef object current_dir_list
999
cdef object _pending_consistent_entries # list
988
1000
cdef int path_index
989
1001
cdef object root_dir_info
990
1002
cdef object bisect_left
991
1003
cdef object pathjoin
992
1004
cdef object fstat
1005
# A set of the ids we've output when doing partial output.
1006
cdef object seen_ids
993
1007
cdef object sha_file
995
1009
def __init__(self, include_unchanged, use_filesystem_for_exec,
996
1010
search_specific_files, state, source_index, target_index,
997
1011
want_unversioned, tree):
1012
self.doing_consistency_expansion = 0
998
1013
self.old_dirname_to_file_id = {}
999
1014
self.new_dirname_to_file_id = {}
1000
# Just a sentry, so that _process_entry can say that this
1001
# record is handled, but isn't interesting to process (unchanged)
1002
self.uninteresting = object()
1015
# Are we doing a partial iter_changes?
1016
self.partial = set(['']).__ne__(search_specific_files)
1003
1017
# Using a list so that we can access the values and change them in
1004
1018
# nested scope. Each one is [path, file_id, entry]
1005
1019
self.last_source_parent = [None, None]
1006
1020
self.last_target_parent = [None, None]
1007
self.include_unchanged = include_unchanged
1021
if include_unchanged is None:
1022
self.include_unchanged = False
1024
self.include_unchanged = int(include_unchanged)
1008
1025
self.use_filesystem_for_exec = use_filesystem_for_exec
1009
1026
self.utf8_decode = cache_utf8._utf8_decode
1010
1027
# for all search_indexs in each path at or under each element of
1011
# search_specific_files, if the detail is relocated: add the id, and add the
1012
# relocated path as one to search if its not searched already. If the
1013
# detail is not relocated, add the id.
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
1031
self.searched_specific_files = set()
1032
# When we search exact paths without expanding downwards, we record
1034
self.searched_exact_paths = set()
1015
1035
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()
1016
1041
self.state = state
1017
1042
self.current_root = None
1018
1043
self.current_root_unicode = None
1034
1059
self.current_block_pos = -1
1035
1060
self.current_dir_info = None
1036
1061
self.current_dir_list = None
1062
self._pending_consistent_entries = []
1037
1063
self.path_index = 0
1038
1064
self.root_dir_info = None
1039
1065
self.bisect_left = bisect.bisect_left
1040
1066
self.pathjoin = osutils.pathjoin
1041
1067
self.fstat = os.fstat
1042
1068
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')
1044
1073
cdef _process_entry(self, entry, path_info):
1045
1074
"""Compare an entry and real disk to generate delta information.
1047
1076
:param path_info: top_relpath, basename, kind, lstat, abspath for
1048
the path of entry. If None, then the path is considered absent.
1049
(Perhaps we should pass in a concrete entry for this ?)
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 ?)
1050
1079
Basename is returned as a utf8 string because we expect this
1051
1080
tuple will be ignored, and don't want to take the time to
1053
:return: None if the these don't match
1054
A tuple of information about the change, or
1055
the object 'uninteresting' if these match, but are
1056
basically identical.
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
1058
1090
cdef char target_minikind
1059
1091
cdef char source_minikind
1136
1172
if source_minikind != c'f':
1137
1173
content_change = 1
1139
# If the size is the same, check the sha:
1140
if target_details[2] == source_details[2]:
1141
if link_or_sha1 is None:
1143
file_obj = file(path_info[4], 'rb')
1145
# XXX: TODO: Use lower level file IO rather
1146
# than python objects for sha-misses.
1147
statvalue = self.fstat(file_obj.fileno())
1148
link_or_sha1 = self.sha_file(file_obj)
1151
self.state._observed_sha1(entry, link_or_sha1,
1153
content_change = (link_or_sha1 != source_details[1])
1155
# Size changed, so must be different
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])
1157
1186
# Target details is updated at update_entry time
1158
1187
if self.use_filesystem_for_exec:
1159
1188
# We don't need S_ISREG here, because we are sure
1246
1281
(source_parent_id, target_parent_id),
1247
1282
(self.utf8_decode(old_basename)[0], self.utf8_decode(entry[0][1])[0]),
1248
1283
(source_kind, target_kind),
1249
(source_exec, target_exec))
1251
return self.uninteresting
1284
(source_exec, target_exec)), changed
1252
1285
elif source_minikind == c'a' and _versioned_minikind(target_minikind):
1253
1286
# looks like a new file
1254
1287
path = self.pathjoin(entry[0][0], entry[0][1])
1255
1288
# parent id is the entry for the path in the target tree
1256
1289
# TODO: these are the same for an entire directory: cache em.
1257
parent_id = self.state._get_entry(self.target_index,
1258
path_utf8=entry[0][0])[0][2]
1290
parent_entry = self.state._get_entry(self.target_index,
1291
path_utf8=entry[0][0])
1292
if parent_entry is None:
1293
raise errors.DirstateCorrupt(self.state,
1294
"We could not find the parent entry in index %d"
1295
" for the entry: %s"
1296
% (self.target_index, entry[0]))
1297
parent_id = parent_entry[0][2]
1259
1298
if parent_id == entry[0][2]:
1260
1299
parent_id = None
1261
1300
if path_info is not None:
1303
1342
(parent_id, None),
1304
1343
(self.utf8_decode(entry[0][1])[0], None),
1305
1344
(_minikind_to_kind(source_minikind), None),
1306
(source_details[3], None))
1345
(source_details[3], None)), True
1307
1346
elif _versioned_minikind(source_minikind) and target_minikind == c'r':
1308
1347
# a rename; could be a true rename, or a rename inherited from
1309
1348
# a renamed parent. TODO: handle this efficiently. Its not
1310
1349
# common case to rename dirs though, so a correct but slow
1311
1350
# implementation will do.
1312
if not osutils.is_inside_any(self.searched_specific_files, target_details[1]):
1351
if (not self.doing_consistency_expansion and
1352
not osutils.is_inside_any(self.searched_specific_files,
1353
target_details[1])):
1313
1354
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
1314
1358
elif ((source_minikind == c'r' or source_minikind == c'a') and
1315
1359
(target_minikind == c'r' or target_minikind == c'a')):
1316
1360
# neither of the selected trees contain this path,
1330
1374
def iter_changes(self):
1333
cdef void _update_current_block(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:
1334
1398
if (self.block_index < len(self.state._dirblocks) and
1335
1399
osutils.is_inside(self.current_root, self.state._dirblocks[self.block_index][0])):
1336
1400
self.current_block = self.state._dirblocks[self.block_index]
1396
1461
cdef char * current_dirname_c, * current_blockname_c
1397
1462
cdef int advance_entry, advance_path
1398
1463
cdef int path_handled
1399
uninteresting = self.uninteresting
1400
1464
searched_specific_files = self.searched_specific_files
1401
1465
# Are we walking a root?
1402
1466
while self.root_entries_pos < self.root_entries_len:
1403
1467
entry = self.root_entries[self.root_entries_pos]
1404
1468
self.root_entries_pos = self.root_entries_pos + 1
1405
result = self._process_entry(entry, self.root_dir_info)
1406
if result is not None and result is not self.uninteresting:
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:
1408
1475
# Have we finished the prior root, or never started one ?
1409
1476
if self.current_root is None:
1410
1477
# TODO: the pending list should be lexically sorted? the
1695
1774
# entry referring to file not present on disk.
1696
1775
# advance the entry only, after processing.
1697
result = self._process_entry(current_entry, None)
1698
if result is not None:
1699
if result is self.uninteresting:
1776
result, changed = self._process_entry(current_entry,
1701
1778
advance_path = 0
1703
1780
# paths are the same,and the dirstate entry is not
1704
1781
# absent or renamed.
1705
result = self._process_entry(current_entry, current_path_info)
1706
if result is not None:
1782
result, changed = self._process_entry(current_entry,
1784
if changed is not None:
1707
1785
path_handled = -1
1708
if result is self.uninteresting:
1786
if not changed and not self.include_unchanged:
1710
1788
# >- loop control starts here:
1712
1790
if advance_entry and current_entry is not None:
1771
1853
self.current_dir_list = self.current_dir_info[1]
1772
1854
except StopIteration:
1773
1855
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_pyx.pyx
