~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Martin Pool
  • Date: 2005-07-21 12:01:14 UTC
  • Revision ID: mbp@sourcefrog.net-20050721120114-100fff1ee8c35385
- fix up self reference in msvc lock object

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
#
 
1
# (C) 2005 Canonical Ltd
 
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
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
# FIXME: This refactoring of the workingtree code doesn't seem to keep 
18
 
# the WorkingTree's copy of the inventory in sync with the branch.  The
19
 
# branch modifies its working inventory when it does a commit to make
20
 
# missing files permanently removed.
21
 
 
22
 
# TODO: Maybe also keep the full path of the entry, and the children?
23
 
# But those depend on its position within a particular inventory, and
24
 
# it would be nice not to need to hold the backpointer here.
25
17
 
26
18
# This should really be an id randomly assigned when the tree is
27
19
# created, but it's not for now.
28
20
ROOT_ID = "TREE_ROOT"
29
21
 
30
 
import os
31
 
import re
32
 
import sys
33
22
 
34
 
from bzrlib.lazy_import import lazy_import
35
 
lazy_import(globals(), """
36
 
import collections
37
 
import tarfile
 
23
import sys, os.path, types, re
38
24
 
39
25
import bzrlib
40
 
from bzrlib import (
41
 
    errors,
42
 
    generate_ids,
43
 
    osutils,
44
 
    symbol_versioning,
45
 
    workingtree,
46
 
    )
47
 
""")
 
26
from bzrlib.errors import BzrError, BzrCheckError
48
27
 
49
 
from bzrlib.errors import (
50
 
    BzrCheckError,
51
 
    BzrError,
52
 
    )
53
 
from bzrlib.symbol_versioning import deprecated_in, deprecated_method
 
28
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
54
29
from bzrlib.trace import mutter
55
30
 
56
 
 
57
31
class InventoryEntry(object):
58
32
    """Description of a versioned file.
59
33
 
60
34
    An InventoryEntry has the following fields, which are also
61
35
    present in the XML inventory-entry element:
62
36
 
63
 
    file_id
64
 
 
65
 
    name
66
 
        (within the parent directory)
67
 
 
68
 
    parent_id
69
 
        file_id of the parent directory, or ROOT_ID
70
 
 
71
 
    revision
72
 
        the revision_id in which this variation of this file was 
73
 
        introduced.
74
 
 
75
 
    executable
76
 
        Indicates that this file should be executable on systems
77
 
        that support it.
78
 
 
79
 
    text_sha1
80
 
        sha-1 of the text of the file
81
 
        
82
 
    text_size
83
 
        size in bytes of the text of the file
84
 
        
85
 
    (reading a version 4 tree created a text_id field.)
 
37
    * *file_id*
 
38
    * *name*: (only the basename within the directory, must not
 
39
      contain slashes)
 
40
    * *kind*: "directory" or "file"
 
41
    * *directory_id*: (if absent/null means the branch root directory)
 
42
    * *text_sha1*: only for files
 
43
    * *text_size*: in bytes, only for files 
 
44
    * *text_id*: identifier for the text version, only for files
 
45
 
 
46
    InventoryEntries can also exist inside a WorkingTree
 
47
    inventory, in which case they are not yet bound to a
 
48
    particular revision of the file.  In that case the text_sha1,
 
49
    text_size and text_id are absent.
 
50
 
86
51
 
87
52
    >>> i = Inventory()
88
53
    >>> i.path2id('')
89
54
    'TREE_ROOT'
90
 
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
91
 
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
92
 
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
93
 
    InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
94
 
    >>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}
95
 
    >>> for ix, j in enumerate(i.iter_entries()):
96
 
    ...   print (j[0] == shouldbe[ix], j[1])
 
55
    >>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
 
56
    >>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
 
57
    >>> for j in i.iter_entries():
 
58
    ...   print j
97
59
    ... 
98
 
    (True, InventoryDirectory('TREE_ROOT', u'', parent_id=None, revision=None))
99
 
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
100
 
    (True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None))
101
 
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
102
 
    InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
103
 
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
104
 
    InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
 
60
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
 
61
    ('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
 
62
    >>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
 
63
    Traceback (most recent call last):
 
64
    ...
 
65
    BzrError: inventory already contains entry with id {2323}
 
66
    >>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
 
67
    >>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
105
68
    >>> i.path2id('src/wibble')
106
69
    '2325'
107
70
    >>> '2325' in i
108
71
    True
109
 
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
110
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
72
    >>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
111
73
    >>> i['2326']
112
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
113
 
    >>> for path, entry in i.iter_entries():
114
 
    ...     print path
 
74
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
 
75
    >>> for j in i.iter_entries():
 
76
    ...     print j[0]
 
77
    ...     assert i.path2id(j[0])
115
78
    ... 
116
 
    <BLANKLINE>
117
79
    src
118
80
    src/bye.c
119
81
    src/hello.c
121
83
    src/wibble/wibble.c
122
84
    >>> i.id2path('2326')
123
85
    'src/wibble/wibble.c'
 
86
 
 
87
    TODO: Maybe also keep the full path of the entry, and the children?
 
88
           But those depend on its position within a particular inventory, and
 
89
           it would be nice not to need to hold the backpointer here.
124
90
    """
125
91
 
126
 
    # Constants returned by describe_change()
127
 
    #
128
 
    # TODO: These should probably move to some kind of FileChangeDescription 
129
 
    # class; that's like what's inside a TreeDelta but we want to be able to 
130
 
    # generate them just for one file at a time.
131
 
    RENAMED = 'renamed'
132
 
    MODIFIED_AND_RENAMED = 'modified and renamed'
133
 
    
134
 
    __slots__ = []
135
 
 
136
 
    def detect_changes(self, old_entry):
137
 
        """Return a (text_modified, meta_modified) from this to old_entry.
138
 
        
139
 
        _read_tree_state must have been called on self and old_entry prior to 
140
 
        calling detect_changes.
141
 
        """
142
 
        return False, False
143
 
 
144
 
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
145
 
             output_to, reverse=False):
146
 
        """Perform a diff between two entries of the same kind."""
147
 
    
148
 
    def parent_candidates(self, previous_inventories):
149
 
        """Find possible per-file graph parents.
150
 
 
151
 
        This is currently defined by:
152
 
         - Select the last changed revision in the parent inventory.
153
 
         - Do deal with a short lived bug in bzr 0.8's development two entries
154
 
           that have the same last changed but different 'x' bit settings are
155
 
           changed in-place.
156
 
        """
157
 
        # revision:ie mapping for each ie found in previous_inventories.
158
 
        candidates = {}
159
 
        # identify candidate head revision ids.
160
 
        for inv in previous_inventories:
161
 
            if self.file_id in inv:
162
 
                ie = inv[self.file_id]
163
 
                if ie.revision in candidates:
164
 
                    # same revision value in two different inventories:
165
 
                    # correct possible inconsistencies:
166
 
                    #     * there was a bug in revision updates with 'x' bit 
167
 
                    #       support.
168
 
                    try:
169
 
                        if candidates[ie.revision].executable != ie.executable:
170
 
                            candidates[ie.revision].executable = False
171
 
                            ie.executable = False
172
 
                    except AttributeError:
173
 
                        pass
174
 
                else:
175
 
                    # add this revision as a candidate.
176
 
                    candidates[ie.revision] = ie
177
 
        return candidates
178
 
 
179
 
    @deprecated_method(deprecated_in((1, 6, 0)))
180
 
    def get_tar_item(self, root, dp, now, tree):
181
 
        """Get a tarfile item and a file stream for its content."""
182
 
        item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
183
 
        # TODO: would be cool to actually set it to the timestamp of the
184
 
        # revision it was last changed
185
 
        item.mtime = now
186
 
        fileobj = self._put_in_tar(item, tree)
187
 
        return item, fileobj
188
 
 
189
 
    def has_text(self):
