← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Martin Pool
  • Date: 2009-09-11 06:36:50 UTC
  • mto: This revision was merged to the branch mainline in revision 4688.
  • Revision ID: mbp@sourcefrog.net-20090911063650-yvb522sbe6k0i62r
Only mutter extension load errors when they occur, and record for later

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
51
51
    )
52
52
from bzrlib.symbol_versioning import deprecated_in, deprecated_method
53
53
from bzrlib.trace import mutter
54
 
from bzrlib.static_tuple import StaticTuple
55
54
 
56
55
 
57
56
class InventoryEntry(object):
261
260
    def versionable_kind(kind):
262
261
        return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
263
262
 
264
 
    def check(self, checker, rev_id, inv):
 
263
    def check(self, checker, rev_id, inv, tree):
265
264
        """Check this inventory entry is intact.
266
265
 
267
266
        This is a template method, override _check for kind specific
273
272
        :param rev_id: Revision id from which this InventoryEntry was loaded.
274
273
             Not necessarily the last-changed revision for this file.
275
274
        :param inv: Inventory from which the entry was loaded.
 
275
        :param tree: RevisionTree for this entry.
276
276
        """
277
277
        if self.parent_id is not None:
278
278
            if not inv.has_id(self.parent_id):
279
279
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
280
280
                        % (self.parent_id, rev_id))
281
 
        checker._add_entry_to_text_key_references(inv, self)
282
 
        self._check(checker, rev_id)
 
281
        self._check(checker, rev_id, tree)
283
282
 
284
 
    def _check(self, checker, rev_id):
 
283
    def _check(self, checker, rev_id, tree):
285
284
        """Check this inventory entry for kind specific errors."""
286
 
        checker._report_items.append(
287
 
            'unknown entry kind %r in revision {%s}' % (self.kind, rev_id))
 
285
        raise BzrCheckError('unknown entry kind %r in revision {%s}' %
 
286
                            (self.kind, rev_id))
288
287
 
289
288
    def copy(self):
290
289
        """Clone this inventory entry."""
403
402
                 'text_id', 'parent_id', 'children', 'executable',
404
403
                 'revision', 'symlink_target', 'reference_revision']
405
404
 
406
 
    def _check(self, checker, rev_id):
 
405
    def _check(self, checker, rev_id, tree):
407
406
        """See InventoryEntry._check"""
408
407
 
409
408
    def __init__(self, file_id):
432
431
                 'text_id', 'parent_id', 'children', 'executable',
433
432
                 'revision', 'symlink_target', 'reference_revision']
434
433
 
435
 
    def _check(self, checker, rev_id):
 
434
    def _check(self, checker, rev_id, tree):
436
435
        """See InventoryEntry._check"""
437
 
        if (self.text_sha1 is not None or self.text_size is not None or
438
 
            self.text_id is not None):
439
 
            checker._report_items.append('directory {%s} has text in revision {%s}'
 
436
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
437
            raise BzrCheckError('directory {%s} has text in revision {%s}'
440
438
                                % (self.file_id, rev_id))
441
 
        # In non rich root repositories we do not expect a file graph for the
442
 
        # root.
443
 
        if self.name == '' and not checker.rich_roots:
444
 
            return
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 '').
448
 
        checker.add_pending_item(rev_id,
449
 
            ('texts', self.file_id, self.revision), 'text',
450
 
             'da39a3ee5e6b4b0d3255bfef95601890afd80709')
451
439
 
452
440
    def copy(self):
453
441
        other = InventoryDirectory(self.file_id, self.name, self.parent_id)
486
474
                 'text_id', 'parent_id', 'children', 'executable',
487
475
                 'revision', 'symlink_target', 'reference_revision']
488
476
 
489
 
    def _check(self, checker, tree_revision_id):
 
477
    def _check(self, checker, tree_revision_id, tree):
490
478
        """See InventoryEntry._check"""
491
 
        # TODO: check size too.
492
 
        checker.add_pending_item(tree_revision_id,
493
 
            ('texts', self.file_id, self.revision), 'text',
494
 
             self.text_sha1)
495
 
        if self.text_size is None:
496
 
            checker._report_items.append(
497
 
                'fileid {%s} in {%s} has None for text_size' % (self.file_id,
498
 
                tree_revision_id))
 
479
        key = (self.file_id, self.revision)
 
480
        if key in checker.checked_texts:
 
481
            prev_sha = checker.checked_texts[key]
 
482
            if prev_sha != self.text_sha1:
 
483
                raise BzrCheckError(
 
484
                    'mismatched sha1 on {%s} in {%s} (%s != %s) %r' %
 
485
                    (self.file_id, tree_revision_id, prev_sha, self.text_sha1,
 
486
                     t))
 
