482
473
return path_utf8.decode('utf8')
484
475
if not osutils.supports_executable():
485
477
def is_executable(self, file_id, path=None):
486
"""Test if a file is executable or not.
488
Note: The caller is expected to take a read-lock before calling this.
490
478
file_id = osutils.safe_file_id(file_id)
491
479
entry = self._get_entry(file_id=file_id, path=path)
492
480
if entry == (None, None):
494
482
return entry[1][0][3]
496
485
def is_executable(self, file_id, path=None):
497
"""Test if a file is executable or not.
499
Note: The caller is expected to take a read-lock before calling this.
502
487
file_id = osutils.safe_file_id(file_id)
503
488
path = self.id2path(file_id)
1808
1800
NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
1809
1801
# Using a list so that we can access the values and change them in
1810
1802
# nested scope. Each one is [path, file_id, entry]
1811
last_source_parent = [None, None]
1812
last_target_parent = [None, None]
1803
last_source_parent = [None, None, None]
1804
last_target_parent = [None, None, None]
1814
1806
use_filesystem_for_exec = (sys.platform != 'win32')
1816
# Just a sentry, so that _process_entry can say that this
1817
# record is handled, but isn't interesting to process (unchanged)
1818
uninteresting = object()
1821
old_dirname_to_file_id = {}
1822
new_dirname_to_file_id = {}
1823
# TODO: jam 20070516 - Avoid the _get_entry lookup overhead by
1824
# keeping a cache of directories that we have seen.
1826
1808
def _process_entry(entry, path_info):
1827
1809
"""Compare an entry and real disk to generate delta information.
1927
1901
target_exec = False
1929
1903
raise Exception, "unknown kind %s" % path_info[2]
1930
if source_minikind == 'd':
1932
old_path = path = pathjoin(old_dirname, old_basename)
1933
old_dirname_to_file_id[old_path] = file_id
1934
1904
# parent id is the entry for the path in the target tree
1935
1905
if old_dirname == last_source_parent[0]:
1936
1906
source_parent_id = last_source_parent[1]
1939
source_parent_id = old_dirname_to_file_id[old_dirname]
1941
source_parent_entry = state._get_entry(source_index,
1942
path_utf8=old_dirname)
1943
source_parent_id = source_parent_entry[0][2]
1908
source_parent_entry = state._get_entry(source_index,
1909
path_utf8=old_dirname)
1910
source_parent_id = source_parent_entry[0][2]
1944
1911
if source_parent_id == entry[0][2]:
1945
1912
# This is the root, so the parent is None
1946
1913
source_parent_id = None
1948
1915
last_source_parent[0] = old_dirname
1949
1916
last_source_parent[1] = source_parent_id
1917
last_source_parent[2] = source_parent_entry
1950
1918
new_dirname = entry[0][0]
1951
1919
if new_dirname == last_target_parent[0]:
1952
1920
target_parent_id = last_target_parent[1]
1955
target_parent_id = new_dirname_to_file_id[new_dirname]
1957
# TODO: We don't always need to do the lookup, because the
1958
# parent entry will be the same as the source entry.
1959
target_parent_entry = state._get_entry(target_index,
1960
path_utf8=new_dirname)
1961
assert target_parent_entry != (None, None), (
1962
"Could not find target parent in wt: %s\nparent of: %s"
1963
% (new_dirname, entry))
1964
target_parent_id = target_parent_entry[0][2]
1922
# TODO: We don't always need to do the lookup, because the
1923
# parent entry will be the same as the source entry.
1924
target_parent_entry = state._get_entry(target_index,
1925
path_utf8=new_dirname)
1926
assert target_parent_entry != (None, None), (
1927
"Could not find target parent in wt: %s\nparent of: %s"
1928
% (new_dirname, entry))
1929
target_parent_id = target_parent_entry[0][2]
1965
1930
if target_parent_id == entry[0][2]:
1966
1931
# This is the root, so the parent is None
1967
1932
target_parent_id = None
1969
1934
last_target_parent[0] = new_dirname
1970
1935
last_target_parent[1] = target_parent_id
1936
last_target_parent[2] = target_parent_entry
1972
1938
source_exec = source_details[3]
1973
if (include_unchanged
1975
or source_parent_id != target_parent_id
1976
or old_basename != entry[0][1]
1977
or source_exec != target_exec
1979
if old_path is None:
1980
old_path = path = pathjoin(old_dirname, old_basename)
1981
old_path_u = utf8_decode(old_path)[0]
1984
old_path_u = utf8_decode(old_path)[0]
1985
if old_path == path:
1988
path_u = utf8_decode(path)[0]
1989
source_kind = _minikind_to_kind[source_minikind]
1990
return (entry[0][2],
1991
(old_path_u, path_u),
1994
(source_parent_id, target_parent_id),
1995
(utf8_decode(old_basename)[0], utf8_decode(entry[0][1])[0]),
1996
(source_kind, target_kind),
1997
(source_exec, target_exec))
1999
return uninteresting
1939
return ((entry[0][2], (old_path, path), content_change,
1941
(source_parent_id, target_parent_id),
1942
(old_basename, entry[0][1]),
1943
(_minikind_to_kind[source_minikind], target_kind),
1944
(source_exec, target_exec)),)
2000
1945
elif source_minikind in 'a' and target_minikind in 'fdlt':
2001
1946
# looks like a new file
2002
1947
if path_info is not None:
2037
1980
parent_id = state._get_entry(source_index, path_utf8=entry[0][0])[0][2]
2038
1981
if parent_id == entry[0][2]:
2039
1982
parent_id = None
2040
return (entry[0][2],
2041
(utf8_decode(old_path)[0], None),
2045
(utf8_decode(entry[0][1])[0], None),
2046
(_minikind_to_kind[source_minikind], None),
2047
(source_details[3], None))
1983
return ((entry[0][2], (old_path, None), True,
1986
(entry[0][1], None),
1987
(_minikind_to_kind[source_minikind], None),
1988
(source_details[3], None)),)
2048
1989
elif source_minikind in 'fdlt' and target_minikind in 'r':
2049
1990
# a rename; could be a true rename, or a rename inherited from
2050
1991
# a renamed parent. TODO: handle this efficiently. Its not
2099
2040
path_handled = False
2100
2041
for entry in root_entries:
2101
result = _process_entry(entry, root_dir_info)
2102
if result is not None:
2042
for result in _process_entry(entry, root_dir_info):
2043
# this check should probably be outside the loop: one
2044
# 'iterate two trees' api, and then _iter_changes filters
2045
# unchanged pairs. - RBC 20070226
2103
2046
path_handled = True
2104
if result is not uninteresting:
2047
if (include_unchanged
2048
or result[2] # content change
2049
or result[3][0] != result[3][1] # versioned status
2050
or result[4][0] != result[4][1] # parent id
2051
or result[5][0] != result[5][1] # name
2052
or result[6][0] != result[6][1] # kind
2053
or result[7][0] != result[7][1] # executable
2056
(utf8_decode_or_none(result[1][0]),
2057
utf8_decode_or_none(result[1][1])),
2061
(utf8_decode_or_none(result[5][0]),
2062
utf8_decode_or_none(result[5][1])),
2106
2066
if want_unversioned and not path_handled and root_dir_info:
2107
2067
new_executable = bool(
2108
2068
stat.S_ISREG(root_dir_info[3].st_mode)
2185
2145
stat.S_ISREG(current_path_info[3].st_mode)
2186
2146
and stat.S_IEXEC & current_path_info[3].st_mode)
2188
(None, utf8_decode(current_path_info[0])[0]),
2148
(None, utf8_decode_or_none(current_path_info[0])),
2190
2150
(False, False),
2192
(None, utf8_decode(current_path_info[1])[0]),
2152
(None, utf8_decode_or_none(current_path_info[1])),
2193
2153
(None, current_path_info[2]),
2194
2154
(None, new_executable))
2195
# dont descend into this unversioned path if it is
2197
if current_path_info[2] in ('directory',
2199
del current_dir_info[1][path_index]
2155
# dont descend into this unversioned path if it is
2157
if current_path_info[2] in ('directory',
2159
del current_dir_info[1][path_index]
2203
2163
# This dir info has been handled, go to the next
2216
2176
for current_entry in current_block[1]:
2217
2177
# entry referring to file not present on disk.
2218
2178
# advance the entry only, after processing.
2219
result = _process_entry(current_entry, None)
2220
if result is not None:
2221
if result is not uninteresting:
2179
for result in _process_entry(current_entry, None):
2180
# this check should probably be outside the loop: one
2181
# 'iterate two trees' api, and then _iter_changes filters
2182
# unchanged pairs. - RBC 20070226
2183
if (include_unchanged
2184
or result[2] # content change
2185
or result[3][0] != result[3][1] # versioned status
2186
or result[4][0] != result[4][1] # parent id
2187
or result[5][0] != result[5][1] # name
2188
or result[6][0] != result[6][1] # kind
2189
or result[7][0] != result[7][1] # executable
2192
(utf8_decode_or_none(result[1][0]),
2193
utf8_decode_or_none(result[1][1])),
2197
(utf8_decode_or_none(result[5][0]),
2198
utf8_decode_or_none(result[5][1])),
2223
2202
block_index +=1
2224
2203
if (block_index < len(state._dirblocks) and
2225
2204
osutils.is_inside(current_root,
2255
2234
elif current_path_info is None:
2256
2235
# no path is fine: the per entry code will handle it.
2257
result = _process_entry(current_entry, current_path_info)
2258
if result is not None:
2259
if result is not uninteresting:
2261
elif (current_entry[0][1] != current_path_info[1]
2262
or current_entry[1][target_index][0] in 'ar'):
2263
# The current path on disk doesn't match the dirblock
2264
# record. Either the dirblock is marked as absent, or
2265
# the file on disk is not present at all in the
2266
# dirblock. Either way, report about the dirblock
2267
# entry, and let other code handle the filesystem one.
2268
if current_path_info[1].split('/') < current_entry[0][1].split('/'):
2236
for result in _process_entry(current_entry, current_path_info):
2237
# this check should probably be outside the loop: one
2238
# 'iterate two trees' api, and then _iter_changes filters
2239
# unchanged pairs. - RBC 20070226
2240
if (include_unchanged
2241
or result[2] # content change
2242
or result[3][0] != result[3][1] # versioned status
2243
or result[4][0] != result[4][1] # parent id
2244
or result[5][0] != result[5][1] # name
2245
or result[6][0] != result[6][1] # kind
2246
or result[7][0] != result[7][1] # executable
2249
(utf8_decode_or_none(result[1][0]),
2250
utf8_decode_or_none(result[1][1])),
2254
(utf8_decode_or_none(result[5][0]),
2255
utf8_decode_or_none(result[5][1])),
2259
elif current_entry[0][1] != current_path_info[1]:
2260
if current_path_info[1] < current_entry[0][1]:
2269
2261
# extra file on disk: pass for now, but only
2270
2262
# increment the path, not the entry
2271
2263
advance_entry = False
2273
2265
# entry referring to file not present on disk.
2274
2266
# advance the entry only, after processing.
2275
result = _process_entry(current_entry, None)
2276
if result is not None:
2277
if result is not uninteresting:
2267
for result in _process_entry(current_entry, None):
2268
# this check should probably be outside the loop: one
2269
# 'iterate two trees' api, and then _iter_changes filters
2270
# unchanged pairs. - RBC 20070226
2272
if (include_unchanged
2273
or result[2] # content change
2274
or result[3][0] != result[3][1] # versioned status
2275
or result[4][0] != result[4][1] # parent id
2276
or result[5][0] != result[5][1] # name
2277
or result[6][0] != result[6][1] # kind
2278
or result[7][0] != result[7][1] # executable
2281
(utf8_decode_or_none(result[1][0]),
2282
utf8_decode_or_none(result[1][1])),
2286
(utf8_decode_or_none(result[5][0]),
2287
utf8_decode_or_none(result[5][1])),
2279
2291
advance_path = False
2281
result = _process_entry(current_entry, current_path_info)
2282
if result is not None:
2284
if result is not uninteresting:
2293
for result in _process_entry(current_entry, current_path_info):
2294
# this check should probably be outside the loop: one
2295
# 'iterate two trees' api, and then _iter_changes filters
2296
# unchanged pairs. - RBC 20070226
2297
if current_entry[1][target_index][0] == 'a':
2298
advance_path = False
2299
path_handled = False
2302
if (include_unchanged
2303
or result[2] # content change
2304
or result[3][0] != result[3][1] # versioned status
2305
or result[4][0] != result[4][1] # parent id
2306
or result[5][0] != result[5][1] # name
2307
or result[6][0] != result[6][1] # kind
2308
or result[7][0] != result[7][1] # executable
2311
(utf8_decode_or_none(result[1][0]),
2312
utf8_decode_or_none(result[1][1])),
2316
(utf8_decode_or_none(result[5][0]),
2317
utf8_decode_or_none(result[5][1])),
2286
2321
if advance_entry and current_entry is not None:
2287
2322
entry_index += 1
2288
2323
if entry_index < len(current_block[1]):
added
removed
bzrlib/workingtree_4.py