190
 
        """Return true if the object this entry represents has textual data.
191
 
 
192
 
        Note that textual data includes binary content.
193
 
 
194
 
        Also note that all entries get weave files created for them.
195
 
        This attribute is primarily used when upgrading from old trees that
196
 
        did not have the weave index for all inventory entries.
197
 
        """
198
 
        return False
199
 
 
200
 
    def __init__(self, file_id, name, parent_id, text_id=None):
 
92
    # TODO: split InventoryEntry into subclasses for files,
 
93
    # directories, etc etc.
 
94
 
 
95
    text_sha1 = None
 
96
    text_size = None
 
97
    
 
98
    def __init__(self, file_id, name, kind, parent_id, text_id=None):
201
99
        """Create an InventoryEntry
202
100
        
203
101
        The filename must be a single component, relative to the
204
102
        parent directory; it cannot be a whole path or relative name.
205
103
 
206
 
        >>> e = InventoryFile('123', 'hello.c', ROOT_ID)
 
104
        >>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
207
105
        >>> e.name
208
106
        'hello.c'
209
107
        >>> e.file_id
210
108
        '123'
211
 
        >>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
 
109
        >>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
212
110
        Traceback (most recent call last):
213
 
        InvalidEntryName: Invalid entry name: src/hello.c
 
111
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
214
112
        """
215
113
        if '/' in name or '\\' in name:
216
 
            raise errors.InvalidEntryName(name=name)
217
 
        self.executable = False
218
 
        self.revision = None
219
 
        self.text_sha1 = None
220
 
        self.text_size = None
 
114
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
 
115
        
221
116
        self.file_id = file_id
222
117
        self.name = name
 
118
        self.kind = kind
223
119
        self.text_id = text_id
224
120
        self.parent_id = parent_id
225
 
        self.symlink_target = None
226
 
        self.reference_revision = None
227
 
 
228
 
    def kind_character(self):
229
 
        """Return a short kind indicator useful for appending to names."""
230
 
        raise BzrError('unknown kind %r' % self.kind)
231
 
 
232
 
    known_kinds = ('file', 'directory', 'symlink')
233
 
 
234
 
    def _put_in_tar(self, item, tree):
235
 
        """populate item for stashing in a tar, and return the content stream.
236
 
 
237
 
        If no content is available, return None.
238
 
        """
239
 
        raise BzrError("don't know how to export {%s} of kind %r" %
240
 
                       (self.file_id, self.kind))
241
 
 
242
 
    @deprecated_method(deprecated_in((1, 6, 0)))
243
 
    def put_on_disk(self, dest, dp, tree):
244
 
        """Create a representation of self on disk in the prefix dest.
245
 
        
246
 
        This is a template method - implement _put_on_disk in subclasses.
247
 
        """
248
 
        fullpath = osutils.pathjoin(dest, dp)
249
 
        self._put_on_disk(fullpath, tree)
250
 
        # mutter("  export {%s} kind %s to %s", self.file_id,
251
 
        #         self.kind, fullpath)
252
 
 
253
 
    def _put_on_disk(self, fullpath, tree):
254
 
        """Put this entry onto disk at fullpath, from tree tree."""
255
 
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
 
121
        if kind == 'directory':
 
122
            self.children = {}
 
123
        elif kind == 'file':
 
124
            pass
 
125
        else:
 
126
            raise BzrError("unhandled entry kind %r" % kind)
 
127
 
 
128
 
256
129
 
257
130
    def sorted_children(self):
258
 
        return sorted(self.children.items())
259
 
 
260
 
    @staticmethod
261
 
    def versionable_kind(kind):
262
 
        return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
263
 
 
264
 
    def check(self, checker, rev_id, inv, tree):
265
 
        """Check this inventory entry is intact.
266
 
 
267
 
        This is a template method, override _check for kind specific
268
 
        tests.
269
 
 
270
 
        :param checker: Check object providing context for the checks; 
271
 
             can be used to find out what parts of the repository have already
272
 
             been checked.
273
 
        :param rev_id: Revision id from which this InventoryEntry was loaded.
274
 
             Not necessarily the last-changed revision for this file.
275
 
        :param inv: Inventory from which the entry was loaded.
276
 
        :param tree: RevisionTree for this entry.
277
 
        """
278
 
        if self.parent_id is not None:
279
 
            if not inv.has_id(self.parent_id):
280
 
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
281
 
                        % (self.parent_id, rev_id))
282
 
        self._check(checker, rev_id, tree)
283
 
 
284
 
    def _check(self, checker, rev_id, tree):
285
 
        """Check this inventory entry for kind specific errors."""
286
 
        raise BzrCheckError('unknown entry kind %r in revision {%s}' % 
287
 
                            (self.kind, rev_id))
 
131
        l = self.children.items()
 
132
        l.sort()
 
133
        return l
 
134
 
288
135
 
289
136
    def copy(self):
290
 
        """Clone this inventory entry."""
291
 
        raise NotImplementedError
292
 
 
293
 
    @staticmethod
294
 
    def describe_change(old_entry, new_entry):
295
 
        """Describe the change between old_entry and this.
296
 
        
297
 
        This smells of being an InterInventoryEntry situation, but as its
298
 
        the first one, we're making it a static method for now.
299
 
 
300
 
        An entry with a different parent, or different name is considered 
301
 
        to be renamed. Reparenting is an internal detail.
302
 
        Note that renaming the parent does not trigger a rename for the
303
 
        child entry itself.
304
 
        """
305
 
        # TODO: Perhaps return an object rather than just a string
306
 
        if old_entry is new_entry:
307
 
            # also the case of both being None
308
 
            return 'unchanged'
309
 
        elif old_entry is None:
310
 
            return 'added'
311
 
        elif new_entry is None:
312
 
            return 'removed'
313
 
        if old_entry.kind != new_entry.kind:
314
 
            return 'modified'
315
 
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
316
 
        if text_modified or meta_modified:
317
 
            modified = True
318
 
        else:
319
 
            modified = False
320
 
        # TODO 20060511 (mbp, rbc) factor out 'detect_rename' here.
321
 
        if old_entry.parent_id != new_entry.parent_id:
322
 
            renamed = True
323
 
        elif old_entry.name != new_entry.name:
324
 
            renamed = True
325
 
        else:
326
 
            renamed = False
327
 
        if renamed and not modified:
328
 
            return InventoryEntry.RENAMED
329
 
        if modified and not renamed:
330
 
            return 'modified'
331
 
        if modified and renamed:
332
 
            return InventoryEntry.MODIFIED_AND_RENAMED
333
 
        return 'unchanged'
 
137
        other = InventoryEntry(self.file_id, self.name, self.kind,
 
138
                               self.parent_id, text_id=self.text_id)
 
139
        other.text_sha1 = self.text_sha1
 
140
        other.text_size = self.text_size
 
141
        # note that children are *not* copied; they're pulled across when
 
142
        # others are added
 
143
        return other
 
144
 
334
145
 
335
146
    def __repr__(self):
336
 
        return ("%s(%r, %r, parent_id=%r, revision=%r)"
 
147
        return ("%s(%r, %r, kind=%r, parent_id=%r)"
337
148
                % (self.__class__.__name__,
338
149
                   self.file_id,
339
150
                   self.name,
340
 
                   self.parent_id,
341
 
                   self.revision))
 
151
                   self.kind,
 
152
                   self.parent_id))
 
153
 
 
154
    
 
155
    def to_element(self):
 
156
        """Convert to XML element"""
 
157
        from bzrlib.xml import Element
 
158
        
 
159
        e = Element('entry')
 
160
 
 
161
        e.set('name', self.name)
 
162
        e.set('file_id', self.file_id)
 
163
        e.set('kind', self.kind)
 
164
 
 
165
        if self.text_size != None:
 
166
            e.set('text_size', '%d' % self.text_size)
 
167
            
 
168
        for f in ['text_id', 'text_sha1']:
 
169
            v = getattr(self, f)
 
170
            if v != None:
 
171
                e.set(f, v)
 