487
            else:
 
488
                checker.repeated_text_cnt += 1
 
489
                return
 
490
 
 
491
        checker.checked_text_cnt += 1
 
492
        # We can't check the length, because Weave doesn't store that
 
493
        # information, and the whole point of looking at the weave's
 
494
        # sha1sum is that we don't have to extract the text.
 
495
        if (self.text_sha1 != tree._repository.texts.get_sha1s([key])[key]):
 
496
            raise BzrCheckError('text {%s} version {%s} wrong sha1' % key)
 
497
        checker.checked_texts[key] = self.text_sha1
499
498
 
500
499
    def copy(self):
501
500
        other = InventoryFile(self.file_id, self.name, self.parent_id)
599
598
                 'text_id', 'parent_id', 'children', 'executable',
600
599
                 'revision', 'symlink_target', 'reference_revision']
601
600
 
602
 
    def _check(self, checker, tree_revision_id):
 
601
    def _check(self, checker, rev_id, tree):
603
602
        """See InventoryEntry._check"""
604
603
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
605
 
            checker._report_items.append(
606
 
               'symlink {%s} has text in revision {%s}'
607
 
                    % (self.file_id, tree_revision_id))
 
604
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
 
605
                    % (self.file_id, rev_id))
608
606
        if self.symlink_target is None:
609
 
            checker._report_items.append(
610
 
                'symlink {%s} has no target in revision {%s}'
611
 
                    % (self.file_id, tree_revision_id))
612
 
        # Symlinks are stored as ''
613
 
        checker.add_pending_item(tree_revision_id,
614
 
            ('texts', self.file_id, self.revision), 'text',
615
 
             'da39a3ee5e6b4b0d3255bfef95601890afd80709')
 
607
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
 
608
                    % (self.file_id, rev_id))
616
609
 
617
610
    def copy(self):
618
611
        other = InventoryLink(self.file_id, self.name, self.parent_id)
750
743
        """
751
744
        return self.has_id(file_id)
752
745
 
753
 
    def has_filename(self, filename):
754
 
        return bool(self.path2id(filename))
755
 
 
756
746
    def id2path(self, file_id):
757
747
        """Return as a string the path to file_id.
758
748
 
761
751
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
762
752
        >>> print i.id2path('foo-id')
763
753
        src/foo.c
764
 
 
765
 
        :raises NoSuchId: If file_id is not present in the inventory.
766
754
        """
767
755
        # get all names, skipping root
768
756
        return '/'.join(reversed(
959
947
        descend(self.root, u'')
960
948
        return accum
961
949
 
962
 
    def path2id(self, relpath):
 
950
    def path2id(self, name):
963
951
        """Walk down through directories to return entry of last component.
964
952
 
965
 
        :param relpath: may be either a list of path components, or a single
966
 
            string, in which case it is automatically split.
 
953
        names may be either a list of path components, or a single
 
954
        string, in which case it is automatically split.
967
955
 
968
956
        This returns the entry of the last component in the path,
969
957
        which may be either a file or a directory.
970
958
 
971
959
        Returns None IFF the path is not found.
972
960
        """
973
 
        if isinstance(relpath, basestring):
974
 
            names = osutils.splitpath(relpath)
975
 
        else:
976
 
            names = relpath
 
961
        if isinstance(name, basestring):
 
962
            name = osutils.splitpath(name)
 
963
 
 
964
        # mutter("lookup path %r" % name)
977
965
 
978
966
        try:
979
967
            parent = self.root
982
970
            return None
983
971
        if parent is None:
984
972
            return None
985
 
        for f in names:
 
973
        for f in name:
986
974
            try:
987
975
                children = getattr(parent, 'children', None)
988
976
                if children is None:
1198
1186
            raise errors.InconsistentDelta("<deleted>", parent_id,
1199
1187
                "The file id was deleted but its children were not deleted.")
1200
1188
 
1201
 
    def create_by_apply_delta(self, inventory_delta, new_revision_id,
1202
 
                              propagate_caches=False):
1203
 
        """See CHKInventory.create_by_apply_delta()"""
1204
 
        new_inv = self.copy()
1205
 
        new_inv.apply_delta(inventory_delta)
1206
 
        new_inv.revision_id = new_revision_id
1207
 
        return new_inv
1208
 
 
1209
1189
    def _set_root(self, ie):
1210
1190
        self.root = ie
1211
1191
        self._byid = {self.root.file_id: self.root}
1383
1363
            yield ie
1384
1364
            file_id = ie.parent_id
1385
1365
 
 
1366
    def has_filename(self, filename):
 
1367
        return bool(self.path2id(filename))
 
1368
 
1386
1369
    def has_id(self, file_id):
1387
1370
        return (file_id in self._byid)
1388
1371
 
1555
1538
        else:
1556
1539
            raise ValueError("unknown kind %r" % entry.kind)
1557
1540
 
1558
 
    def _expand_fileids_to_parents_and_children(self, file_ids):
1559
 
        """Give a more wholistic view starting with the given file_ids.
