438
437
self.text_id is not None):
439
438
checker._report_items.append('directory {%s} has text in revision {%s}'
440
439
% (self.file_id, rev_id))
441
# In non rich root repositories we do not expect a file graph for the
443
if self.name == '' and not checker.rich_roots:
445
# Directories are stored as an empty file, but the file should exist
446
# to provide a per-fileid log. The hash of every directory content is
447
# "da..." below (the sha1sum of '').
440
# Directories are stored as ''.
448
441
checker.add_pending_item(rev_id,
449
442
('texts', self.file_id, self.revision), 'text',
450
443
'da39a3ee5e6b4b0d3255bfef95601890afd80709')
959
950
descend(self.root, u'')
962
def path2id(self, relpath):
953
def path2id(self, name):
963
954
"""Walk down through directories to return entry of last component.
965
:param relpath: may be either a list of path components, or a single
966
string, in which case it is automatically split.
956
names may be either a list of path components, or a single
957
string, in which case it is automatically split.
968
959
This returns the entry of the last component in the path,
969
960
which may be either a file or a directory.
971
962
Returns None IFF the path is not found.
973
if isinstance(relpath, basestring):
974
names = osutils.splitpath(relpath)
964
if isinstance(name, basestring):
965
name = osutils.splitpath(name)
967
# mutter("lookup path %r" % name)
979
970
parent = self.root
1556
1539
raise ValueError("unknown kind %r" % entry.kind)
1558
def _expand_fileids_to_parents_and_children(self, file_ids):
1559
"""Give a more wholistic view starting with the given file_ids.
1561
For any file_id which maps to a directory, we will include all children
1562
of that directory. We will also include all directories which are
1563
parents of the given file_ids, but we will not include their children.
1570
fringle # fringle-id
1574
if given [foo-id] we will include
1575
TREE_ROOT as interesting parents
1577
foo-id, baz-id, frob-id, fringle-id
1581
# TODO: Pre-pass over the list of fileids to see if anything is already
1582
# deserialized in self._fileid_to_entry_cache
1584
directories_to_expand = set()
1585
children_of_parent_id = {}
1586
# It is okay if some of the fileids are missing
1587
for entry in self._getitems(file_ids):
1588
if entry.kind == 'directory':
1589
directories_to_expand.add(entry.file_id)
1590
interesting.add(entry.parent_id)
1591
children_of_parent_id.setdefault(entry.parent_id, []
1592
).append(entry.file_id)
1594
# Now, interesting has all of the direct parents, but not the
1595
# parents of those parents. It also may have some duplicates with
1597
remaining_parents = interesting.difference(file_ids)
1598
# When we hit the TREE_ROOT, we'll get an interesting parent of None,
1599
# but we don't actually want to recurse into that
1600
interesting.add(None) # this will auto-filter it in the loop
1601
remaining_parents.discard(None)
1602
while remaining_parents:
1603
next_parents = set()
1604
for entry in self._getitems(remaining_parents):
1605
next_parents.add(entry.parent_id)
1606
children_of_parent_id.setdefault(entry.parent_id, []
1607
).append(entry.file_id)
1608
# Remove any search tips we've already processed
1609
remaining_parents = next_parents.difference(interesting)
1610
interesting.update(remaining_parents)
1611
# We should probably also .difference(directories_to_expand)
1612
interesting.update(file_ids)
1613
interesting.discard(None)
1614
while directories_to_expand:
1615
# Expand directories by looking in the
1616
# parent_id_basename_to_file_id map
1617
keys = [StaticTuple(f,).intern() for f in directories_to_expand]
1618
directories_to_expand = set()
1619
items = self.parent_id_basename_to_file_id.iteritems(keys)
1620
next_file_ids = set([item[1] for item in items])
1621
next_file_ids = next_file_ids.difference(interesting)
1622
interesting.update(next_file_ids)
1623
for entry in self._getitems(next_file_ids):
1624
if entry.kind == 'directory':
1625
directories_to_expand.add(entry.file_id)
1626
children_of_parent_id.setdefault(entry.parent_id, []
1627
).append(entry.file_id)
1628
return interesting, children_of_parent_id
1630
def filter(self, specific_fileids):
1631
"""Get an inventory view filtered against a set of file-ids.
1633
Children of directories and parents are included.
1635
The result may or may not reference the underlying inventory
1636
so it should be treated as immutable.
1639
parent_to_children) = self._expand_fileids_to_parents_and_children(
1641
# There is some overlap here, but we assume that all interesting items
1642
# are in the _fileid_to_entry_cache because we had to read them to
1643
# determine if they were a dir we wanted to recurse, or just a file
1644
# This should give us all the entries we'll want to add, so start
1646
other = Inventory(self.root_id)
1647
other.root.revision = self.root.revision
1648
other.revision_id = self.revision_id
1649
if not interesting or not parent_to_children:
1650
# empty filter, or filtering entrys that don't exist
1651
# (if even 1 existed, then we would have populated
1652
# parent_to_children with at least the tree root.)
1654
cache = self._fileid_to_entry_cache
1656
remaining_children = collections.deque(parent_to_children[self.root_id])
1658
import pdb; pdb.set_trace()
1660
while remaining_children:
1661
file_id = remaining_children.popleft()
1663
if ie.kind == 'directory':
1664
ie = ie.copy() # We create a copy to depopulate the .children attribute
1665
# TODO: depending on the uses of 'other' we should probably alwyas
1666
# '.copy()' to prevent someone from mutating other and
1667
# invaliding our internal cache
1669
if file_id in parent_to_children:
1670
remaining_children.extend(parent_to_children[file_id])
1674
1542
def _bytes_to_utf8name_key(bytes):
1675
1543
"""Get the file_id, revision_id key out of bytes."""
1918
1785
raise errors.BzrError('Duplicate key in inventory: %r\n%r'
1919
1786
% (key, bytes))
1920
1787
info[key] = value
1921
revision_id = intern(info['revision_id'])
1922
root_id = intern(info['root_id'])
1923
search_key_name = intern(info.get('search_key_name', 'plain'))
1924
parent_id_basename_to_file_id = intern(info.get(
1925
'parent_id_basename_to_file_id', None))
1926
if not parent_id_basename_to_file_id.startswith('sha1:'):
1927
raise ValueError('parent_id_basename_to_file_id should be a sha1'
1928
' key not %r' % (parent_id_basename_to_file_id,))
1788
revision_id = info['revision_id']
1789
root_id = info['root_id']
1790
search_key_name = info.get('search_key_name', 'plain')
1791
parent_id_basename_to_file_id = info.get(
1792
'parent_id_basename_to_file_id', None)
1929
1793
id_to_entry = info['id_to_entry']
1930
if not id_to_entry.startswith('sha1:'):
1931
raise ValueError('id_to_entry should be a sha1'
1932
' key not %r' % (id_to_entry,))
1934
1795
result = CHKInventory(search_key_name)
1935
1796
result.revision_id = revision_id
1938
1799
result._search_key_name)
1939
1800
if parent_id_basename_to_file_id is not None:
1940
1801
result.parent_id_basename_to_file_id = chk_map.CHKMap(
1941
chk_store, StaticTuple(parent_id_basename_to_file_id,),
1802
chk_store, (parent_id_basename_to_file_id,),
1942
1803
search_key_func=search_key_func)
1944
1805
result.parent_id_basename_to_file_id = None
1946
result.id_to_entry = chk_map.CHKMap(chk_store,
1947
StaticTuple(id_to_entry,),
1807
result.id_to_entry = chk_map.CHKMap(chk_store, (id_to_entry,),
1948
1808
search_key_func=search_key_func)
1949
1809
if (result.revision_id,) != expected_revision_id:
1950
1810
raise ValueError("Mismatched revision id and expected: %r, %r" %
2015
1874
return self._bytes_to_entry(
2016
self.id_to_entry.iteritems([StaticTuple(file_id,)]).next()[1])
1875
self.id_to_entry.iteritems([(file_id,)]).next()[1])
2017
1876
except StopIteration:
2018
1877
# really we're passing an inventory, not a tree...
2019
1878
raise errors.NoSuchId(self, file_id)
2021
def _getitems(self, file_ids):
2022
"""Similar to __getitem__, but lets you query for multiple.
2024
The returned order is undefined. And currently if an item doesn't
2025
exist, it isn't included in the output.
2029
for file_id in file_ids:
2030
entry = self._fileid_to_entry_cache.get(file_id, None)
2032
remaining.append(file_id)
2034
result.append(entry)
2035
file_keys = [StaticTuple(f,).intern() for f in remaining]
2036
for file_key, value in self.id_to_entry.iteritems(file_keys):
2037
entry = self._bytes_to_entry(value)
2038
result.append(entry)
2039
self._fileid_to_entry_cache[entry.file_id] = entry
2042
1880
def has_id(self, file_id):
2043
1881
# Perhaps have an explicit 'contains' method on CHKMap ?
2044
1882
if self._fileid_to_entry_cache.get(file_id, None) is not None:
2047
self.id_to_entry.iteritems([StaticTuple(file_id,)]))) == 1
1884
return len(list(self.id_to_entry.iteritems([(file_id,)]))) == 1
2049
1886
def is_root(self, file_id):
2050
1887
return file_id == self.root_id
2179
2016
delta.append((old_path, new_path, file_id, entry))
2182
def path2id(self, relpath):
2019
def path2id(self, name):
2183
2020
"""See CommonInventory.path2id()."""
2184
2021
# TODO: perhaps support negative hits?
2185
result = self._path_to_fileid_cache.get(relpath, None)
2022
result = self._path_to_fileid_cache.get(name, None)
2186
2023
if result is not None:
2188
if isinstance(relpath, basestring):
2189
names = osutils.splitpath(relpath)
2025
if isinstance(name, basestring):
2026
names = osutils.splitpath(name)
2192
2029
current_id = self.root_id
2193
2030
if current_id is None:
2195
2032
parent_id_index = self.parent_id_basename_to_file_id
2197
2033
for basename in names:
2198
if cur_path is None:
2201
cur_path = cur_path + '/' + basename
2034
# TODO: Cache each path we figure out in this function.
2202
2035
basename_utf8 = basename.encode('utf8')
2203
file_id = self._path_to_fileid_cache.get(cur_path, None)
2036
key_filter = [(current_id, basename_utf8)]
2038
for (parent_id, name_utf8), file_id in parent_id_index.iteritems(
2039
key_filter=key_filter):
2040
if parent_id != current_id or name_utf8 != basename_utf8:
2041
raise errors.BzrError("corrupt inventory lookup! "
2042
"%r %r %r %r" % (parent_id, current_id, name_utf8,
2204
2044
if file_id is None:
2205
key_filter = [StaticTuple(current_id, basename_utf8)]
2206
items = parent_id_index.iteritems(key_filter)
2207
for (parent_id, name_utf8), file_id in items:
2208
if parent_id != current_id or name_utf8 != basename_utf8:
2209
raise errors.BzrError("corrupt inventory lookup! "
2210
"%r %r %r %r" % (parent_id, current_id, name_utf8,
2215
self._path_to_fileid_cache[cur_path] = file_id
2216
2046
current_id = file_id
2047
self._path_to_fileid_cache[name] = current_id
2217
2048
return current_id
2219
2050
def to_lines(self):
2224
2055
lines.append('search_key_name: %s\n' % (self._search_key_name,))
2225
2056
lines.append("root_id: %s\n" % self.root_id)
2226
2057
lines.append('parent_id_basename_to_file_id: %s\n' %
2227
(self.parent_id_basename_to_file_id.key()[0],))
2058
self.parent_id_basename_to_file_id.key())
2228
2059
lines.append("revision_id: %s\n" % self.revision_id)
2229
lines.append("id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
2060
lines.append("id_to_entry: %s\n" % self.id_to_entry.key())
2231
2062
lines.append("revision_id: %s\n" % self.revision_id)
2232
2063
lines.append("root_id: %s\n" % self.root_id)
2233
2064
if self.parent_id_basename_to_file_id is not None:
2234
2065
lines.append('parent_id_basename_to_file_id: %s\n' %
2235
(self.parent_id_basename_to_file_id.key()[0],))
2236
lines.append("id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
2066
self.parent_id_basename_to_file_id.key())
2067
lines.append("id_to_entry: %s\n" % self.id_to_entry.key())
added
removed
bzrlib/inventory.py