172
 
 
173
        # to be conservative, we don't externalize the root pointers
 
174
        # for now, leaving them as null in the xml form.  in a future
 
175
        # version it will be implied by nested elements.
 
176
        if self.parent_id != ROOT_ID:
 
177
            assert isinstance(self.parent_id, basestring)
 
178
            e.set('parent_id', self.parent_id)
 
179
 
 
180
        e.tail = '\n'
 
181
            
 
182
        return e
 
183
 
 
184
 
 
185
    def from_element(cls, elt):
 
186
        assert elt.tag == 'entry'
 
187
 
 
188
        ## original format inventories don't have a parent_id for
 
189
        ## nodes in the root directory, but it's cleaner to use one
 
190
        ## internally.
 
191
        parent_id = elt.get('parent_id')
 
192
        if parent_id == None:
 
193
            parent_id = ROOT_ID
 
194
 
 
195
        self = cls(elt.get('file_id'), elt.get('name'), elt.get('kind'), parent_id)
 
196
        self.text_id = elt.get('text_id')
 
197
        self.text_sha1 = elt.get('text_sha1')
 
198
        
 
199
        ## mutter("read inventoryentry: %r" % (elt.attrib))
 
200
 
 
201
        v = elt.get('text_size')
 
202
        self.text_size = v and int(v)
 
203
 
 
204
        return self
 
205
            
 
206
 
 
207
    from_element = classmethod(from_element)
342
208
 
343
209
    def __eq__(self, other):
344
 
        if other is self:
345
 
            # For the case when objects are cached
346
 
            return True
347
210
        if not isinstance(other, InventoryEntry):
348
211
            return NotImplemented
349
212
 
350
 
        return ((self.file_id == other.file_id)
351
 
                and (self.name == other.name)
352
 
                and (other.symlink_target == self.symlink_target)
353
 
                and (self.text_sha1 == other.text_sha1)
354
 
                and (self.text_size == other.text_size)
355
 
                and (self.text_id == other.text_id)
356
 
                and (self.parent_id == other.parent_id)
357
 
                and (self.kind == other.kind)
358
 
                and (self.revision == other.revision)
359
 
                and (self.executable == other.executable)
360
 
                and (self.reference_revision == other.reference_revision)
361
 
                )
 
213
        return (self.file_id == other.file_id) \
 
214
               and (self.name == other.name) \
 
215
               and (self.text_sha1 == other.text_sha1) \
 
216
               and (self.text_size == other.text_size) \
 
217
               and (self.text_id == other.text_id) \
 
218
               and (self.parent_id == other.parent_id) \
 
219
               and (self.kind == other.kind)
 
220
 
362
221
 
363
222
    def __ne__(self, other):
364
223
        return not (self == other)
366
225
    def __hash__(self):
367
226
        raise ValueError('not hashable')
368
227
 
369
 
    def _unchanged(self, previous_ie):
370
 
        """Has this entry changed relative to previous_ie.
371
 
 
372
 
        This method should be overridden in child classes.
373
 
        """
374
 
        compatible = True
375
 
        # different inv parent
376
 
        if previous_ie.parent_id != self.parent_id:
377
 
            compatible = False
378
 
        # renamed
379
 
        elif previous_ie.name != self.name:
380
 
            compatible = False
381
 
        elif previous_ie.kind != self.kind:
382
 
            compatible = False
383
 
        return compatible
384
 
 
385
 
    def _read_tree_state(self, path, work_tree):
386
 
        """Populate fields in the inventory entry from the given tree.
387
 
        
388
 
        Note that this should be modified to be a noop on virtual trees
389
 
        as all entries created there are prepopulated.
390
 
        """
391
 
        # TODO: Rather than running this manually, we should check the 
392
 
        # working sha1 and other expensive properties when they're
393
 
        # first requested, or preload them if they're already known
394
 
        pass            # nothing to do by default
395
 
 
396
 
    def _forget_tree_state(self):
397
 
        pass
398
228
 
399
229
 
400
230
class RootEntry(InventoryEntry):
401
 
 
402
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
403
 
                 'text_id', 'parent_id', 'children', 'executable',
404
 
                 'revision', 'symlink_target', 'reference_revision']
405
 
 
406
 
    def _check(self, checker, rev_id, tree):
407
 
        """See InventoryEntry._check"""
408
 
 
409
231
    def __init__(self, file_id):
410
232
        self.file_id = file_id
411
233
        self.children = {}
412
 
        self.kind = 'directory'
 
234
        self.kind = 'root_directory'
413
235
        self.parent_id = None
414
 
        self.name = u''
415
 
        self.revision = None
416
 
        symbol_versioning.warn('RootEntry is deprecated as of bzr 0.10.'
417
 
                               '  Please use InventoryDirectory instead.',
418
 
                               DeprecationWarning, stacklevel=2)
 
236
        self.name = ''
419
237
 
420
238
    def __eq__(self, other):
421
239
        if not isinstance(other, RootEntry):
425
243
               and (self.children == other.children)
426
244
 
427
245
 
428
 
class InventoryDirectory(InventoryEntry):
429
 
    """A directory in an inventory."""
430
 
 
431
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
432
 
                 'text_id', 'parent_id', 'children', 'executable',
433
 
                 'revision', 'symlink_target', 'reference_revision']
434
 
 
435
 
    def _check(self, checker, rev_id, tree):
436
 
        """See InventoryEntry._check"""
437
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
438
 
            raise BzrCheckError('directory {%s} has text in revision {%s}'
439
 
                                % (self.file_id, rev_id))
440
 
 
441
 
    def copy(self):
442
 
        other = InventoryDirectory(self.file_id, self.name, self.parent_id)
443
 
        other.revision = self.revision
444
 
        # note that children are *not* copied; they're pulled across when
445
 
        # others are added
446
 
        return other
447
 
 
448
 
    def __init__(self, file_id, name, parent_id):
449
 
        super(InventoryDirectory, self).__init__(file_id, name, parent_id)
450
 
        self.children = {}
451
 
        self.kind = 'directory'
452
 
 
453
 
    def kind_character(self):
454
 
        """See InventoryEntry.kind_character."""
455
 
        return '/'
456
 
 
457
 
    def _put_in_tar(self, item, tree):
458
 
        """See InventoryEntry._put_in_tar."""
459
 
        item.type = tarfile.DIRTYPE
460
 
        fileobj = None
461
 
        item.name += '/'
462
 
        item.size = 0
463
 
        item.mode = 0755
464
 
        return fileobj
465
 
 
466
 
    def _put_on_disk(self, fullpath, tree):
467
 
        """See InventoryEntry._put_on_disk."""
468
 
        os.mkdir(fullpath)
469
 
 
470
 
 
471
 
class InventoryFile(InventoryEntry):
472
 
    """A file in an inventory."""
473
 
 
474
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
475
 
                 'text_id', 'parent_id', 'children', 'executable',
476
 
                 'revision', 'symlink_target', 'reference_revision']
477
 
 
478
 
    def _check(self, checker, tree_revision_id, tree):
479
 
        """See InventoryEntry._check"""
480
 
        key = (self.file_id, self.revision)
481
 
        if key in checker.checked_texts:
482
 
            prev_sha = checker.checked_texts[key]
483
 
            if prev_sha != self.text_sha1:
484
 
                raise BzrCheckError(
485
 
                    'mismatched sha1 on {%s} in {%s} (%s != %s) %r' %
486
 
                    (self.file_id, tree_revision_id, prev_sha, self.text_sha1,
487
 
                     t))
488
 
            else:
489
 
                checker.repeated_text_cnt += 1
490
 
                return
491
 
 
492
 
        mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
493
 
        checker.checked_text_cnt += 1
494
 
        # We can't check the length, because Weave doesn't store that
495
 
        # information, and the whole point of looking at the weave's
496
 
        # sha1sum is that we don't have to extract the text.
497
 
        if (self.text_sha1 != tree._repository.texts.get_sha1s([key])[key]):