1560
 
 
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.
1564
 
 
1565
 
        eg:
1566
 
          /     # TREE_ROOT
1567
 
          foo/  # foo-id
1568
 
            baz # baz-id
1569
 
            frob/ # frob-id
1570
 
              fringle # fringle-id
1571
 
          bar/  # bar-id
1572
 
            bing # bing-id
1573
 
 
1574
 
        if given [foo-id] we will include
1575
 
            TREE_ROOT as interesting parents
1576
 
        and 
1577
 
            foo-id, baz-id, frob-id, fringle-id
1578
 
        As interesting ids.
1579
 
        """
1580
 
        interesting = set()
1581
 
        # TODO: Pre-pass over the list of fileids to see if anything is already
1582
 
        #       deserialized in self._fileid_to_entry_cache
1583
 
 
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)
1593
 
 
1594
 
        # Now, interesting has all of the direct parents, but not the
1595
 
        # parents of those parents. It also may have some duplicates with
1596
 
        # specific_fileids
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
1629
 
 
1630
 
    def filter(self, specific_fileids):
1631
 
        """Get an inventory view filtered against a set of file-ids.
1632
 
 
1633
 
        Children of directories and parents are included.
1634
 
 
1635
 
        The result may or may not reference the underlying inventory
1636
 
        so it should be treated as immutable.
1637
 
        """
1638
 
        (interesting,
1639
 
         parent_to_children) = self._expand_fileids_to_parents_and_children(
1640
 
                                specific_fileids)
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
1645
 
        # adding
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.)
1653
 
            return other
1654
 
        cache = self._fileid_to_entry_cache
1655
 
        try:
1656
 
            remaining_children = collections.deque(parent_to_children[self.root_id])
1657
 
        except:
1658
 
            import pdb; pdb.set_trace()
1659
 
            raise
1660
 
        while remaining_children:
1661
 
            file_id = remaining_children.popleft()
1662
 
            ie = cache[file_id]
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
1668
 
            other.add(ie)
1669
 
            if file_id in parent_to_children:
1670
 
                remaining_children.extend(parent_to_children[file_id])
1671
 
        return other
1672
 
 
1673
1541
    @staticmethod
1674
1542
    def _bytes_to_utf8name_key(bytes):
1675
1543
        """Get the file_id, revision_id key out of bytes."""
1677
1545
        # to filter out empty names because of non rich-root...
1678
1546
        sections = bytes.split('\n')
1679
1547
        kind, file_id = sections[0].split(': ')
1680
 
        return (sections[2], intern(file_id), intern(sections[3]))
 
1548
        return (sections[2], file_id, sections[3])
1681
1549
 
1682
1550
    def _bytes_to_entry(self, bytes):
1683
1551
        """Deserialise a serialised entry."""
1705
1573
            result.reference_revision = sections[4]
1706
1574
        else:
1707
1575
            raise ValueError("Not a serialised entry %r" % bytes)
1708
 
        result.file_id = intern(result.file_id)
1709
 
        result.revision = intern(sections[3])
 
1576
        result.revision = sections[3]
1710
1577
        if result.parent_id == '':
1711
1578
            result.parent_id = None
1712
1579
        self._fileid_to_entry_cache[result.file_id] = result
1810
1677
                        pass
1811
1678
                deletes.add(file_id)
1812
1679
            else:
1813
 
                new_key = StaticTuple(file_id,)
 
1680
                new_key = (file_id,)
1814
1681
                new_value = result._entry_to_bytes(entry)
1815
1682
                # Update caches. It's worth doing this whether
1816
1683
                # we're propagating the old caches or not.
1819
1686
            if old_path is None:
1820
1687
                old_key = None
1821
1688
            else:
1822
 
                old_key = StaticTuple(file_id,)
 
1689
                old_key = (file_id,)
1823
1690
                if self.id2path(file_id) != old_path:
1824
1691
                    raise errors.InconsistentDelta(old_path, file_id,
1825
1692
                        "Entry was at wrong other path %r." %
1826
1693
                        self.id2path(file_id))
1827
1694
                altered.add(file_id)
1828
 
            id_to_entry_delta.append(StaticTuple(old_key, new_key, new_value))
 
1695
            id_to_entry_delta.append((old_key, new_key, new_value))
1829
1696
            if result.parent_id_basename_to_file_id is not None:
1830
1697
                # parent_id, basename changes
1831
1698
                if old_path is None:
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,))
1933
1794
 
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)
1943
1804
        else:
1944
1805
            result.parent_id_basename_to_file_id = None
1945
1806
 
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" %
1972
1832
        id_to_entry_dict = {}
1973
1833
        parent_id_basename_dict = {}
1974
1834
        for path, entry in inventory.iter_entries():
1975
 
            key = StaticTuple(entry.file_id,).intern()
1976
 
            id_to_entry_dict[key] = entry_to_bytes(entry)
 
1835
            id_to_entry_dict[(entry.file_id,)] = entry_to_bytes(entry)
1977
1836
            p_id_key = parent_id_basename_key(entry)
1978
1837
            parent_id_basename_dict[p_id_key] = entry.file_id
1979
1838
 
2002
1861
            parent_id = entry.parent_id
2003
1862
        else:
2004
1863
            parent_id = ''
2005
 
        return StaticTuple(parent_id, entry.name.encode('utf8')).intern()
 
1864
        return parent_id, entry.name.encode('utf8')
2006
1865
 
2007
1866
    def __getitem__(self, file_id):
2008
1867
        """map a single file_id -> InventoryEntry."""
2013
1872
            return result
2014
1873
        try:
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)
2020
1879
 
2021
 
    def _getitems(self, file_ids):
2022
 
        """Similar to __getitem__, but lets you query for multiple.
