2102
1918
if not found_versioned:
2103
1919
# none of the indexes was not 'absent' at all ids for this
2105
not_versioned.append(path)
2106
if len(not_versioned) > 0:
2107
raise errors.PathsNotVersionedError(not_versioned)
1921
all_versioned = False
1923
if not all_versioned:
1924
raise errors.PathsNotVersionedError(specific_files)
2108
1925
# -- remove redundancy in supplied specific_files to prevent over-scanning --
2109
search_specific_files = osutils.minimum_path_selection(specific_files)
1926
search_specific_files = set()
1927
for path in specific_files:
1928
other_specific_files = specific_files.difference(set([path]))
1929
if not osutils.is_inside_any(other_specific_files, path):
1930
# this is a top level path, we must check it.
1931
search_specific_files.add(path)
1933
# compare source_index and target_index at or under each element of search_specific_files.
1934
# follow the following comparison table. Note that we only want to do diff operations when
1935
# the target is fdl because thats when the walkdirs logic will have exposed the pathinfo
1939
# Source | Target | disk | action
1940
# r | fdlt | | add source to search, add id path move and perform
1941
# | | | diff check on source-target
1942
# r | fdlt | a | dangling file that was present in the basis.
1944
# r | a | | add source to search
1946
# r | r | | this path is present in a non-examined tree, skip.
1947
# r | r | a | this path is present in a non-examined tree, skip.
1948
# a | fdlt | | add new id
1949
# a | fdlt | a | dangling locally added file, skip
1950
# a | a | | not present in either tree, skip
1951
# a | a | a | not present in any tree, skip
1952
# a | r | | not present in either tree at this path, skip as it
1953
# | | | may not be selected by the users list of paths.
1954
# a | r | a | not present in either tree at this path, skip as it
1955
# | | | may not be selected by the users list of paths.
1956
# fdlt | fdlt | | content in both: diff them
1957
# fdlt | fdlt | a | deleted locally, but not unversioned - show as deleted ?
1958
# fdlt | a | | unversioned: output deleted id for now
1959
# fdlt | a | a | unversioned and deleted: output deleted id
1960
# fdlt | r | | relocated in this tree, so add target to search.
1961
# | | | Dont diff, we will see an r,fd; pair when we reach
1962
# | | | this id at the other path.
1963
# fdlt | r | a | relocated in this tree, so add target to search.
1964
# | | | Dont diff, we will see an r,fd; pair when we reach
1965
# | | | this id at the other path.
1967
# for all search_indexs in each path at or under each element of
1968
# search_specific_files, if the detail is relocated: add the id, and add the
1969
# relocated path as one to search if its not searched already. If the
1970
# detail is not relocated, add the id.
1971
searched_specific_files = set()
1972
NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
1973
# Using a list so that we can access the values and change them in
1974
# nested scope. Each one is [path, file_id, entry]
1975
last_source_parent = [None, None]
1976
last_target_parent = [None, None]
2111
1978
use_filesystem_for_exec = (sys.platform != 'win32')
2112
iter_changes = self.target._iter_changes(include_unchanged,
2113
use_filesystem_for_exec, search_specific_files, state,
2114
source_index, target_index, want_unversioned, self.target)
2115
return iter_changes.iter_changes()
1980
# Just a sentry, so that _process_entry can say that this
1981
# record is handled, but isn't interesting to process (unchanged)
1982
uninteresting = object()
1984
old_dirname_to_file_id = {}
1985
new_dirname_to_file_id = {}
1986
# TODO: jam 20070516 - Avoid the _get_entry lookup overhead by
1987
# keeping a cache of directories that we have seen.
1989
def _process_entry(entry, path_info):
1990
"""Compare an entry and real disk to generate delta information.
1992
:param path_info: top_relpath, basename, kind, lstat, abspath for
1993
the path of entry. If None, then the path is considered absent.
1994
(Perhaps we should pass in a concrete entry for this ?)
1995
Basename is returned as a utf8 string because we expect this
1996
tuple will be ignored, and don't want to take the time to
1998
:return: None if these don't match
1999
A tuple of information about the change, or
2000
the object 'uninteresting' if these match, but are
2001
basically identical.
2003
if source_index is None:
2004
source_details = NULL_PARENT_DETAILS
2006
source_details = entry[1][source_index]
2007
target_details = entry[1][target_index]
2008
target_minikind = target_details[0]
2009
if path_info is not None and target_minikind in 'fdlt':
2010
if not (target_index == 0):
2011
raise AssertionError()
2012
link_or_sha1 = state.update_entry(entry, abspath=path_info[4],
2013
stat_value=path_info[3])
2014
# The entry may have been modified by update_entry
2015
target_details = entry[1][target_index]
2016
target_minikind = target_details[0]
2019
file_id = entry[0][2]
2020
source_minikind = source_details[0]
2021
if source_minikind in 'fdltr' and target_minikind in 'fdlt':
2022
# claimed content in both: diff
2023
# r | fdlt | | add source to search, add id path move and perform
2024
# | | | diff check on source-target
2025
# r | fdlt | a | dangling file that was present in the basis.
2027
if source_minikind in 'r':
2028
# add the source to the search path to find any children it
2029
# has. TODO ? : only add if it is a container ?
2030
if not osutils.is_inside_any(searched_specific_files,
2032
search_specific_files.add(source_details[1])
2033
# generate the old path; this is needed for stating later
2035
old_path = source_details[1]
2036
old_dirname, old_basename = os.path.split(old_path)
2037
path = pathjoin(entry[0][0], entry[0][1])
2038
old_entry = state._get_entry(source_index,
2040
# update the source details variable to be the real
2042
if old_entry == (None, None):
2043
raise errors.CorruptDirstate(state._filename,
2044
"entry '%s/%s' is considered renamed from %r"
2045
" but source does not exist\n"
2046
"entry: %s" % (entry[0][0], entry[0][1], old_path, entry))
2047
source_details = old_entry[1][source_index]
2048
source_minikind = source_details[0]
2050
old_dirname = entry[0][0]
2051
old_basename = entry[0][1]
2052
old_path = path = None
2053
if path_info is None:
2054
# the file is missing on disk, show as removed.
2055
content_change = True
2059
# source and target are both versioned and disk file is present.
2060
target_kind = path_info[2]
2061
if target_kind == 'directory':
2063
old_path = path = pathjoin(old_dirname, old_basename)
2064
new_dirname_to_file_id[path] = file_id
2065
if source_minikind != 'd':
2066
content_change = True
2068
# directories have no fingerprint
2069
content_change = False
2071
elif target_kind == 'file':
2072
if source_minikind != 'f':
2073
content_change = True
2075
# We could check the size, but we already have the
2077
content_change = (link_or_sha1 != source_details[1])
2078
# Target details is updated at update_entry time
2079
if use_filesystem_for_exec:
2080
# We don't need S_ISREG here, because we are sure
2081
# we are dealing with a file.
2082
target_exec = bool(stat.S_IEXEC & path_info[3].st_mode)
2084
target_exec = target_details[3]
2085
elif target_kind == 'symlink':
2086
if source_minikind != 'l':
2087
content_change = True
2089
content_change = (link_or_sha1 != source_details[1])
2091
elif target_kind == 'tree-reference':
2092
if source_minikind != 't':
2093
content_change = True
2095
content_change = False
2098
raise Exception, "unknown kind %s" % path_info[2]
2099
if source_minikind == 'd':
2101
old_path = path = pathjoin(old_dirname, old_basename)
2102
old_dirname_to_file_id[old_path] = file_id
2103
# parent id is the entry for the path in the target tree
2104
if old_dirname == last_source_parent[0]:
2105
source_parent_id = last_source_parent[1]
2108
source_parent_id = old_dirname_to_file_id[old_dirname]
2110
source_parent_entry = state._get_entry(source_index,
2111
path_utf8=old_dirname)
2112
source_parent_id = source_parent_entry[0][2]
2113
if source_parent_id == entry[0][2]:
2114
# This is the root, so the parent is None
2115
source_parent_id = None
2117
last_source_parent[0] = old_dirname
2118
last_source_parent[1] = source_parent_id
2119
new_dirname = entry[0][0]
2120
if new_dirname == last_target_parent[0]:
2121
target_parent_id = last_target_parent[1]
2124
target_parent_id = new_dirname_to_file_id[new_dirname]
2126
# TODO: We don't always need to do the lookup, because the
2127
# parent entry will be the same as the source entry.
2128
target_parent_entry = state._get_entry(target_index,
2129
path_utf8=new_dirname)
2130
if target_parent_entry == (None, None):
2131
raise AssertionError(
2132
"Could not find target parent in wt: %s\nparent of: %s"
2133
% (new_dirname, entry))
2134
target_parent_id = target_parent_entry[0][2]
2135
if target_parent_id == entry[0][2]:
2136
# This is the root, so the parent is None
2137
target_parent_id = None
2139
last_target_parent[0] = new_dirname
2140
last_target_parent[1] = target_parent_id
2142
source_exec = source_details[3]
2143
if (include_unchanged
2145
or source_parent_id != target_parent_id
2146
or old_basename != entry[0][1]
2147
or source_exec != target_exec
2149
if old_path is None:
2150
old_path = path = pathjoin(old_dirname, old_basename)
2151
old_path_u = utf8_decode(old_path)[0]
2154
old_path_u = utf8_decode(old_path)[0]
2155
if old_path == path:
2158
path_u = utf8_decode(path)[0]
2159
source_kind = _minikind_to_kind[source_minikind]
2160
return (entry[0][2],
2161
(old_path_u, path_u),
2164
(source_parent_id, target_parent_id),
2165
(utf8_decode(old_basename)[0], utf8_decode(entry[0][1])[0]),
2166
(source_kind, target_kind),
2167
(source_exec, target_exec))
2169
return uninteresting
2170
elif source_minikind in 'a' and target_minikind in 'fdlt':
2171
# looks like a new file
2172
path = pathjoin(entry[0][0], entry[0][1])
2173
# parent id is the entry for the path in the target tree
2174
# TODO: these are the same for an entire directory: cache em.
2175
parent_id = state._get_entry(target_index,
2176
path_utf8=entry[0][0])[0][2]
2177
if parent_id == entry[0][2]:
2179
if path_info is not None:
2181
if use_filesystem_for_exec:
2182
# We need S_ISREG here, because we aren't sure if this
2185
stat.S_ISREG(path_info[3].st_mode)
2186
and stat.S_IEXEC & path_info[3].st_mode)
2188
target_exec = target_details[3]
2189
return (entry[0][2],
2190
(None, utf8_decode(path)[0]),
2194
(None, utf8_decode(entry[0][1])[0]),
2195
(None, path_info[2]),
2196
(None, target_exec))
2198
# Its a missing file, report it as such.
2199
return (entry[0][2],
2200
(None, utf8_decode(path)[0]),
2204
(None, utf8_decode(entry[0][1])[0]),
2207
elif source_minikind in 'fdlt' and target_minikind in 'a':
2208
# unversioned, possibly, or possibly not deleted: we dont care.
2209
# if its still on disk, *and* theres no other entry at this
2210
# path [we dont know this in this routine at the moment -
2211
# perhaps we should change this - then it would be an unknown.
2212
old_path = pathjoin(entry[0][0], entry[0][1])
2213
# parent id is the entry for the path in the target tree
2214
parent_id = state._get_entry(source_index, path_utf8=entry[0][0])[0][2]
2215
if parent_id == entry[0][2]:
2217
return (entry[0][2],
2218
(utf8_decode(old_path)[0], None),
2222
(utf8_decode(entry[0][1])[0], None),
2223
(_minikind_to_kind[source_minikind], None),
2224
(source_details[3], None))
2225
elif source_minikind in 'fdlt' and target_minikind in 'r':
2226
# a rename; could be a true rename, or a rename inherited from
2227
# a renamed parent. TODO: handle this efficiently. Its not
2228
# common case to rename dirs though, so a correct but slow
2229
# implementation will do.
2230
if not osutils.is_inside_any(searched_specific_files, target_details[1]):
2231
search_specific_files.add(target_details[1])
2232
elif source_minikind in 'ra' and target_minikind in 'ra':
2233
# neither of the selected trees contain this file,
2234
# so skip over it. This is not currently directly tested, but
2235
# is indirectly via test_too_much.TestCommands.test_conflicts.
2238
raise AssertionError("don't know how to compare "
2239
"source_minikind=%r, target_minikind=%r"
2240
% (source_minikind, target_minikind))
2241
## import pdb;pdb.set_trace()
2244
while search_specific_files:
2245
# TODO: the pending list should be lexically sorted? the
2246
# interface doesn't require it.
2247
current_root = search_specific_files.pop()
2248
current_root_unicode = current_root.decode('utf8')
2249
searched_specific_files.add(current_root)
2250
# process the entries for this containing directory: the rest will be
2251
# found by their parents recursively.
2252
root_entries = _entries_for_path(current_root)
2253
root_abspath = self.target.abspath(current_root_unicode)
2255
root_stat = os.lstat(root_abspath)
2257
if e.errno == errno.ENOENT:
2258
# the path does not exist: let _process_entry know that.
2259
root_dir_info = None
2261
# some other random error: hand it up.
2264
root_dir_info = ('', current_root,
2265
osutils.file_kind_from_stat_mode(root_stat.st_mode), root_stat,
2267
if root_dir_info[2] == 'directory':
2268
if self.target._directory_is_tree_reference(
2269
current_root.decode('utf8')):
2270
root_dir_info = root_dir_info[:2] + \
2271
('tree-reference',) + root_dir_info[3:]
2273
if not root_entries and not root_dir_info:
2274
# this specified path is not present at all, skip it.
2276
path_handled = False
2277
for entry in root_entries:
2278
result = _process_entry(entry, root_dir_info)
2279
if result is not None:
2281
if result is not uninteresting:
2283
if want_unversioned and not path_handled and root_dir_info:
2284
new_executable = bool(
2285
stat.S_ISREG(root_dir_info[3].st_mode)
2286
and stat.S_IEXEC & root_dir_info[3].st_mode)
2288
(None, current_root_unicode),
2292
(None, splitpath(current_root_unicode)[-1]),
2293
(None, root_dir_info[2]),
2294
(None, new_executable)
2296
initial_key = (current_root, '', '')
2297
block_index, _ = state._find_block_index_from_key(initial_key)
2298
if block_index == 0:
2299
# we have processed the total root already, but because the
2300
# initial key matched it we should skip it here.
2302
if root_dir_info and root_dir_info[2] == 'tree-reference':
2303
current_dir_info = None
2305
dir_iterator = osutils._walkdirs_utf8(root_abspath, prefix=current_root)
2307
current_dir_info = dir_iterator.next()
2309
# on win32, python2.4 has e.errno == ERROR_DIRECTORY, but
2310
# python 2.5 has e.errno == EINVAL,
2311
# and e.winerror == ERROR_DIRECTORY
2312
e_winerror = getattr(e, 'winerror', None)
2313
win_errors = (ERROR_DIRECTORY, ERROR_PATH_NOT_FOUND)
2314
# there may be directories in the inventory even though
2315
# this path is not a file on disk: so mark it as end of
2317
if e.errno in (errno.ENOENT, errno.ENOTDIR, errno.EINVAL):
2318
current_dir_info = None
2319
elif (sys.platform == 'win32'
2320
and (e.errno in win_errors
2321
or e_winerror in win_errors)):
2322
current_dir_info = None
2326
if current_dir_info[0][0] == '':
2327
# remove .bzr from iteration
2328
bzr_index = bisect_left(current_dir_info[1], ('.bzr',))
2329
if current_dir_info[1][bzr_index][0] != '.bzr':
2330
raise AssertionError()
2331
del current_dir_info[1][bzr_index]
2332
# walk until both the directory listing and the versioned metadata
2334
if (block_index < len(state._dirblocks) and
2335
osutils.is_inside(current_root, state._dirblocks[block_index][0])):
2336
current_block = state._dirblocks[block_index]
2338
current_block = None
2339
while (current_dir_info is not None or
2340
current_block is not None):
2341
if (current_dir_info and current_block
2342
and current_dir_info[0][0] != current_block[0]):
2343
if cmp_by_dirs(current_dir_info[0][0], current_block[0]) < 0:
2344
# filesystem data refers to paths not covered by the dirblock.
2345
# this has two possibilities:
2346
# A) it is versioned but empty, so there is no block for it
2347
# B) it is not versioned.
2349
# if (A) then we need to recurse into it to check for
2350
# new unknown files or directories.
2351
# if (B) then we should ignore it, because we don't
2352
# recurse into unknown directories.
2354
while path_index < len(current_dir_info[1]):
2355
current_path_info = current_dir_info[1][path_index]
2356
if want_unversioned:
2357
if current_path_info[2] == 'directory':
2358
if self.target._directory_is_tree_reference(
2359
current_path_info[0].decode('utf8')):
2360
current_path_info = current_path_info[:2] + \
2361
('tree-reference',) + current_path_info[3:]
2362
new_executable = bool(
2363
stat.S_ISREG(current_path_info[3].st_mode)
2364
and stat.S_IEXEC & current_path_info[3].st_mode)
2366
(None, utf8_decode(current_path_info[0])[0]),
2370
(None, utf8_decode(current_path_info[1])[0]),
2371
(None, current_path_info[2]),
2372
(None, new_executable))
2373
# dont descend into this unversioned path if it is
2375
if current_path_info[2] in ('directory',
2377
del current_dir_info[1][path_index]
2381
# This dir info has been handled, go to the next
2383
current_dir_info = dir_iterator.next()
2384
except StopIteration:
2385
current_dir_info = None
2387
# We have a dirblock entry for this location, but there
2388
# is no filesystem path for this. This is most likely
2389
# because a directory was removed from the disk.
2390
# We don't have to report the missing directory,
2391
# because that should have already been handled, but we
2392
# need to handle all of the files that are contained
2394
for current_entry in current_block[1]:
2395
# entry referring to file not present on disk.
2396
# advance the entry only, after processing.
2397
result = _process_entry(current_entry, None)
2398
if result is not None:
2399
if result is not uninteresting:
2402
if (block_index < len(state._dirblocks) and
2403
osutils.is_inside(current_root,
2404
state._dirblocks[block_index][0])):
2405
current_block = state._dirblocks[block_index]
2407
current_block = None
2410
if current_block and entry_index < len(current_block[1]):
2411
current_entry = current_block[1][entry_index]
2413
current_entry = None
2414
advance_entry = True
2416
if current_dir_info and path_index < len(current_dir_info[1]):
2417
current_path_info = current_dir_info[1][path_index]
2418
if current_path_info[2] == 'directory':
2419
if self.target._directory_is_tree_reference(
2420
current_path_info[0].decode('utf8')):
2421
current_path_info = current_path_info[:2] + \
2422
('tree-reference',) + current_path_info[3:]
2424
current_path_info = None
2426
path_handled = False
2427
while (current_entry is not None or
2428
current_path_info is not None):
2429
if current_entry is None:
2430
# the check for path_handled when the path is adnvaced
2431
# will yield this path if needed.
2433
elif current_path_info is None:
2434
# no path is fine: the per entry code will handle it.
2435
result = _process_entry(current_entry, current_path_info)
2436
if result is not None:
2437
if result is not uninteresting:
2439
elif (current_entry[0][1] != current_path_info[1]
2440
or current_entry[1][target_index][0] in 'ar'):
2441
# The current path on disk doesn't match the dirblock
2442
# record. Either the dirblock is marked as absent, or
2443
# the file on disk is not present at all in the
2444
# dirblock. Either way, report about the dirblock
2445
# entry, and let other code handle the filesystem one.
2447
# Compare the basename for these files to determine
2449
if current_path_info[1] < current_entry[0][1]:
2450
# extra file on disk: pass for now, but only
2451
# increment the path, not the entry
2452
advance_entry = False
2454
# entry referring to file not present on disk.
2455
# advance the entry only, after processing.
2456
result = _process_entry(current_entry, None)
2457
if result is not None:
2458
if result is not uninteresting:
2460
advance_path = False
2462
result = _process_entry(current_entry, current_path_info)
2463
if result is not None:
2465
if result is not uninteresting:
2467
if advance_entry and current_entry is not None:
2469
if entry_index < len(current_block[1]):
2470
current_entry = current_block[1][entry_index]
2472
current_entry = None
2474
advance_entry = True # reset the advance flaga
2475
if advance_path and current_path_info is not None:
2476
if not path_handled:
2477
# unversioned in all regards
2478
if want_unversioned:
2479
new_executable = bool(
2480
stat.S_ISREG(current_path_info[3].st_mode)
2481
and stat.S_IEXEC & current_path_info[3].st_mode)
2483
relpath_unicode = utf8_decode(current_path_info[0])[0]
2484
except UnicodeDecodeError:
2485
raise errors.BadFilenameEncoding(
2486
current_path_info[0], osutils._fs_enc)
2488
(None, relpath_unicode),
2492
(None, utf8_decode(current_path_info[1])[0]),
2493
(None, current_path_info[2]),
2494
(None, new_executable))
2495
# dont descend into this unversioned path if it is
2497
if current_path_info[2] in ('directory'):
2498
del current_dir_info[1][path_index]
2500
# dont descend the disk iterator into any tree
2502
if current_path_info[2] == 'tree-reference':
2503
del current_dir_info[1][path_index]
2506
if path_index < len(current_dir_info[1]):
2507
current_path_info = current_dir_info[1][path_index]
2508
if current_path_info[2] == 'directory':
2509
if self.target._directory_is_tree_reference(
2510
current_path_info[0].decode('utf8')):
2511
current_path_info = current_path_info[:2] + \
2512
('tree-reference',) + current_path_info[3:]
2514
current_path_info = None
2515
path_handled = False
2517
advance_path = True # reset the advance flagg.
2518
if current_block is not None:
2520
if (block_index < len(state._dirblocks) and
2521
osutils.is_inside(current_root, state._dirblocks[block_index][0])):
2522
current_block = state._dirblocks[block_index]
2524
current_block = None
2525
if current_dir_info is not None:
2527
current_dir_info = dir_iterator.next()
2528
except StopIteration:
2529
current_dir_info = None
2118
2532
def is_compatible(source, target):
2119
2533
# the target must be a dirstate working tree
2120
if not isinstance(target, DirStateWorkingTree):
2534
if not isinstance(target, WorkingTree4):
2122
# the source must be a revtree or dirstate rev tree.
2536
# the source must be a revtreee or dirstate rev tree.
2123
2537
if not isinstance(source,
2124
2538
(revisiontree.RevisionTree, DirStateRevisionTree)):
2126
2540
# the source revid must be in the target dirstate
2127
if not (source._revision_id == _mod_revision.NULL_REVISION or
2541
if not (source._revision_id == NULL_REVISION or
2128
2542
source._revision_id in target.get_parent_ids()):
2129
# TODO: what about ghosts? it may well need to
2543
# TODO: what about ghosts? it may well need to
2130
2544
# check for them explicitly.
added
removed
bzrlib/workingtree_4.py