498
 
            raise BzrCheckError('text {%s} version {%s} wrong sha1' % key)
499
 
        checker.checked_texts[key] = self.text_sha1
500
 
 
501
 
    def copy(self):
502
 
        other = InventoryFile(self.file_id, self.name, self.parent_id)
503
 
        other.executable = self.executable
504
 
        other.text_id = self.text_id
505
 
        other.text_sha1 = self.text_sha1
506
 
        other.text_size = self.text_size
507
 
        other.revision = self.revision
508
 
        return other
509
 
 
510
 
    def detect_changes(self, old_entry):
511
 
        """See InventoryEntry.detect_changes."""
512
 
        text_modified = (self.text_sha1 != old_entry.text_sha1)
513
 
        meta_modified = (self.executable != old_entry.executable)
514
 
        return text_modified, meta_modified
515
 
 
516
 
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
517
 
             output_to, reverse=False):
518
 
        """See InventoryEntry._diff."""
519
 
        from bzrlib.diff import DiffText
520
 
        from_file_id = self.file_id
521
 
        if to_entry:
522
 
            to_file_id = to_entry.file_id
523
 
        else:
524
 
            to_file_id = None
525
 
        if reverse:
526
 
            to_file_id, from_file_id = from_file_id, to_file_id
527
 
            tree, to_tree = to_tree, tree
528
 
            from_label, to_label = to_label, from_label
529
 
        differ = DiffText(tree, to_tree, output_to, 'utf-8', '', '',
530
 
                          text_diff)
531
 
        return differ.diff_text(from_file_id, to_file_id, from_label, to_label)
532
 
 
533
 
    def has_text(self):
534
 
        """See InventoryEntry.has_text."""
535
 
        return True
536
 
 
537
 
    def __init__(self, file_id, name, parent_id):
538
 
        super(InventoryFile, self).__init__(file_id, name, parent_id)
539
 
        self.kind = 'file'
540
 
 
541
 
    def kind_character(self):
542
 
        """See InventoryEntry.kind_character."""
543
 
        return ''
544
 
 
545
 
    def _put_in_tar(self, item, tree):
546
 
        """See InventoryEntry._put_in_tar."""
547
 
        item.type = tarfile.REGTYPE
548
 
        fileobj = tree.get_file(self.file_id)
549
 
        item.size = self.text_size
550
 
        if tree.is_executable(self.file_id):
551
 
            item.mode = 0755
552
 
        else:
553
 
            item.mode = 0644
554
 
        return fileobj
555
 
 
556
 
    def _put_on_disk(self, fullpath, tree):
557
 
        """See InventoryEntry._put_on_disk."""
558
 
        osutils.pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
559
 
        if tree.is_executable(self.file_id):
560
 
            os.chmod(fullpath, 0755)
561
 
 
562
 
    def _read_tree_state(self, path, work_tree):
563
 
        """See InventoryEntry._read_tree_state."""
564
 
        self.text_sha1 = work_tree.get_file_sha1(self.file_id, path=path)
565
 
        # FIXME: 20050930 probe for the text size when getting sha1
566
 
        # in _read_tree_state
567
 
        self.executable = work_tree.is_executable(self.file_id, path=path)
568
 
 
569
 
    def __repr__(self):
570
 
        return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s)"
571
 
                % (self.__class__.__name__,
572
 
                   self.file_id,
573
 
                   self.name,
574
 
                   self.parent_id,
575
 
                   self.text_sha1,
576
 
                   self.text_size))
577
 
 
578
 
    def _forget_tree_state(self):
579
 
        self.text_sha1 = None
580
 
 
581
 
    def _unchanged(self, previous_ie):
582
 
        """See InventoryEntry._unchanged."""
583
 
        compatible = super(InventoryFile, self)._unchanged(previous_ie)
584
 
        if self.text_sha1 != previous_ie.text_sha1:
585
 
            compatible = False
586
 
        else:
587
 
            # FIXME: 20050930 probe for the text size when getting sha1
588
 
            # in _read_tree_state
589
 
            self.text_size = previous_ie.text_size
590
 
        if self.executable != previous_ie.executable:
591
 
            compatible = False
592
 
        return compatible
593
 
 
594
 
 
595
 
class InventoryLink(InventoryEntry):
596
 
    """A file in an inventory."""
597
 
 
598
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
599
 
                 'text_id', 'parent_id', 'children', 'executable',
600
 
                 'revision', 'symlink_target', 'reference_revision']
601
 
 
602
 
    def _check(self, checker, rev_id, tree):
603
 
        """See InventoryEntry._check"""
604
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
605
 
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
606
 
                    % (self.file_id, rev_id))
607
 
        if self.symlink_target is None:
608
 
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
609
 
                    % (self.file_id, rev_id))
610
 
 
611
 
    def copy(self):
612
 
        other = InventoryLink(self.file_id, self.name, self.parent_id)
613
 
        other.symlink_target = self.symlink_target
614
 
        other.revision = self.revision
615
 
        return other
616
 
 
617
 
    def detect_changes(self, old_entry):
618
 
        """See InventoryEntry.detect_changes."""
619
 
        # FIXME: which _modified field should we use ? RBC 20051003
620
 
        text_modified = (self.symlink_target != old_entry.symlink_target)
621
 
        if text_modified:
622
 
            mutter("    symlink target changed")
623
 
        meta_modified = False
624
 
        return text_modified, meta_modified
625
 
 
626
 
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
627
 
             output_to, reverse=False):
628
 
        """See InventoryEntry._diff."""
629
 
        from bzrlib.diff import DiffSymlink
630
 
        old_target = self.symlink_target
631
 
        if to_entry is not None:
632
 
            new_target = to_entry.symlink_target
633
 
        else:
634
 
            new_target = None
635
 
        if not reverse:
636
 
            old_tree = tree
637
 
            new_tree = to_tree
638
 
        else:
639
 
            old_tree = to_tree
640
 
            new_tree = tree
641
 
            new_target, old_target = old_target, new_target
642
 
        differ = DiffSymlink(old_tree, new_tree, output_to)
643
 
        return differ.diff_symlink(old_target, new_target)
644
 
 
645
 
    def __init__(self, file_id, name, parent_id):
646
 
        super(InventoryLink, self).__init__(file_id, name, parent_id)
647
 
        self.kind = 'symlink'
648
 
 
649
 
    def kind_character(self):
650
 
        """See InventoryEntry.kind_character."""
651
 
        return ''
652
 
 
653
 
    def _put_in_tar(self, item, tree):
654
 
        """See InventoryEntry._put_in_tar."""
655
 
        item.type = tarfile.SYMTYPE
656
 
        fileobj = None
657
 
        item.size = 0
658
 
        item.mode = 0755
659
 
        item.linkname = self.symlink_target
660
 
        return fileobj
661
 
 
662
 
    def _put_on_disk(self, fullpath, tree):
663
 
        """See InventoryEntry._put_on_disk."""
664
 
        try:
665
 
            os.symlink(self.symlink_target, fullpath)
666
 
        except OSError,e:
667
 
            raise BzrError("Failed to create symlink %r -> %r, error: %s" % (fullpath, self.symlink_target, e))
668
 
 
669
 
    def _read_tree_state(self, path, work_tree):
670
 
        """See InventoryEntry._read_tree_state."""
671
 
        self.symlink_target = work_tree.get_symlink_target(self.file_id)
672
 
 
673
 
    def _forget_tree_state(self):
674
 
        self.symlink_target = None
675
 
 
676
 
    def _unchanged(self, previous_ie):
677
 
        """See InventoryEntry._unchanged."""
678
 
        compatible = super(InventoryLink, self)._unchanged(previous_ie)
679
 
        if self.symlink_target != previous_ie.symlink_target:
680
 
            compatible = False
681
 
        return compatible
682
 
 
683
 
 
684
 
class TreeReference(InventoryEntry):
685
 
    
686
 
    kind = 'tree-reference'
687
 
    
688
 
    def __init__(self, file_id, name, parent_id, revision=None,
689
 
                 reference_revision=None):