2023
 
        
2024
 
        The returned order is undefined. And currently if an item doesn't
2025
 
        exist, it isn't included in the output.
2026
 
        """
2027
 
        result = []
2028
 
        remaining = []
2029
 
        for file_id in file_ids:
2030
 
            entry = self._fileid_to_entry_cache.get(file_id, None)
2031
 
            if entry is None:
2032
 
                remaining.append(file_id)
2033
 
            else:
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
2040
 
        return result
2041
 
 
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:
2045
1883
            return True
2046
 
        return len(list(
2047
 
            self.id_to_entry.iteritems([StaticTuple(file_id,)]))) == 1
 
1884
        return len(list(self.id_to_entry.iteritems([(file_id,)]))) == 1
2048
1885
 
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))
2180
2017
        return delta
2181
2018
 
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:
2187
2024
            return result
2188
 
        if isinstance(relpath, basestring):
2189
 
            names = osutils.splitpath(relpath)
 
2025
        if isinstance(name, basestring):
 
2026
            names = osutils.splitpath(name)
2190
2027
        else:
2191
 
            names = relpath
 
2028
            names = name
2192
2029
        current_id = self.root_id
2193
2030
        if current_id is None:
2194
2031
            return None
2195
2032
        parent_id_index = self.parent_id_basename_to_file_id
2196
 
        cur_path = None
2197
2033
        for basename in names:
2198
 
            if cur_path is None:
2199
 
                cur_path = basename
2200
 
            else:
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)]
 
2037
            file_id = None
 
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,
 
2043
                        basename_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,
2211
 
                            basename_utf8))
2212
 
                if file_id is None:
2213
 
                    return None
2214
 
                else:
2215
 
                    self._path_to_fileid_cache[cur_path] = file_id
 
2045
                return None
2216
2046
            current_id = file_id
 
2047
        self._path_to_fileid_cache[name] = current_id
2217
2048
        return current_id
2218
2049
 
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())
2230
2061
        else:
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())
2237
2068
        return lines
2238
2069
 
2239
2070
    @property
2280
2111
        parent_id_index = self._chk_inventory.parent_id_basename_to_file_id
2281
2112
        child_keys = set()
2282
2113
        for (parent_id, name_utf8), file_id in parent_id_index.iteritems(
2283
 
            key_filter=[StaticTuple(self.file_id,)]):
2284
 
            child_keys.add(StaticTuple(file_id,))
 
2114
            key_filter=[(self.file_id,)]):
 
2115
            child_keys.add((file_id,))
2285
2116
        cached = set()
2286
2117
        for file_id_key in child_keys:
2287
2118
            entry = self._chk_inventory._fileid_to_entry_cache.get(
2320
2151
    try:
2321
2152
        factory = entry_factory[kind]
2322
2153
    except KeyError:
2323
 
        raise errors.BadFileKindError(name, kind)
 
2154
        raise BzrError("unknown kind %r" % kind)
2324
2155
    return factory(file_id, name, parent_id)
2325
2156
 
2326
2157