1931
1867
if not all_versioned:
1932
1868
raise errors.PathsNotVersionedError(specific_files)
1933
1869
# -- remove redundancy in supplied specific_files to prevent over-scanning --
1870
search_specific_files = set()
1934
1871
for path in specific_files:
1935
1872
other_specific_files = specific_files.difference(set([path]))
1936
1873
if not osutils.is_inside_any(other_specific_files, path):
1937
1874
# this is a top level path, we must check it.
1938
1875
search_specific_files.add(path)
1877
# compare source_index and target_index at or under each element of search_specific_files.
1878
# follow the following comparison table. Note that we only want to do diff operations when
1879
# the target is fdl because thats when the walkdirs logic will have exposed the pathinfo
1883
# Source | Target | disk | action
1884
# r | fdlt | | add source to search, add id path move and perform
1885
# | | | diff check on source-target
1886
# r | fdlt | a | dangling file that was present in the basis.
1888
# r | a | | add source to search
1890
# r | r | | this path is present in a non-examined tree, skip.
1891
# r | r | a | this path is present in a non-examined tree, skip.
1892
# a | fdlt | | add new id
1893
# a | fdlt | a | dangling locally added file, skip
1894
# a | a | | not present in either tree, skip
1895
# a | a | a | not present in any tree, skip
1896
# a | r | | not present in either tree at this path, skip as it
1897
# | | | may not be selected by the users list of paths.
1898
# a | r | a | not present in either tree at this path, skip as it
1899
# | | | may not be selected by the users list of paths.
1900
# fdlt | fdlt | | content in both: diff them
1901
# fdlt | fdlt | a | deleted locally, but not unversioned - show as deleted ?
1902
# fdlt | a | | unversioned: output deleted id for now
1903
# fdlt | a | a | unversioned and deleted: output deleted id
1904
# fdlt | r | | relocated in this tree, so add target to search.
1905
# | | | Dont diff, we will see an r,fd; pair when we reach
1906
# | | | this id at the other path.
1907
# fdlt | r | a | relocated in this tree, so add target to search.
1908
# | | | Dont diff, we will see an r,fd; pair when we reach
1909
# | | | this id at the other path.
1911
# for all search_indexs in each path at or under each element of
1912
# search_specific_files, if the detail is relocated: add the id, and add the
1913
# relocated path as one to search if its not searched already. If the
1914
# detail is not relocated, add the id.
1915
searched_specific_files = set()
1916
NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
1917
# Using a list so that we can access the values and change them in
1918
# nested scope. Each one is [path, file_id, entry]
1919
last_source_parent = [None, None]
1920
last_target_parent = [None, None]
1940
1922
use_filesystem_for_exec = (sys.platform != 'win32')
1941
iter_changes = self.target._iter_changes(include_unchanged,
1942
use_filesystem_for_exec, search_specific_files, state,
1943
source_index, target_index, want_unversioned, self.target)
1944
return iter_changes.iter_changes()
1924
# Just a sentry, so that _process_entry can say that this
1925
# record is handled, but isn't interesting to process (unchanged)
1926
uninteresting = object()
1929
old_dirname_to_file_id = {}
1930
new_dirname_to_file_id = {}
1931
# TODO: jam 20070516 - Avoid the _get_entry lookup overhead by
1932
# keeping a cache of directories that we have seen.
1934
def _process_entry(entry, path_info):
1935
"""Compare an entry and real disk to generate delta information.
1937
:param path_info: top_relpath, basename, kind, lstat, abspath for
1938
the path of entry. If None, then the path is considered absent.
1939
(Perhaps we should pass in a concrete entry for this ?)
1940
Basename is returned as a utf8 string because we expect this
1941
tuple will be ignored, and don't want to take the time to
1943
:return: None if these don't match
1944
A tuple of information about the change, or
1945
the object 'uninteresting' if these match, but are
1946
basically identical.
1948
if source_index is None:
1949
source_details = NULL_PARENT_DETAILS
1951
source_details = entry[1][source_index]
1952
target_details = entry[1][target_index]
1953
target_minikind = target_details[0]
1954
if path_info is not None and target_minikind in 'fdlt':
1955
assert target_index == 0
1956
link_or_sha1 = state.update_entry(entry, abspath=path_info[4],
1957
stat_value=path_info[3])
1958
# The entry may have been modified by update_entry
1959
target_details = entry[1][target_index]
1960
target_minikind = target_details[0]
1963
file_id = entry[0][2]
1964
source_minikind = source_details[0]
1965
if source_minikind in 'fdltr' and target_minikind in 'fdlt':
1966
# claimed content in both: diff
1967
# r | fdlt | | add source to search, add id path move and perform
1968
# | | | diff check on source-target
1969
# r | fdlt | a | dangling file that was present in the basis.
1971
if source_minikind in 'r':
1972
# add the source to the search path to find any children it
1973
# has. TODO ? : only add if it is a container ?
1974
if not osutils.is_inside_any(searched_specific_files,
1976
search_specific_files.add(source_details[1])
1977
# generate the old path; this is needed for stating later
1979
old_path = source_details[1]
1980
old_dirname, old_basename = os.path.split(old_path)
1981
path = pathjoin(entry[0][0], entry[0][1])
1982
old_entry = state._get_entry(source_index,
1984
# update the source details variable to be the real
1986
if old_entry == (None, None):
1987
raise errors.CorruptDirstate(state._filename,
1988
"entry '%s/%s' is considered renamed from %r"
1989
" but source does not exist\n"
1990
"entry: %s" % (entry[0][0], entry[0][1], old_path, entry))
1991
source_details = old_entry[1][source_index]
1992
source_minikind = source_details[0]
1994
old_dirname = entry[0][0]
1995
old_basename = entry[0][1]
1996
old_path = path = None
1997
if path_info is None:
1998
# the file is missing on disk, show as removed.
1999
content_change = True
2003
# source and target are both versioned and disk file is present.
2004
target_kind = path_info[2]
2005
if target_kind == 'directory':
2007
old_path = path = pathjoin(old_dirname, old_basename)
2008
new_dirname_to_file_id[path] = file_id
2009
if source_minikind != 'd':
2010
content_change = True
2012
# directories have no fingerprint
2013
content_change = False
2015
elif target_kind == 'file':
2016
if source_minikind != 'f':
2017
content_change = True
2019
# We could check the size, but we already have the
2021
content_change = (link_or_sha1 != source_details[1])
2022
# Target details is updated at update_entry time
2023
if use_filesystem_for_exec:
2024
# We don't need S_ISREG here, because we are sure
2025
# we are dealing with a file.
2026
target_exec = bool(stat.S_IEXEC & path_info[3].st_mode)
2028
target_exec = target_details[3]
2029
elif target_kind == 'symlink':
2030
if source_minikind != 'l':
2031
content_change = True
2033
content_change = (link_or_sha1 != source_details[1])
2035
elif target_kind == 'tree-reference':
2036
if source_minikind != 't':
2037
content_change = True
2039
content_change = False
2042
raise Exception, "unknown kind %s" % path_info[2]
2043
if source_minikind == 'd':
2045
old_path = path = pathjoin(old_dirname, old_basename)
2046
old_dirname_to_file_id[old_path] = file_id
2047
# parent id is the entry for the path in the target tree
2048
if old_dirname == last_source_parent[0]:
2049
source_parent_id = last_source_parent[1]
2052
source_parent_id = old_dirname_to_file_id[old_dirname]
2054
source_parent_entry = state._get_entry(source_index,
2055
path_utf8=old_dirname)
2056
source_parent_id = source_parent_entry[0][2]
2057
if source_parent_id == entry[0][2]:
2058
# This is the root, so the parent is None
2059
source_parent_id = None
2061
last_source_parent[0] = old_dirname
2062
last_source_parent[1] = source_parent_id
2063
new_dirname = entry[0][0]
2064
if new_dirname == last_target_parent[0]:
2065
target_parent_id = last_target_parent[1]
2068
target_parent_id = new_dirname_to_file_id[new_dirname]
2070
# TODO: We don't always need to do the lookup, because the
2071
# parent entry will be the same as the source entry.
2072
target_parent_entry = state._get_entry(target_index,
2073
path_utf8=new_dirname)
2074
assert target_parent_entry != (None, None), (
2075
"Could not find target parent in wt: %s\nparent of: %s"
2076
% (new_dirname, entry))
2077
target_parent_id = target_parent_entry[0][2]
2078
if target_parent_id == entry[0][2]:
2079
# This is the root, so the parent is None
2080
target_parent_id = None
2082
last_target_parent[0] = new_dirname
2083
last_target_parent[1] = target_parent_id
2085
source_exec = source_details[3]
2086
if (include_unchanged
2088
or source_parent_id != target_parent_id
2089
or old_basename != entry[0][1]
2090
or source_exec != target_exec
2092
if old_path is None:
2093
old_path = path = pathjoin(old_dirname, old_basename)
2094
old_path_u = utf8_decode(old_path)[0]
2097
old_path_u = utf8_decode(old_path)[0]
2098
if old_path == path:
2101
path_u = utf8_decode(path)[0]
2102
source_kind = _minikind_to_kind[source_minikind]
2103
return (entry[0][2],
2104
(old_path_u, path_u),
2107
(source_parent_id, target_parent_id),
2108
(utf8_decode(old_basename)[0], utf8_decode(entry[0][1])[0]),
2109
(source_kind, target_kind),
2110
(source_exec, target_exec))
2112
return uninteresting
2113
elif source_minikind in 'a' and target_minikind in 'fdlt':
2114
# looks like a new file
2115
if path_info is not None:
2116
path = pathjoin(entry[0][0], entry[0][1])
2117
# parent id is the entry for the path in the target tree
2118
# TODO: these are the same for an entire directory: cache em.
2119
parent_id = state._get_entry(target_index,
2120
path_utf8=entry[0][0])[0][2]
2121
if parent_id == entry[0][2]:
2123
if use_filesystem_for_exec:
2124
# We need S_ISREG here, because we aren't sure if this
2127
stat.S_ISREG(path_info[3].st_mode)
2128
and stat.S_IEXEC & path_info[3].st_mode)
2130
target_exec = target_details[3]
2131
return (entry[0][2],
2132
(None, utf8_decode(path)[0]),
2136
(None, utf8_decode(entry[0][1])[0]),
2137
(None, path_info[2]),
2138
(None, target_exec))
2140
# but its not on disk: we deliberately treat this as just
2141
# never-present. (Why ?! - RBC 20070224)
2143
elif source_minikind in 'fdlt' and target_minikind in 'a':
2144
# unversioned, possibly, or possibly not deleted: we dont care.
2145
# if its still on disk, *and* theres no other entry at this
2146
# path [we dont know this in this routine at the moment -
2147
# perhaps we should change this - then it would be an unknown.
2148
old_path = pathjoin(entry[0][0], entry[0][1])
2149
# parent id is the entry for the path in the target tree
2150
parent_id = state._get_entry(source_index, path_utf8=entry[0][0])[0][2]
2151
if parent_id == entry[0][2]:
2153
return (entry[0][2],
2154
(utf8_decode(old_path)[0], None),
2158
(utf8_decode(entry[0][1])[0], None),
2159
(_minikind_to_kind[source_minikind], None),
2160
(source_details[3], None))
2161
elif source_minikind in 'fdlt' and target_minikind in 'r':
2162
# a rename; could be a true rename, or a rename inherited from
2163
# a renamed parent. TODO: handle this efficiently. Its not
2164
# common case to rename dirs though, so a correct but slow
2165
# implementation will do.
2166
if not osutils.is_inside_any(searched_specific_files, target_details[1]):
2167
search_specific_files.add(target_details[1])
2168
elif source_minikind in 'ra' and target_minikind in 'ra':
2169
# neither of the selected trees contain this file,
2170
# so skip over it. This is not currently directly tested, but
2171
# is indirectly via test_too_much.TestCommands.test_conflicts.
2174
raise AssertionError("don't know how to compare "
2175
"source_minikind=%r, target_minikind=%r"
2176
% (source_minikind, target_minikind))
2177
## import pdb;pdb.set_trace()
2180
while search_specific_files:
2181
# TODO: the pending list should be lexically sorted? the
2182
# interface doesn't require it.
2183
current_root = search_specific_files.pop()
2184
current_root_unicode = current_root.decode('utf8')
2185
searched_specific_files.add(current_root)
2186
# process the entries for this containing directory: the rest will be
2187
# found by their parents recursively.
2188
root_entries = _entries_for_path(current_root)
2189
root_abspath = self.target.abspath(current_root_unicode)
2191
root_stat = os.lstat(root_abspath)
2193
if e.errno == errno.ENOENT:
2194
# the path does not exist: let _process_entry know that.
2195
root_dir_info = None
2197
# some other random error: hand it up.
2200
root_dir_info = ('', current_root,
2201
osutils.file_kind_from_stat_mode(root_stat.st_mode), root_stat,
2203
if root_dir_info[2] == 'directory':
2204
if self.target._directory_is_tree_reference(
2205
current_root.decode('utf8')):
2206
root_dir_info = root_dir_info[:2] + \
2207
('tree-reference',) + root_dir_info[3:]
2209
if not root_entries and not root_dir_info:
2210
# this specified path is not present at all, skip it.
2212
path_handled = False
2213
for entry in root_entries:
2214
result = _process_entry(entry, root_dir_info)
2215
if result is not None:
2217
if result is not uninteresting:
2219
if want_unversioned and not path_handled and root_dir_info:
2220
new_executable = bool(
2221
stat.S_ISREG(root_dir_info[3].st_mode)
2222
and stat.S_IEXEC & root_dir_info[3].st_mode)
2224
(None, current_root_unicode),
2228
(None, splitpath(current_root_unicode)[-1]),
2229
(None, root_dir_info[2]),
2230
(None, new_executable)
2232
initial_key = (current_root, '', '')
2233
block_index, _ = state._find_block_index_from_key(initial_key)
2234
if block_index == 0:
2235
# we have processed the total root already, but because the
2236
# initial key matched it we should skip it here.
2238
if root_dir_info and root_dir_info[2] == 'tree-reference':
2239
current_dir_info = None
2241
dir_iterator = osutils._walkdirs_utf8(root_abspath, prefix=current_root)
2243
current_dir_info = dir_iterator.next()
2245
# on win32, python2.4 has e.errno == ERROR_DIRECTORY, but
2246
# python 2.5 has e.errno == EINVAL,
2247
# and e.winerror == ERROR_DIRECTORY
2248
e_winerror = getattr(e, 'winerror', None)
2249
win_errors = (ERROR_DIRECTORY, ERROR_PATH_NOT_FOUND)
2250
# there may be directories in the inventory even though
2251
# this path is not a file on disk: so mark it as end of
2253
if e.errno in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL):
2254
current_dir_info = None
2255
elif (sys.platform == 'win32'
2256
and (e.errno in win_errors
2257
or e_winerror in win_errors)):
2258
current_dir_info = None
2262
if current_dir_info[0][0] == '':
2263
# remove .bzr from iteration
2264
bzr_index = bisect_left(current_dir_info[1], ('.bzr',))
2265
assert current_dir_info[1][bzr_index][0] == '.bzr'
2266
del current_dir_info[1][bzr_index]
2267
# walk until both the directory listing and the versioned metadata
2269
if (block_index < len(state._dirblocks) and
2270
osutils.is_inside(current_root, state._dirblocks[block_index][0])):
2271
current_block = state._dirblocks[block_index]
2273
current_block = None
2274
while (current_dir_info is not None or
2275
current_block is not None):
2276
if (current_dir_info and current_block
2277
and current_dir_info[0][0] != current_block[0]):
2278
if cmp_by_dirs(current_dir_info[0][0], current_block[0]) < 0:
2279
# filesystem data refers to paths not covered by the dirblock.
2280
# this has two possibilities:
2281
# A) it is versioned but empty, so there is no block for it
2282
# B) it is not versioned.
2284
# if (A) then we need to recurse into it to check for
2285
# new unknown files or directories.
2286
# if (B) then we should ignore it, because we don't
2287
# recurse into unknown directories.
2289
while path_index < len(current_dir_info[1]):
2290
current_path_info = current_dir_info[1][path_index]
2291
if want_unversioned:
2292
if current_path_info[2] == 'directory':
2293
if self.target._directory_is_tree_reference(
2294
current_path_info[0].decode('utf8')):
2295
current_path_info = current_path_info[:2] + \
2296
('tree-reference',) + current_path_info[3:]
2297
new_executable = bool(
2298
stat.S_ISREG(current_path_info[3].st_mode)
2299
and stat.S_IEXEC & current_path_info[3].st_mode)
2301
(None, utf8_decode(current_path_info[0])[0]),
2305
(None, utf8_decode(current_path_info[1])[0]),
2306
(None, current_path_info[2]),
2307
(None, new_executable))
2308
# dont descend into this unversioned path if it is
2310
if current_path_info[2] in ('directory',
2312
del current_dir_info[1][path_index]
2316
# This dir info has been handled, go to the next
2318
current_dir_info = dir_iterator.next()
2319
except StopIteration:
2320
current_dir_info = None
2322
# We have a dirblock entry for this location, but there
2323
# is no filesystem path for this. This is most likely
2324
# because a directory was removed from the disk.
2325
# We don't have to report the missing directory,
2326
# because that should have already been handled, but we
2327
# need to handle all of the files that are contained
2329
for current_entry in current_block[1]:
2330
# entry referring to file not present on disk.
2331
# advance the entry only, after processing.
2332
result = _process_entry(current_entry, None)
2333
if result is not None:
2334
if result is not uninteresting:
2337
if (block_index < len(state._dirblocks) and
2338
osutils.is_inside(current_root,
2339
state._dirblocks[block_index][0])):
2340
current_block = state._dirblocks[block_index]
2342
current_block = None
2345
if current_block and entry_index < len(current_block[1]):
2346
current_entry = current_block[1][entry_index]
2348
current_entry = None
2349
advance_entry = True
2351
if current_dir_info and path_index < len(current_dir_info[1]):
2352
current_path_info = current_dir_info[1][path_index]
2353
if current_path_info[2] == 'directory':
2354
if self.target._directory_is_tree_reference(
2355
current_path_info[0].decode('utf8')):
2356
current_path_info = current_path_info[:2] + \
2357
('tree-reference',) + current_path_info[3:]
2359
current_path_info = None
2361
path_handled = False
2362
while (current_entry is not None or
2363
current_path_info is not None):
2364
if current_entry is None:
2365
# the check for path_handled when the path is adnvaced
2366
# will yield this path if needed.
2368
elif current_path_info is None:
2369
# no path is fine: the per entry code will handle it.
2370
result = _process_entry(current_entry, current_path_info)
2371
if result is not None:
2372
if result is not uninteresting:
2374
elif (current_entry[0][1] != current_path_info[1]
2375
or current_entry[1][target_index][0] in 'ar'):
2376
# The current path on disk doesn't match the dirblock
2377
# record. Either the dirblock is marked as absent, or
2378
# the file on disk is not present at all in the
2379
# dirblock. Either way, report about the dirblock
2380
# entry, and let other code handle the filesystem one.
2382
# Compare the basename for these files to determine
2384
if current_path_info[1] < current_entry[0][1]:
2385
# extra file on disk: pass for now, but only
2386
# increment the path, not the entry
2387
advance_entry = False
2389
# entry referring to file not present on disk.
2390
# advance the entry only, after processing.
2391
result = _process_entry(current_entry, None)
2392
if result is not None:
2393
if result is not uninteresting:
2395
advance_path = False
2397
result = _process_entry(current_entry, current_path_info)
2398
if result is not None:
2400
if result is not uninteresting:
2402
if advance_entry and current_entry is not None:
2404
if entry_index < len(current_block[1]):
2405
current_entry = current_block[1][entry_index]
2407
current_entry = None
2409
advance_entry = True # reset the advance flaga
2410
if advance_path and current_path_info is not None:
2411
if not path_handled:
2412
# unversioned in all regards
2413
if want_unversioned:
2414
new_executable = bool(
2415
stat.S_ISREG(current_path_info[3].st_mode)
2416
and stat.S_IEXEC & current_path_info[3].st_mode)
2418
(None, utf8_decode(current_path_info[0])[0]),
2422
(None, utf8_decode(current_path_info[1])[0]),
2423
(None, current_path_info[2]),
2424
(None, new_executable))
2425
# dont descend into this unversioned path if it is
2427
if current_path_info[2] in ('directory'):
2428
del current_dir_info[1][path_index]
2430
# dont descend the disk iterator into any tree
2432
if current_path_info[2] == 'tree-reference':
2433
del current_dir_info[1][path_index]
2436
if path_index < len(current_dir_info[1]):
2437
current_path_info = current_dir_info[1][path_index]
2438
if current_path_info[2] == 'directory':
2439
if self.target._directory_is_tree_reference(
2440
current_path_info[0].decode('utf8')):
2441
current_path_info = current_path_info[:2] + \
2442
('tree-reference',) + current_path_info[3:]
2444
current_path_info = None
2445
path_handled = False
2447
advance_path = True # reset the advance flagg.
2448
if current_block is not None:
2450
if (block_index < len(state._dirblocks) and
2451
osutils.is_inside(current_root, state._dirblocks[block_index][0])):
2452
current_block = state._dirblocks[block_index]
2454
current_block = None
2455
if current_dir_info is not None:
2457
current_dir_info = dir_iterator.next()
2458
except StopIteration:
2459
current_dir_info = None
1947
2463
def is_compatible(source, target):
added
removed
bzrlib/workingtree_4.py