690
 
        InventoryEntry.__init__(self, file_id, name, parent_id)
691
 
        self.revision = revision
692
 
        self.reference_revision = reference_revision
693
 
 
694
 
    def copy(self):
695
 
        return TreeReference(self.file_id, self.name, self.parent_id,
696
 
                             self.revision, self.reference_revision)
697
 
 
698
 
    def _read_tree_state(self, path, work_tree):
699
 
        """Populate fields in the inventory entry from the given tree.
700
 
        """
701
 
        self.reference_revision = work_tree.get_reference_revision(
702
 
            self.file_id, path)
703
 
 
704
 
    def _forget_tree_state(self):
705
 
        self.reference_revision = None 
706
 
 
707
 
    def _unchanged(self, previous_ie):
708
 
        """See InventoryEntry._unchanged."""
709
 
        compatible = super(TreeReference, self)._unchanged(previous_ie)
710
 
        if self.reference_revision != previous_ie.reference_revision:
711
 
            compatible = False
712
 
        return compatible
713
 
 
714
246
 
715
247
class Inventory(object):
716
248
    """Inventory of versioned files in a tree.
730
262
    inserted, other than through the Inventory API.
731
263
 
732
264
    >>> inv = Inventory()
733
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
734
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
265
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
735
266
    >>> inv['123-123'].name
736
267
    'hello.c'
737
268
 
745
276
    May also look up by name:
746
277
 
747
278
    >>> [x[0] for x in inv.iter_entries()]
748
 
    ['', u'hello.c']
 
279
    ['hello.c']
749
280
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
750
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
751
 
    Traceback (most recent call last):
752
 
    BzrError: parent_id {TREE_ROOT} not in inventory
753
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', 'TREE_ROOT-12345678-12345678'))
754
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678', sha1=None, len=None)
 
281
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
755
282
    """
756
 
    def __init__(self, root_id=ROOT_ID, revision_id=None):
 
283
    def __init__(self, root_id=ROOT_ID):
757
284
        """Create or read an inventory.
758
285
 
759
286
        If a working directory is specified, the inventory is read
763
290
        The inventory is created with a default root directory, with
764
291
        an id of None.
765
292
        """
766
 
        if root_id is not None:
767
 
            self._set_root(InventoryDirectory(root_id, u'', None))
768
 
        else:
769
 
            self.root = None
770
 
            self._byid = {}
771
 
        self.revision_id = revision_id
772
 
 
773
 
    def __repr__(self):
774
 
        return "<Inventory object at %x, contents=%r>" % (id(self), self._byid)
775
 
 
776
 
    def apply_delta(self, delta):
777
 
        """Apply a delta to this inventory.
778
 
 
779
 
        :param delta: A list of changes to apply. After all the changes are
780
 
            applied the final inventory must be internally consistent, but it
781
 
            is ok to supply changes which, if only half-applied would have an
782
 
            invalid result - such as supplying two changes which rename two
783
 
            files, 'A' and 'B' with each other : [('A', 'B', 'A-id', a_entry),
784
 
            ('B', 'A', 'B-id', b_entry)].
785
 
 
786
 
            Each change is a tuple, of the form (old_path, new_path, file_id,
787
 
            new_entry).
788
 
            
789
 
            When new_path is None, the change indicates the removal of an entry
790
 
            from the inventory and new_entry will be ignored (using None is
791
 
            appropriate). If new_path is not None, then new_entry must be an
792
 
            InventoryEntry instance, which will be incorporated into the
793
 
            inventory (and replace any existing entry with the same file id).
794
 
            
795
 
            When old_path is None, the change indicates the addition of
796
 
            a new entry to the inventory.
797
 
            
798
 
            When neither new_path nor old_path are None, the change is a
799
 
            modification to an entry, such as a rename, reparent, kind change
800
 
            etc. 
801
 
 
802
 
            The children attribute of new_entry is ignored. This is because
803
 
            this method preserves children automatically across alterations to
804
 
            the parent of the children, and cases where the parent id of a
805
 
            child is changing require the child to be passed in as a separate
806
 
            change regardless. E.g. in the recursive deletion of a directory -
807
 
            the directory's children must be included in the delta, or the
808
 
            final inventory will be invalid.
809
 
        """
810
 
        children = {}
811
 
        # Remove all affected items which were in the original inventory,
812
 
        # starting with the longest paths, thus ensuring parents are examined
813
 
        # after their children, which means that everything we examine has no
814
 
        # modified children remaining by the time we examine it.
815
 
        for old_path, file_id in sorted(((op, f) for op, np, f, e in delta
816
 
                                        if op is not None), reverse=True):
817
 
            if file_id not in self:
818
 
                # adds come later
819
 
                continue
820
 
            # Preserve unaltered children of file_id for later reinsertion.
821
 
            file_id_children = getattr(self[file_id], 'children', {})
822
 
            if len(file_id_children):
823
 
                children[file_id] = file_id_children
824
 
            # Remove file_id and the unaltered children. If file_id is not
825
 
            # being deleted it will be reinserted back later.
826
 
            self.remove_recursive_id(file_id)
827
 
        # Insert all affected which should be in the new inventory, reattaching
828
 
        # their children if they had any. This is done from shortest path to
829
 
        # longest, ensuring that items which were modified and whose parents in
830
 
        # the resulting inventory were also modified, are inserted after their
831
 
        # parents.
832
 
        for new_path, new_entry in sorted((np, e) for op, np, f, e in
833
 
                                          delta if np is not None):
834
 
            if new_entry.kind == 'directory':
835
 
                # Pop the child which to allow detection of children whose
836
 
                # parents were deleted and which were not reattached to a new
837
 
                # parent.
838
 
                new_entry.children = children.pop(new_entry.file_id, {})
839
 
            self.add(new_entry)
840
 
        if len(children):
841
 
            # Get the parent id that was deleted
842
 
            parent_id, children = children.popitem()
843
 
            raise errors.InconsistentDelta("<deleted>", parent_id,
844
 
                "The file id was deleted but its children were not deleted.")
845
 
 
846
 
    def _set_root(self, ie):
847
 
        self.root = ie
 
293
        # We are letting Branch(init=True) create a unique inventory
 
294
        # root id. Rather than generating a random one here.
 
295
        #if root_id is None:
 
296
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
 
297
        self.root = RootEntry(root_id)
848
298
        self._byid = {self.root.file_id: self.root}
849
299
 
850
 
    def copy(self):
851
 
        # TODO: jam 20051218 Should copy also copy the revision_id?
852
 
        entries = self.iter_entries()
853
 
        if self.root is None:
854
 
            return Inventory(root_id=None)
855
 
        other = Inventory(entries.next()[1].file_id)
856
 
        other.root.revision = self.root.revision
857
 
        # copy recursively so we know directories will be added before
858
 
        # their children.  There are more efficient ways than this...
859
 
        for path, entry in entries:
860
 
            other.add(entry.copy())
861
 
        return other
862
300
 
863
301
    def __iter__(self):
864
302
        return iter(self._byid)
865
303
 
 
304
 
866
305
    def __len__(self):
867
306
        """Returns number of entries."""
868
307
        return len(self._byid)
869
308
 
 
309
 
870
310
    def iter_entries(self, from_dir=None):
871
311
        """Return (path, entry) pairs, in order by name."""
872
 
        if from_dir is None:
873
 
            if self.root is None:
874
 
                return
875
 
            from_dir = self.root
876
 
            yield '', self.root
877
 
        elif isinstance(from_dir, basestring):
878
 
            from_dir = self._byid[from_dir]
879
 
            
880
 
        # unrolling the recursive called changed the time from
881
 
        # 440ms/663ms (inline/total) to 116ms/116ms
882
 
        children = from_dir.children.items()
883
 
        children.sort()
884
 
        children = collections.deque(children)
885
 
        stack = [(u'', children)]
886
 
        while stack:
887
 
            from_dir_relpath, children = stack[-1]
