← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Andrew Bennetts
  • Date: 2011-02-14 12:03:05 UTC
  • mto: This revision was merged to the branch mainline in revision 5664.
  • Revision ID: andrew.bennetts@canonical.com-20110214120305-7l7iu1h6f13voeo7
Add release note.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
31
31
lazy_import(globals(), """
32
32
import collections
33
33
import copy
 
34
import os
34
35
import re
35
36
import tarfile
36
37
 
42
43
    )
43
44
""")
44
45
 
45
 
from bzrlib import (
46
 
    lazy_regex,
47
 
    trace,
 
46
from bzrlib.errors import (
 
47
    BzrCheckError,
 
48
    BzrError,
48
49
    )
49
 
 
 
50
from bzrlib.trace import mutter
50
51
from bzrlib.static_tuple import StaticTuple
51
52
 
52
53
 
223
224
 
224
225
    def kind_character(self):
225
226
        """Return a short kind indicator useful for appending to names."""
226
 
        raise errors.BzrError('unknown kind %r' % self.kind)
 
227
        raise BzrError('unknown kind %r' % self.kind)
227
228
 
228
229
    known_kinds = ('file', 'directory', 'symlink')
229
230
 
249
250
        """
250
251
        if self.parent_id is not None:
251
252
            if not inv.has_id(self.parent_id):
252
 
                raise errors.BzrCheckError(
253
 
                    'missing parent {%s} in inventory for revision {%s}' % (
254
 
                        self.parent_id, rev_id))
 
253
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
 
254
                        % (self.parent_id, rev_id))
255
255
        checker._add_entry_to_text_key_references(inv, self)
256
256
        self._check(checker, rev_id)
257
257
 
539
539
        # FIXME: which _modified field should we use ? RBC 20051003
540
540
        text_modified = (self.symlink_target != old_entry.symlink_target)
541
541
        if text_modified:
542
 
            trace.mutter("    symlink target changed")
 
542
            mutter("    symlink target changed")
543
543
        meta_modified = False
544
544
        return text_modified, meta_modified
545
545
 
718
718
                # if we finished all children, pop it off the stack
719
719
                stack.pop()
720
720
 
721
 
    def _preload_cache(self):
722
 
        """Populate any caches, we are about to access all items.
723
 
        
724
 
        The default implementation does nothing, because CommonInventory doesn't
725
 
        have a cache.
726
 
        """
727
 
        pass
728
 
    
729
721
    def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None,
730
722
        yield_parents=False):
731
723
        """Iterate over the entries in a directory first order.
744
736
            specific_file_ids = set(specific_file_ids)
745
737
        # TODO? Perhaps this should return the from_dir so that the root is
746
738
        # yielded? or maybe an option?
747
 
        if from_dir is None and specific_file_ids is None:
748
 
            # They are iterating from the root, and have not specified any
749
 
            # specific entries to look at. All current callers fully consume the
750
 
            # iterator, so we can safely assume we are accessing all entries
751
 
            self._preload_cache()
752
739
        if from_dir is None:
753
740
            if self.root is None:
754
741
                return
1182
1169
    def _add_child(self, entry):
1183
1170
        """Add an entry to the inventory, without adding it to its parent"""
1184
1171
        if entry.file_id in self._byid:
1185
 
            raise errors.BzrError(
1186
 
                "inventory already contains entry with id {%s}" %
1187
 
                entry.file_id)
 
1172
            raise BzrError("inventory already contains entry with id {%s}" %
 
1173
                           entry.file_id)
1188
1174
        self._byid[entry.file_id] = entry
1189
1175
        for child in getattr(entry, 'children', {}).itervalues():
1190
1176
            self._add_child(child)
1354
1340
        """
1355
1341
        new_name = ensure_normalized_name(new_name)
1356
1342
        if not is_valid_name(new_name):
1357
 
            raise errors.BzrError("not an acceptable filename: %r" % new_name)
 
1343
            raise BzrError("not an acceptable filename: %r" % new_name)
1358
1344
 
1359
1345
        new_parent = self._byid[new_parent_id]
1360
1346
        if new_name in new_parent.children:
1361
 
            raise errors.BzrError("%r already exists in %r" %
1362
 
                (new_name, self.id2path(new_parent_id)))
 
1347
            raise BzrError("%r already exists in %r" % (new_name, self.id2path(new_parent_id)))
1363
1348
 
1364
1349
        new_parent_idpath = self.get_idpath(new_parent_id)
1365
1350
        if file_id in new_parent_idpath:
1366
 
            raise errors.BzrError(
1367
 
                "cannot move directory %r into a subdirectory of itself, %r"
 
1351
            raise BzrError("cannot move directory %r into a subdirectory of itself, %r"
1368
1352
                    % (self.id2path(file_id), self.id2path(new_parent_id)))
1369
1353
 
1370
1354
        file_ie = self._byid[file_id]
1406
1390
    def __init__(self, search_key_name):
1407
1391
        CommonInventory.__init__(self)
1408
1392
        self._fileid_to_entry_cache = {}
1409
 
        self._fully_cached = False
1410
1393
        self._path_to_fileid_cache = {}
1411
1394
        self._search_key_name = search_key_name
1412
1395
        self.root_id = None
1973
1956
 
1974
1957
    def iter_just_entries(self):
1975
1958
        """Iterate over all entries.
1976
 
 
 
1959
        
1977
1960
        Unlike iter_entries(), just the entries are returned (not (path, ie))
1978
1961
        and the order of entries is undefined.
1979
1962
 
1987
1970
                self._fileid_to_entry_cache[file_id] = ie
1988
1971
            yield ie
1989
1972
 
1990
 
    def _preload_cache(self):
1991
 
        """Make sure all file-ids are in _fileid_to_entry_cache"""
1992
 
        if self._fully_cached:
1993
 
            return # No need to do it again
1994
 
        # The optimal sort order is to use iteritems() directly
1995
 
        cache = self._fileid_to_entry_cache
1996
 
        for key, entry in self.id_to_entry.iteritems():
1997
 
            file_id = key[0]
1998
 
            if file_id not in cache:
1999
 
                ie = self._bytes_to_entry(entry)
2000
 
                cache[file_id] = ie
2001
 
            else:
2002
 
                ie = cache[file_id]
2003
 
        last_parent_id = last_parent_ie = None
2004
 
        pid_items = self.parent_id_basename_to_file_id.iteritems()
2005
 
        for key, child_file_id in pid_items:
2006
 
            if key == ('', ''): # This is the root
2007
 
                if child_file_id != self.root_id:
2008
 
                    raise ValueError('Data inconsistency detected.'
2009
 
                        ' We expected data with key ("","") to match'
2010
 
                        ' the root id, but %s != %s'
2011
 
                        % (child_file_id, self.root_id))
2012
 
                continue
2013
 
            parent_id, basename = key
2014
 
            ie = cache[child_file_id]
2015
 
            if parent_id == last_parent_id:
2016
 
                parent_ie = last_parent_ie
2017
 
            else:
2018
 
                parent_ie = cache[parent_id]
2019
 
            if parent_ie.kind != 'directory':
2020
 
                raise ValueError('Data inconsistency detected.'
2021
 
                    ' An entry in the parent_id_basename_to_file_id map'
2022
 
                    ' has parent_id {%s} but the kind of that object'
2023
 
                    ' is %r not "directory"' % (parent_id, parent_ie.kind))
2024
 
            if parent_ie._children is None:
2025
 
                parent_ie._children = {}
2026
 
            basename = basename.decode('utf-8')
2027
 
            if basename in parent_ie._children:
2028
 
                existing_ie = parent_ie._children[basename]
2029
 
                if existing_ie != ie:
2030
 
                    raise ValueError('Data inconsistency detected.'
2031
 
                        ' Two entries with basename %r were found'
2032
 
                        ' in the parent entry {%s}'
2033
 
                        % (basename, parent_id))
2034
 
            if basename != ie.name:
2035
 
                raise ValueError('Data inconsistency detected.'
2036
 
                    ' In the parent_id_basename_to_file_id map, file_id'
2037
 
                    ' {%s} is listed as having basename %r, but in the'
2038
 
                    ' id_to_entry map it is %r'
2039
 
                    % (child_file_id, basename, ie.name))
2040
 
            parent_ie._children[basename] = ie
2041
 
        self._fully_cached = True
2042
 
 
2043
1973
    def iter_changes(self, basis):
2044
1974
        """Generate a Tree.iter_changes change list between this and basis.
2045
1975
 
2302
2232
    return name
2303
2233
 
2304
2234
 
2305
 
_NAME_RE = lazy_regex.lazy_compile(r'^[^/\\]+$')
 
2235
_NAME_RE = None
2306
2236
 
2307
2237
def is_valid_name(name):
 
2238
    global _NAME_RE
 
2239
    if _NAME_RE is None:
 
2240
        _NAME_RE = re.compile(r'^[^/\\]+$')
 
2241
 
2308
2242
    return bool(_NAME_RE.match(name))
2309
2243
 
2310
2244