/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Andrew Bennetts
  • Date: 2009-10-21 11:13:40 UTC
  • mto: This revision was merged to the branch mainline in revision 4762.
  • Revision ID: andrew.bennetts@canonical.com-20091021111340-w7x4d5yf83qwjncc
Add test that WSGI glue allows request handlers to access paths above that request's. backing transport, so long as it is within the WSGI app's backing transport.

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):
1600
1599
        interesting.add(None) # this will auto-filter it in the loop
1601
1600
        remaining_parents.discard(None) 
1602
1601
        while remaining_parents:
 
1602
            if None in remaining_parents:
 
1603
                import pdb; pdb.set_trace()
1603
1604
            next_parents = set()
1604
1605
            for entry in self._getitems(remaining_parents):
1605
1606
                next_parents.add(entry.parent_id)
1614
1615
        while directories_to_expand:
1615
1616
            # Expand directories by looking in the
1616
1617
            # parent_id_basename_to_file_id map
1617
 
            keys = [StaticTuple(f,).intern() for f in directories_to_expand]
 
1618
            keys = [(f,) for f in directories_to_expand]
1618
1619
            directories_to_expand = set()
1619
1620
            items = self.parent_id_basename_to_file_id.iteritems(keys)
1620
1621
            next_file_ids = set([item[1] for item in items])
1677
1678
        # to filter out empty names because of non rich-root...
1678
1679
        sections = bytes.split('\n')
1679
1680
        kind, file_id = sections[0].split(': ')
1680
 
        return (sections[2], intern(file_id), intern(sections[3]))
 
1681
        return (sections[2], file_id, sections[3])
1681
1682
 
1682
1683
    def _bytes_to_entry(self, bytes):
1683
1684
        """Deserialise a serialised entry."""
1705
1706
            result.reference_revision = sections[4]
1706
1707
        else:
1707
1708
            raise ValueError("Not a serialised entry %r" % bytes)
1708
 
        result.file_id = intern(result.file_id)
1709
 
        result.revision = intern(sections[3])
 
1709
        result.revision = sections[3]
1710
1710
        if result.parent_id == '':
1711
1711
            result.parent_id = None
1712
1712
        self._fileid_to_entry_cache[result.file_id] = result
1810
1810
                        pass
1811
1811
                deletes.add(file_id)
1812
1812
            else:
1813
 
                new_key = StaticTuple(file_id,)
 
1813
                new_key = (file_id,)
1814
1814
                new_value = result._entry_to_bytes(entry)
1815
1815
                # Update caches. It's worth doing this whether
1816
1816
                # we're propagating the old caches or not.
1819
1819
            if old_path is None:
1820
1820
                old_key = None
1821
1821
            else:
1822
 
                old_key = StaticTuple(file_id,)
 
1822
                old_key = (file_id,)
1823
1823
                if self.id2path(file_id) != old_path:
1824
1824
                    raise errors.InconsistentDelta(old_path, file_id,
1825
1825
                        "Entry was at wrong other path %r." %
1826
1826
                        self.id2path(file_id))
1827
1827
                altered.add(file_id)
1828
 
            id_to_entry_delta.append(StaticTuple(old_key, new_key, new_value))
 
1828
            id_to_entry_delta.append((old_key, new_key, new_value))
1829
1829
            if result.parent_id_basename_to_file_id is not None:
1830
1830
                # parent_id, basename changes
1831
1831
                if old_path is None:
1923
1923
        search_key_name = intern(info.get('search_key_name', 'plain'))
1924
1924
        parent_id_basename_to_file_id = intern(info.get(
1925
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,))
1929
1926
        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
1927
 
1934
1928
        result = CHKInventory(search_key_name)
1935
1929
        result.revision_id = revision_id
1938
1932
                            result._search_key_name)
1939
1933
        if parent_id_basename_to_file_id is not None:
1940
1934
            result.parent_id_basename_to_file_id = chk_map.CHKMap(
1941
 
                chk_store, StaticTuple(parent_id_basename_to_file_id,),
 
1935
                chk_store, (parent_id_basename_to_file_id,),
1942
1936
                search_key_func=search_key_func)
1943
1937
        else:
1944
1938
            result.parent_id_basename_to_file_id = None
1945
1939
 