888
 
 
889
 
            while children:
890
 
                name, ie = children.popleft()
891
 
 
892
 
                # we know that from_dir_relpath never ends in a slash
893
 
                # and 'f' doesn't begin with one, we can do a string op, rather
894
 
                # than the checks of pathjoin(), though this means that all paths
895
 
                # start with a slash
896
 
                path = from_dir_relpath + '/' + name
897
 
 
898
 
                yield path[1:], ie
899
 
 
900
 
                if ie.kind != 'directory':
901
 
                    continue
902
 
 
903
 
                # But do this child first
904
 
                new_children = ie.children.items()
905
 
                new_children.sort()
906
 
                new_children = collections.deque(new_children)
907
 
                stack.append((path, new_children))
908
 
                # Break out of inner loop, so that we start outer loop with child
909
 
                break
910
 
            else:
911
 
                # if we finished all children, pop it off the stack
912
 
                stack.pop()
913
 
 
914
 
    def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None,
915
 
        yield_parents=False):
916
 
        """Iterate over the entries in a directory first order.
917
 
 
918
 
        This returns all entries for a directory before returning
919
 
        the entries for children of a directory. This is not
920
 
        lexicographically sorted order, and is a hybrid between
921
 
        depth-first and breadth-first.
922
 
 
923
 
        :param yield_parents: If True, yield the parents from the root leading
924
 
            down to specific_file_ids that have been requested. This has no
925
 
            impact if specific_file_ids is None.
926
 
        :return: This yields (path, entry) pairs
927
 
        """
928
 
        if specific_file_ids and not isinstance(specific_file_ids, set):
929
 
            specific_file_ids = set(specific_file_ids)
930
 
        # TODO? Perhaps this should return the from_dir so that the root is
931
 
        # yielded? or maybe an option?
932
 
        if from_dir is None:
933
 
            if self.root is None:
934
 
                return
935
 
            # Optimize a common case
936
 
            if (not yield_parents and specific_file_ids is not None and
937
 
                len(specific_file_ids) == 1):
938
 
                file_id = list(specific_file_ids)[0]
939
 
                if file_id in self:
940
 
                    yield self.id2path(file_id), self[file_id]
941
 
                return 
942
 
            from_dir = self.root
943
 
            if (specific_file_ids is None or yield_parents or
944
 
                self.root.file_id in specific_file_ids):
945
 
                yield u'', self.root
946
 
        elif isinstance(from_dir, basestring):
947
 
            from_dir = self._byid[from_dir]
948
 
 
949
 
        if specific_file_ids is not None:
950
 
            # TODO: jam 20070302 This could really be done as a loop rather
951
 
            #       than a bunch of recursive calls.
952
 
            parents = set()
953
 
            byid = self._byid
954
 
            def add_ancestors(file_id):
955
 
                if file_id not in byid:
956
 
                    return
957
 
                parent_id = byid[file_id].parent_id
958
 
                if parent_id is None:
959
 
                    return
960
 
                if parent_id not in parents:
961
 
                    parents.add(parent_id)
962
 
                    add_ancestors(parent_id)
963
 
            for file_id in specific_file_ids:
964
 
                add_ancestors(file_id)
965
 
        else:
966
 
            parents = None
967
 
            
968
 
        stack = [(u'', from_dir)]
969
 
        while stack:
970
 
            cur_relpath, cur_dir = stack.pop()
971
 
 
972
 
            child_dirs = []
973
 
            for child_name, child_ie in sorted(cur_dir.children.iteritems()):
974
 
 
975
 
                child_relpath = cur_relpath + child_name
976
 
 
977
 
                if (specific_file_ids is None or 
978
 
                    child_ie.file_id in specific_file_ids or
979
 
                    (yield_parents and child_ie.file_id in parents)):
980
 
                    yield child_relpath, child_ie
981
 
 
982
 
                if child_ie.kind == 'directory':
983
 
                    if parents is None or child_ie.file_id in parents:
984
 
                        child_dirs.append((child_relpath+'/', child_ie))
985
 
            stack.extend(reversed(child_dirs))
986
 
 
987
 
    def make_entry(self, kind, name, parent_id, file_id=None):
988
 
        """Simple thunk to bzrlib.inventory.make_entry."""
989
 
        return make_entry(kind, name, parent_id, file_id)
 
312
        if from_dir == None:
 
313
            assert self.root
 
314
            from_dir = self.root
 
315
        elif isinstance(from_dir, basestring):
 
316
            from_dir = self._byid[from_dir]
 
317
            
 
318
        kids = from_dir.children.items()
 
319
        kids.sort()
 
320
        for name, ie in kids:
 
321
            yield name, ie
 
322
            if ie.kind == 'directory':
 
323
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
 
324
                    yield os.path.join(name, cn), cie
 
325
 
990
326
 
991
327
    def entries(self):
992
328
        """Return list of (path, ie) for all entries except the root.
998
334
            kids = dir_ie.children.items()
999
335
            kids.sort()
1000
336
            for name, ie in kids:
1001
 
                child_path = osutils.pathjoin(dir_path, name)
 
337
                child_path = os.path.join(dir_path, name)
1002
338
                accum.append((child_path, ie))
1003
339
                if ie.kind == 'directory':
1004
340
                    descend(ie, child_path)
1005
341
 
1006
 
        descend(self.root, u'')
 
342
        descend(self.root, '')
1007
343
        return accum
1008
344
 
 
345
 
1009
346
    def directories(self):
1010
347
        """Return (path, entry) pairs for all directories, including the root.
1011
348
        """
1017
354
            kids.sort()
1018
355
 
1019
356
            for name, child_ie in kids:
1020
 
                child_path = osutils.pathjoin(parent_path, name)
 
357
                child_path = os.path.join(parent_path, name)
1021
358
                descend(child_ie, child_path)
1022
 
        descend(self.root, u'')
 
359
        descend(self.root, '')
1023
360
        return accum
1024
361
        
 
362
 
 
363
 
1025
364
    def __contains__(self, file_id):
1026
365
        """True if this entry contains a file with given id.
1027
366
 
1028
367
        >>> inv = Inventory()
1029
 
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1030
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
368
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
1031
369
        >>> '123' in inv
1032
370
        True
1033
371
        >>> '456' in inv
1034
372
        False
1035
373
        """
1036
 
        return (file_id in self._byid)
 
374
        return file_id in self._byid
 
375
 
1037
376
 
1038
377
    def __getitem__(self, file_id):
1039
378
        """Return the entry for given file_id.
1040
379
 
1041
380
        >>> inv = Inventory()
1042
 
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
1043
 
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
381
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
1044
382
        >>> inv['123123'].name
1045
383
        'hello.c'
1046
384
        """
1047
385
        try:
1048
386
            return self._byid[file_id]
1049
387
        except KeyError:
1050
 
            # really we're passing an inventory, not a tree...
1051
 
            raise errors.NoSuchId(self, file_id)
 
388
            if file_id == None:
 
389
                raise BzrError("can't look up file_id None")
 
390
            else:
 
391
                raise BzrError("file_id {%s} not in inventory" % file_id)
 
392
 
1052
393
 
1053
394
    def get_file_kind(self, file_id):
1054
395
        return self._byid[file_id].kind
1056
397
    def get_child(self, parent_id, filename):
1057
398
        return self[parent_id].children.get(filename)
1058
399
 
1059
 
    def _add_child(self, entry):
1060
 
        """Add an entry to the inventory, without adding it to its parent"""
1061
 
        if entry.file_id in self._byid:
1062
 
            raise BzrError("inventory already contains entry with id {%s}" %
1063
 
                           entry.file_id)
1064
 
        self._byid[entry.file_id] = entry
1065
 
        for child in getattr(entry, 'children', {}).itervalues():
1066
 
            self._add_child(child)
1067
 
        return entry
1068
400
 
1069
401
    def add(self, entry):
1070
402
        """Add entry to inventory.
1071
403
 
