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(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):
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
299
299
"""Compare two paths by what directory they are in.
301
see ``_cmp_path_by_dirblock_c`` for details.
301
see ``_cmp_path_by_dirblock`` for details.
303
303
cdef char *dirname1
304
304
cdef int dirname1_len
962
965
cdef class ProcessEntryC:
967
cdef int doing_consistency_expansion
964
968
cdef object old_dirname_to_file_id # dict
965
969
cdef object new_dirname_to_file_id # dict
966
cdef readonly object uninteresting
967
970
cdef object last_source_parent
968
971
cdef object last_target_parent
969
cdef object include_unchanged
972
cdef int include_unchanged
970
974
cdef object use_filesystem_for_exec
971
975
cdef object utf8_decode
972
976
cdef readonly object searched_specific_files
977
cdef readonly object searched_exact_paths
973
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
974
982
cdef object state
975
983
# Current iteration variables:
976
984
cdef object current_root
988
996
cdef object current_block_list
989
997
cdef object current_dir_info
990
998
cdef object current_dir_list
999
cdef object _pending_consistent_entries # list
991
1000
cdef int path_index
992
1001
cdef object root_dir_info
993
1002
cdef object bisect_left
994
1003
cdef object pathjoin
995
1004
cdef object fstat
1005
# A set of the ids we've output when doing partial output.
1006
cdef object seen_ids
996
1007
cdef object sha_file
998
1009
def __init__(self, include_unchanged, use_filesystem_for_exec,
999
1010
search_specific_files, state, source_index, target_index,
1000
1011
want_unversioned, tree):
1012
self.doing_consistency_expansion = 0
1001
1013
self.old_dirname_to_file_id = {}
1002
1014
self.new_dirname_to_file_id = {}
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()
1015
# Are we doing a partial iter_changes?
1016
self.partial = set(['']).__ne__(search_specific_files)
1006
1017
# Using a list so that we can access the values and change them in
1007
1018
# nested scope. Each one is [path, file_id, entry]
1008
1019
self.last_source_parent = [None, None]
1009
1020
self.last_target_parent = [None, None]
1010
self.include_unchanged = include_unchanged
1021
if include_unchanged is None:
1022
self.include_unchanged = False
1024
self.include_unchanged = int(include_unchanged)
1011
1025
self.use_filesystem_for_exec = use_filesystem_for_exec
1012
1026
self.utf8_decode = cache_utf8._utf8_decode
1013
1027
# for all search_indexs in each path at or under each element of
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.
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.
1017
1031
self.searched_specific_files = set()
1032
# When we search exact paths without expanding downwards, we record
1034
self.searched_exact_paths = set()
1018
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()
1019
1041
self.state = state
1020
1042
self.current_root = None
1021
1043
self.current_root_unicode = None
1037
1059
self.current_block_pos = -1
1038
1060
self.current_dir_info = None
1039
1061
self.current_dir_list = None
1062
self._pending_consistent_entries = []
1040
1063
self.path_index = 0
1041
1064
self.root_dir_info = None
1042
1065
self.bisect_left = bisect.bisect_left
1043
1066
self.pathjoin = osutils.pathjoin
1044
1067
self.fstat = os.fstat
1045
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')
1047
1073
cdef _process_entry(self, entry, path_info):
1048
1074
"""Compare an entry and real disk to generate delta information.
1050
1076
:param path_info: top_relpath, basename, kind, lstat, abspath for
1051
the path of entry. If None, then the path is considered absent.
1052
(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 ?)
1053
1079
Basename is returned as a utf8 string because we expect this
1054
1080
tuple will be ignored, and don't want to take the time to
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.
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
1061
1090
cdef char target_minikind
1062
1091
cdef char source_minikind
1306
1342
(parent_id, None),
1307
1343
(self.utf8_decode(entry[0][1])[0], None),
1308
1344
(_minikind_to_kind(source_minikind), None),
1309
(source_details[3], None))
1345
(source_details[3], None)), True
1310
1346
elif _versioned_minikind(source_minikind) and target_minikind == c'r':
1311
1347
# a rename; could be a true rename, or a rename inherited from
1312
1348
# a renamed parent. TODO: handle this efficiently. Its not
1313
1349
# common case to rename dirs though, so a correct but slow
1314
1350
# implementation will do.
1315
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])):
1316
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
1317
1358
elif ((source_minikind == c'r' or source_minikind == c'a') and
1318
1359
(target_minikind == c'r' or target_minikind == c'a')):
1319
1360
# neither of the selected trees contain this path,
1333
1374
def iter_changes(self):
1336
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:
1337
1398
if (self.block_index < len(self.state._dirblocks) and
1338
1399
osutils.is_inside(self.current_root, self.state._dirblocks[self.block_index][0])):
1339
1400
self.current_block = self.state._dirblocks[self.block_index]
1399
1461
cdef char * current_dirname_c, * current_blockname_c
1400
1462
cdef int advance_entry, advance_path
1401
1463
cdef int path_handled
1402
uninteresting = self.uninteresting
1403
1464
searched_specific_files = self.searched_specific_files
1404
1465
# Are we walking a root?
1405
1466
while self.root_entries_pos < self.root_entries_len:
1406
1467
entry = self.root_entries[self.root_entries_pos]
1407
1468
self.root_entries_pos = self.root_entries_pos + 1
1408
result = self._process_entry(entry, self.root_dir_info)
1409
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:
1411
1475
# Have we finished the prior root, or never started one ?
1412
1476
if self.current_root is None:
1413
1477
# TODO: the pending list should be lexically sorted? the
1414
1478
# interface doesn't require it.
1416
1480
self.current_root = self.search_specific_files.pop()
1418
1482
raise StopIteration()
1419
self.current_root_unicode = self.current_root.decode('utf8')
1420
1483
self.searched_specific_files.add(self.current_root)
1421
1484
# process the entries for this containing directory: the rest will be
1422
1485
# found by their parents recursively.
1423
1486
self.root_entries = self.state._entries_for_path(self.current_root)
1424
1487
self.root_entries_len = len(self.root_entries)
1488
self.current_root_unicode = self.current_root.decode('utf8')
1425
1489
self.root_abspath = self.tree.abspath(self.current_root_unicode)
1427
1491
root_stat = os.lstat(self.root_abspath)
1773
1852
self.current_dir_info = self.dir_iterator.next()
1774
1853
self.current_dir_list = self.current_dir_info[1]
1775
except StopIteration:
1854
except StopIteration, _:
1776
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