1946
 
        result.id_to_entry = chk_map.CHKMap(chk_store,
1947
 
                                            StaticTuple(id_to_entry,),
 
1940
        result.id_to_entry = chk_map.CHKMap(chk_store, (id_to_entry,),
1948
1941
                                            search_key_func=search_key_func)
1949
1942
        if (result.revision_id,) != expected_revision_id:
1950
1943
            raise ValueError("Mismatched revision id and expected: %r, %r" %
1972
1965
        id_to_entry_dict = {}
1973
1966
        parent_id_basename_dict = {}
1974
1967
        for path, entry in inventory.iter_entries():
1975
 
            key = StaticTuple(entry.file_id,).intern()
1976
 
            id_to_entry_dict[key] = entry_to_bytes(entry)
 
1968
            id_to_entry_dict[(entry.file_id,)] = entry_to_bytes(entry)
1977
1969
            p_id_key = parent_id_basename_key(entry)
1978
1970
            parent_id_basename_dict[p_id_key] = entry.file_id
1979
1971
 
2002
1994
            parent_id = entry.parent_id
2003
1995
        else:
2004
1996
            parent_id = ''
2005
 
        return StaticTuple(parent_id, entry.name.encode('utf8')).intern()
 
1997
        return parent_id, entry.name.encode('utf8')
2006
1998
 
2007
1999
    def __getitem__(self, file_id):
2008
2000
        """map a single file_id -> InventoryEntry."""
2013
2005
            return result
2014
2006
        try:
2015
2007
            return self._bytes_to_entry(
2016
 
                self.id_to_entry.iteritems([StaticTuple(file_id,)]).next()[1])
 
2008
                self.id_to_entry.iteritems([(file_id,)]).next()[1])
2017
2009
        except StopIteration:
2018
2010
            # really we're passing an inventory, not a tree...
2019
2011
            raise errors.NoSuchId(self, file_id)
2032
2024
                remaining.append(file_id)
2033
2025
            else:
2034
2026
                result.append(entry)
2035
 
        file_keys = [StaticTuple(f,).intern() for f in remaining]
 
2027
        file_keys = [(f,) for f in remaining]
2036
2028
        for file_key, value in self.id_to_entry.iteritems(file_keys):
2037
2029
            entry = self._bytes_to_entry(value)
2038
2030
            result.append(entry)
2043
2035
        # Perhaps have an explicit 'contains' method on CHKMap ?
2044
2036
        if self._fileid_to_entry_cache.get(file_id, None) is not None:
2045
2037
            return True
2046
 
        return len(list(
2047
 
            self.id_to_entry.iteritems([StaticTuple(file_id,)]))) == 1
 
2038
        return len(list(self.id_to_entry.iteritems([(file_id,)]))) == 1
2048
2039
 
2049
2040
    def is_root(self, file_id):
2050
2041
        return file_id == self.root_id
2202
2193
            basename_utf8 = basename.encode('utf8')
2203
2194
            file_id = self._path_to_fileid_cache.get(cur_path, None)
2204
2195
            if file_id is None:
2205
 
                key_filter = [StaticTuple(current_id, basename_utf8)]
 
2196
                key_filter = [(current_id, basename_utf8)]
2206
2197
                items = parent_id_index.iteritems(key_filter)
2207
2198
                for (parent_id, name_utf8), file_id in items:
2208
2199
                    if parent_id != current_id or name_utf8 != basename_utf8:
2224
2215
            lines.append('search_key_name: %s\n' % (self._search_key_name,))
2225
2216
            lines.append("root_id: %s\n" % self.root_id)
2226
2217
            lines.append('parent_id_basename_to_file_id: %s\n' %
2227
 
                (self.parent_id_basename_to_file_id.key()[0],))
 
2218
                self.parent_id_basename_to_file_id.key())
2228
2219
            lines.append("revision_id: %s\n" % self.revision_id)
2229
 
            lines.append("id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
 
2220
            lines.append("id_to_entry: %s\n" % self.id_to_entry.key())
2230
2221
        else:
2231
2222
            lines.append("revision_id: %s\n" % self.revision_id)
2232
2223
            lines.append("root_id: %s\n" % self.root_id)
2233
2224
            if self.parent_id_basename_to_file_id is not None:
2234
2225
                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],))
 
2226
                    self.parent_id_basename_to_file_id.key())
 
2227
            lines.append("id_to_entry: %s\n" % self.id_to_entry.key())
2237
2228
        return lines
2238
2229
 
2239
2230
    @property
2280
2271
        parent_id_index = self._chk_inventory.parent_id_basename_to_file_id
2281
2272
        child_keys = set()
2282
2273
        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,))
 
2274
            key_filter=[(self.file_id,)]):
 
2275
            child_keys.add((file_id,))
2285
2276
        cached = set()
2286
2277
        for file_id_key in child_keys:
2287
2278
            entry = self._chk_inventory._fileid_to_entry_cache.get(