1072
404
        To add  a file to a branch ready to be committed, use Branch.add,
1073
 
        which calls this.
1074
 
 
1075
 
        Returns the new entry object.
1076
 
        """
 
405
        which calls this."""
1077
406
        if entry.file_id in self._byid:
1078
 
            raise errors.DuplicateFileId(entry.file_id,
1079
 
                                         self._byid[entry.file_id])
1080
 
 
1081
 
        if entry.parent_id is None:
1082
 
            self.root = entry
1083
 
        else:
1084
 
            try:
1085
 
                parent = self._byid[entry.parent_id]
1086
 
            except KeyError:
1087
 
                raise BzrError("parent_id {%s} not in inventory" %
1088
 
                               entry.parent_id)
1089
 
 
1090
 
            if entry.name in parent.children:
1091
 
                raise BzrError("%s is already versioned" %
1092
 
                        osutils.pathjoin(self.id2path(parent.file_id),
1093
 
                        entry.name).encode('utf-8'))
1094
 
            parent.children[entry.name] = entry
1095
 
        return self._add_child(entry)
1096
 
 
1097
 
    def add_path(self, relpath, kind, file_id=None, parent_id=None):
 
407
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
 
408
 
 
409
        if entry.parent_id == ROOT_ID or entry.parent_id is None:
 
410
            entry.parent_id = self.root.file_id
 
411
 
 
412
        try:
 
413
            parent = self._byid[entry.parent_id]
 
414
        except KeyError:
 
415
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
 
416
 
 
417
        if parent.children.has_key(entry.name):
 
418
            raise BzrError("%s is already versioned" %
 
419
                    appendpath(self.id2path(parent.file_id), entry.name))
 
420
 
 
421
        self._byid[entry.file_id] = entry
 
422
        parent.children[entry.name] = entry
 
423
 
 
424
 
 
425
    def add_path(self, relpath, kind, file_id=None):
1098
426
        """Add entry from a path.
1099
427
 
1100
 
        The immediate parent must already be versioned.
1101
 
 
1102
 
        Returns the new entry object."""
 
428
        The immediate parent must already be versioned"""
 
429
        from bzrlib.errors import NotVersionedError
1103
430
        
1104
 
        parts = osutils.splitpath(relpath)
1105
 
 
 
431
        parts = bzrlib.osutils.splitpath(relpath)
1106
432
        if len(parts) == 0:
1107
 
            if file_id is None:
1108
 
                file_id = generate_ids.gen_root_id()
1109
 
            self.root = InventoryDirectory(file_id, '', None)
1110
 
            self._byid = {self.root.file_id: self.root}
1111
 
            return self.root
1112
 
        else:
1113
 
            parent_path = parts[:-1]
1114
 
            parent_id = self.path2id(parent_path)
1115
 
            if parent_id is None:
1116
 
                raise errors.NotVersionedError(path=parent_path)
1117
 
        ie = make_entry(kind, parts[-1], parent_id, file_id)
 
433
            raise BzrError("cannot re-add root of inventory")
 
434
 
 
435
        if file_id == None:
 
436
            from bzrlib.branch import gen_file_id
 
437
            file_id = gen_file_id(relpath)
 
438
 
 
439
        parent_path = parts[:-1]
 
440
        parent_id = self.path2id(parent_path)
 
441
        if parent_id == None:
 
442
            raise NotVersionedError(parent_path)
 
443
 
 
444
        ie = InventoryEntry(file_id, parts[-1],
 
445
                            kind=kind, parent_id=parent_id)
1118
446
        return self.add(ie)
1119
447
 
 
448
 
1120
449
    def __delitem__(self, file_id):
1121
450
        """Remove entry by id.
1122
451
 
1123
452
        >>> inv = Inventory()
1124
 
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1125
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
453
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
1126
454
        >>> '123' in inv
1127
455
        True
1128
456
        >>> del inv['123']
1130
458
        False
1131
459
        """
1132
460
        ie = self[file_id]
 
461
 
 
462
        assert self[ie.parent_id].children[ie.name] == ie
 
463
        
 
464
        # TODO: Test deleting all children; maybe hoist to a separate
 
465
        # deltree method?
 
466
        if ie.kind == 'directory':
 
467
            for cie in ie.children.values():
 
468
                del self[cie.file_id]
 
469
            del ie.children
 
470
 
1133
471
        del self._byid[file_id]
1134
 
        if ie.parent_id is not None:
1135
 
            del self[ie.parent_id].children[ie.name]
 
472
        del self[ie.parent_id].children[ie.name]
 
473
 
 
474
 
 
475
    def to_element(self):
 
476
        """Convert to XML Element"""
 
477
        from bzrlib.xml import Element
 
478
        
 
479
        e = Element('inventory')
 
480
        e.text = '\n'
 
481
        if self.root.file_id not in (None, ROOT_ID):
 
482
            e.set('file_id', self.root.file_id)
 
483
        for path, ie in self.iter_entries():
 
484
            e.append(ie.to_element())
 
485
        return e
 
486
    
 
487
 
 
488
    def from_element(cls, elt):
 
489
        """Construct from XML Element
 
490
        
 
491
        >>> inv = Inventory()
 
492
        >>> inv.add(InventoryEntry('foo.c-123981239', 'foo.c', 'file', ROOT_ID))
 
493
        >>> elt = inv.to_element()
 
494
        >>> inv2 = Inventory.from_element(elt)
 
495
        >>> inv2 == inv
 
496
        True
 
497
        """
 
498
        # XXXX: doctest doesn't run this properly under python2.3
 
499
        assert elt.tag == 'inventory'
 
500
        root_id = elt.get('file_id') or ROOT_ID
 
501
        o = cls(root_id)
 
502
        for e in elt:
 
503
            ie = InventoryEntry.from_element(e)
 
504
            if ie.parent_id == ROOT_ID:
 
505
                ie.parent_id = root_id
 
506
            o.add(ie)
 
507
        return o
 
508
        
 
509
    from_element = classmethod(from_element)
 
510
 
1136
511
 
1137
512
    def __eq__(self, other):
1138
513
        """Compare two sets by comparing their contents.
1141
516
        >>> i2 = Inventory()
1142
517
        >>> i1 == i2
1143
518
        True
1144
 
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
1145
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
519
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
1146
520
        >>> i1 == i2
1147
521
        False
1148
 
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
1149
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
522
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
1150
523
        >>> i1 == i2
1151
524
        True
1152
525
        """
1153
526
        if not isinstance(other, Inventory):
1154
527
            return NotImplemented
1155
528
 
 
529
        if len(self._byid) != len(other._byid):
 
530
            # shortcut: obviously not the same
 
531
            return False
 
532
 
1156
533
        return self._byid == other._byid
1157
534
 
 
535
 
1158
536
    def __ne__(self, other):
1159
 
        return not self.__eq__(other)
 
537
        return not (self == other)
 
538
 
1160
539
 
1161
540
    def __hash__(self):
1162
541
        raise ValueError('not hashable')
1163
542
 
1164
 
    def _iter_file_id_parents(self, file_id):
1165
 
        """Yield the parents of file_id up to the root."""
1166
 
        while file_id is not None:
1167
 
            try:
1168
 
                ie = self._byid[file_id]
1169
 
            except KeyError:
1170
 
                raise errors.NoSuchId(tree=None, file_id=file_id)
1171
 
            yield ie
1172
 
            file_id = ie.parent_id
 
543
 
1173
544
 
1174
545
    def get_idpath(self, file_id):
1175
546
        """Return a list of file_ids for the path to an entry.
1180
551
        root directory as depth 1.
1181
552
        """
1182
553
        p = []
1183
 
        for parent in self._iter_file_id_parents(file_id):
1184
 
            p.insert(0, parent.file_id)
 
554
        while file_id != None:
 
555
            try:
 
556
                ie = self._byid[file_id]
 
557
            except KeyError:
 
558
                raise BzrError("file_id {%s} not found in inventory" % file_id)
 
559
            p.insert(0, ie.file_id)
 
560
            file_id = ie.parent_id
1185
561
        return p
1186
562
 
 
563
 
1187
564
    def id2path(self, file_id):
1188
 
        """Return as a string the path to file_id.
1189
 
        
1190
 
        >>> i = Inventory()
1191
 
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
1192
 
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
1193
 
        >>> print i.id2path('foo-id')
1194
 
        src/foo.c
1195
 
        """
 
565
        """Return as a list the path to file_id."""
 
566
 
1196
567
        # get all names, skipping root
1197
 
        return '/'.join(reversed(
1198
 
            [parent.name for parent in 
1199
 
             self._iter_file_id_parents(file_id)][:-1]))
 
568
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
 
569
        return os.sep.join(p)
1200
570
            
 
571
 
 
572
 
1201
573
    def path2id(self, name):
1202
574
        """Walk down through directories to return entry of last component.
1203
575
 
1207
579
        This returns the entry of the last component in the path,
1208
580
        which may be either a file or a directory.
1209
581
 
1210
 
        Returns None IFF the path is not found.
 
582
        Returns None iff the path is not found.
1211
583
        """
1212
 
        if isinstance(name, basestring):
1213
 
            name = osutils.splitpath(name)
 
584
        if isinstance(name, types.StringTypes):
 
585
            name = splitpath(name)
1214
586
 
1215
 
        # mutter("lookup path %r" % name)
 
587
        mutter("lookup path %r" % name)
1216
588
 
1217
589
        parent = self.root
1218
 
        if parent is None:
1219
 
            return None
1220
590
        for f in name:
1221
591
            try:
1222
 
                children = getattr(parent, 'children', None)
1223
 
                if children is None:
1224
 
                    return None
1225
 
                cie = children[f]
 
592
                cie = parent.children[f]
 
593
                assert cie.name == f
 
594
                assert cie.parent_id == parent.file_id
1226
595
                parent = cie
1227
596
            except KeyError:
1228
597
                # or raise an error?
1230
599
 
1231
600
        return parent.file_id
1232
601
 
 
602
 
1233
603
    def has_filename(self, names):
1234
604
        return bool(self.path2id(names))
1235
605
 
 
606
 
1236
607
    def has_id(self, file_id):
1237
 
        return (file_id in self._byid)
1238
 
 
1239
 
    def _make_delta(self, old):
1240
 
        """Make an inventory delta from two inventories."""
1241
 
        old_getter = getattr(old, '_byid', old)
1242
 
        new_getter = self._byid
1243
 
        old_ids = set(old_getter)
1244
 
        new_ids = set(new_getter)
1245
 
        adds = new_ids - old_ids
1246
 
        deletes = old_ids - new_ids
1247
 
        if not adds and not deletes:
1248
 
            common = new_ids
1249
 
        else:
1250
 
            common = old_ids.intersection(new_ids)
1251
 
        delta = []
1252
 
        for file_id in deletes:
1253
 
            delta.append((old.id2path(file_id), None, file_id, None))
1254
 
        for file_id in adds:
1255
 
            delta.append((None, self.id2path(file_id), file_id, self[file_id]))
1256
 
        for file_id in common:
1257
 
            new_ie = new_getter[file_id]
1258
 
            old_ie = old_getter[file_id]
1259
 
            # If xml_serializer returns the cached InventoryEntries (rather
1260
 
            # than always doing .copy()), inlining the 'is' check saves 2.7M
1261
 
            # calls to __eq__.  Under lsprof this saves 20s => 6s.
1262
 
            # It is a minor improvement without lsprof.
1263
 
            if old_ie is new_ie or old_ie == new_ie:
1264
 
                continue
1265
 
            else:
1266
 
                delta.append((old.id2path(file_id), self.id2path(file_id),
1267
 
                              file_id, new_ie))
1268
 
        return delta
1269
 
 
1270
 
    def remove_recursive_id(self, file_id):
1271
 
        """Remove file_id, and children, from the inventory.
1272
 
 
1273
 
        :param file_id: A file_id to remove.
1274
 
        """
1275
 
        to_find_delete = [self._byid[file_id]]
1276
 
        to_delete = []
1277
 
        while to_find_delete:
1278
 
            ie = to_find_delete.pop()
1279
 
            to_delete.append(ie.file_id)
1280
 
            if ie.kind == 'directory':
1281
 
                to_find_delete.extend(ie.children.values())
1282
 
        for file_id in reversed(to_delete):
1283
 
            ie = self[file_id]
1284
 
            del self._byid[file_id]
1285
 
        if ie.parent_id is not None:
1286
 
            del self[ie.parent_id].children[ie.name]
1287
 
        else:
1288
 
            self.root = None
 
608
        return self._byid.has_key(file_id)
 
609
 
1289
610
 
1290
611
    def rename(self, file_id, new_parent_id, new_name):
1291
612
        """Move a file within the inventory.
1292
613
 
1293
614
        This can change either the name, or the parent, or both.
1294
615
 
1295
 
        This does not move the working file.
1296
 
        """
1297
 
        new_name = ensure_normalized_name(new_name)
 
616
        This does not move the working file."""
1298
617
        if not is_valid_name(new_name):
1299
618
            raise BzrError("not an acceptable filename: %r" % new_name)
1300
619
 
1318
637
        file_ie.name = new_name
1319
638
        file_ie.parent_id = new_parent_id
1320
639
 
1321
 
    def is_root(self, file_id):
1322
 
        return self.root is not None and file_id == self.root.file_id
1323
 
 
1324
 
 
1325
 
entry_factory = {
1326
 
    'directory': InventoryDirectory,
1327
 
    'file': InventoryFile,
1328
 
    'symlink': InventoryLink,
1329
 
    'tree-reference': TreeReference
1330
 
}
1331
 
 
1332
 
def make_entry(kind, name, parent_id, file_id=None):
1333
 
    """Create an inventory entry.
1334
 
 
1335
 
    :param kind: the type of inventory entry to create.
1336
 
    :param name: the basename of the entry.
1337
 
    :param parent_id: the parent_id of the entry.
1338
 
    :param file_id: the file_id to use. if None, one will be created.
1339
 
    """
1340
 
    if file_id is None:
1341
 
        file_id = generate_ids.gen_file_id(name)
1342
 
    name = ensure_normalized_name(name)
1343
 
    try:
1344
 
        factory = entry_factory[kind]
1345
 
    except KeyError:
1346
 
        raise BzrError("unknown kind %r" % kind)
1347
 
    return factory(file_id, name, parent_id)
1348
 
 
1349
 
 
1350
 
def ensure_normalized_name(name):
1351
 
    """Normalize name.
1352
 
 
1353
 
    :raises InvalidNormalization: When name is not normalized, and cannot be
1354
 
        accessed on this platform by the normalized path.
1355
 
    :return: The NFC normalised version of name.
1356
 
    """
1357
 
    #------- This has been copied to bzrlib.dirstate.DirState.add, please
1358
 
    # keep them synchronised.
1359
 
    # we dont import normalized_filename directly because we want to be
1360
 
    # able to change the implementation at runtime for tests.
1361
 
    norm_name, can_access = osutils.normalized_filename(name)
1362
 
    if norm_name != name:
1363
 
        if can_access:
1364
 
            return norm_name
1365
 
        else:
1366
 
            # TODO: jam 20060701 This would probably be more useful
1367
 
            #       if the error was raised with the full path
1368
 
            raise errors.InvalidNormalization(name)
1369
 
    return name
1370
 
 
1371
 
 
1372
 
_NAME_RE = None
 
640
 
 
641
 
 
642
 
 
643
_NAME_RE = re.compile(r'^[^/\\]+$')
1373
644
 
1374
645
def is_valid_name(name):
1375
 
    global _NAME_RE
1376
 
    if _NAME_RE is None:
1377
 
        _NAME_RE = re.compile(r'^[^/\\]+$')
1378
 
        
1379
646
    return bool(_NAME_RE.match(name))