~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Martin Pool
  • Date: 2005-09-16 07:03:16 UTC
  • Revision ID: mbp@sourcefrog.net-20050916070316-29f4b33b6f86fdc3
- cElementTree is typically not installed in util

  this was probably causing it to not be imported in many cases

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 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
17
 
22
18
# TODO: Maybe also keep the full path of the entry, and the children?
23
19
# But those depend on its position within a particular inventory, and
24
20
# it would be nice not to need to hold the backpointer here.
25
21
 
 
22
# TODO: Perhaps split InventoryEntry into subclasses for files,
 
23
# directories, etc etc.
 
24
 
 
25
 
26
26
# This should really be an id randomly assigned when the tree is
27
27
# created, but it's not for now.
28
28
ROOT_ID = "TREE_ROOT"
29
29
 
30
30
 
31
 
import collections
32
 
import os.path
33
 
import re
34
 
import sys
35
 
import tarfile
36
 
import types
37
 
from warnings import warn
 
31
import sys, os.path, types, re
38
32
 
39
33
import bzrlib
40
 
from bzrlib import errors, osutils
41
 
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
42
 
                            pathjoin, sha_strings)
43
 
from bzrlib.errors import (NotVersionedError, InvalidEntryName,
44
 
                           BzrError, BzrCheckError, BinaryFile)
 
34
from bzrlib.errors import BzrError, BzrCheckError
 
35
 
 
36
from bzrlib.osutils import uuid, quotefn, splitpath, joinpath, appendpath
45
37
from bzrlib.trace import mutter
46
 
 
 
38
from bzrlib.errors import NotVersionedError
 
39
        
47
40
 
48
41
class InventoryEntry(object):
49
42
    """Description of a versioned file.
56
49
    name
57
50
        (within the parent directory)
58
51
 
 
52
    kind
 
53
        'directory' or 'file'
 
54
 
59
55
    parent_id
60
56
        file_id of the parent directory, or ROOT_ID
61
57
 
62
 
    revision
63
 
        the revision_id in which this variation of this file was 
64
 
        introduced.
65
 
 
66
 
    executable
67
 
        Indicates that this file should be executable on systems
68
 
        that support it.
 
58
    entry_version
 
59
        the revision_id in which the name or parent of this file was
 
60
        last changed
69
61
 
70
62
    text_sha1
71
63
        sha-1 of the text of the file
73
65
    text_size
74
66
        size in bytes of the text of the file
75
67
        
 
68
    text_version
 
69
        the revision_id in which the text of this file was introduced
 
70
 
76
71
    (reading a version 4 tree created a text_id field.)
77
72
 
78
73
    >>> i = Inventory()
79
74
    >>> i.path2id('')
80
75
    'TREE_ROOT'
81
 
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
82
 
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
83
 
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
84
 
    InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
85
 
    >>> shouldbe = {0: '', 1: 'src', 2: pathjoin('src','hello.c')}
86
 
    >>> for ix, j in enumerate(i.iter_entries()):
87
 
    ...   print (j[0] == shouldbe[ix], j[1])
 
76
    >>> i.add(InventoryEntry('123', 'src', 'directory', ROOT_ID))
 
77
    InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT')
 
78
    >>> i.add(InventoryEntry('2323', 'hello.c', 'file', parent_id='123'))
 
79
    InventoryEntry('2323', 'hello.c', kind='file', parent_id='123')
 
80
    >>> for j in i.iter_entries():
 
81
    ...   print j
88
82
    ... 
89
 
    (True, InventoryDirectory('TREE_ROOT', '', parent_id=None, revision=None))
90
 
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
91
 
    (True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None))
92
 
    >>> i.add(InventoryFile('2323', 'bye.c', '123'))
 
83
    ('src', InventoryEntry('123', 'src', kind='directory', parent_id='TREE_ROOT'))
 
84
    ('src/hello.c', InventoryEntry('2323', 'hello.c', kind='file', parent_id='123'))
 
85
    >>> i.add(InventoryEntry('2323', 'bye.c', 'file', '123'))
93
86
    Traceback (most recent call last):
94
87
    ...
95
88
    BzrError: inventory already contains entry with id {2323}
96
 
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
97
 
    InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
98
 
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
99
 
    InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
 
89
    >>> i.add(InventoryEntry('2324', 'bye.c', 'file', '123'))
 
90
    InventoryEntry('2324', 'bye.c', kind='file', parent_id='123')
 
91
    >>> i.add(InventoryEntry('2325', 'wibble', 'directory', '123'))
 
92
    InventoryEntry('2325', 'wibble', kind='directory', parent_id='123')
100
93
    >>> i.path2id('src/wibble')
101
94
    '2325'
102
95
    >>> '2325' in i
103
96
    True
104
 
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
105
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
97
    >>> i.add(InventoryEntry('2326', 'wibble.c', 'file', '2325'))
 
98
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
106
99
    >>> i['2326']
107
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
108
 
    >>> for path, entry in i.iter_entries():
109
 
    ...     print path
110
 
    ...     assert i.path2id(path)
 
100
    InventoryEntry('2326', 'wibble.c', kind='file', parent_id='2325')
 
101
    >>> for j in i.iter_entries():
 
102
    ...     print j[0]
 
103
    ...     assert i.path2id(j[0])
111
104
    ... 
112
 
    <BLANKLINE>
113
105
    src
114
106
    src/bye.c
115
107
    src/hello.c
118
110
    >>> i.id2path('2326')
119
111
    'src/wibble/wibble.c'
120
112
    """
121
 
 
122
 
    # Constants returned by describe_change()
123
 
    #
124
 
    # TODO: These should probably move to some kind of FileChangeDescription 
125
 
    # class; that's like what's inside a TreeDelta but we want to be able to 
126
 
    # generate them just for one file at a time.
127
 
    RENAMED = 'renamed'
128
 
    MODIFIED_AND_RENAMED = 'modified and renamed'
129
113
    
130
 
    __slots__ = []
131
 
 
132
 
    def detect_changes(self, old_entry):
133
 
        """Return a (text_modified, meta_modified) from this to old_entry.
134
 
        
135
 
        _read_tree_state must have been called on self and old_entry prior to 
136
 
        calling detect_changes.
137
 
        """
138
 
        return False, False
139
 
 
140
 
    def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
141
 
             output_to, reverse=False):
142
 
        """Perform a diff from this to to_entry.
143
 
 
144
 
        text_diff will be used for textual difference calculation.
145
 
        This is a template method, override _diff in child classes.
146
 
        """
147
 
        self._read_tree_state(tree.id2path(self.file_id), tree)
148
 
        if to_entry:
149
 
            # cannot diff from one kind to another - you must do a removal
150
 
            # and an addif they do not match.
151
 
            assert self.kind == to_entry.kind
152
 
            to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
153
 
                                      to_tree)
154
 
        self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
155
 
                   output_to, reverse)
156
 
 
157
 
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
158
 
             output_to, reverse=False):
159
 
        """Perform a diff between two entries of the same kind."""
160
 
 
161
 
    def find_previous_heads(self, previous_inventories,
162
 
                            versioned_file_store,
163
 
                            transaction,
164
 
                            entry_vf=None):
165
 
        """Return the revisions and entries that directly precede this.
166
 
 
167
 
        Returned as a map from revision to inventory entry.
168
 
 
169
 
        This is a map containing the file revisions in all parents
170
 
        for which the file exists, and its revision is not a parent of
171
 
        any other. If the file is new, the set will be empty.
172
 
 
173
 
        :param versioned_file_store: A store where ancestry data on this
174
 
                                     file id can be queried.
175
 
        :param transaction: The transaction that queries to the versioned 
176
 
                            file store should be completed under.
177
 
        :param entry_vf: The entry versioned file, if its already available.
178
 
        """
179
 
        def get_ancestors(weave, entry):
180
 
            return set(weave.get_ancestry(entry.revision))
181
 
        # revision:ie mapping for each ie found in previous_inventories.
182
 
        candidates = {}
183
 
        # revision:ie mapping with one revision for each head.
184
 
        heads = {}
185
 
        # revision: ancestor list for each head
186
 
        head_ancestors = {}
187
 
        # identify candidate head revision ids.
188
 
        for inv in previous_inventories:
189
 
            if self.file_id in inv:
190
 
                ie = inv[self.file_id]
191
 
                assert ie.file_id == self.file_id
192
 
                if ie.revision in candidates:
193
 
                    # same revision value in two different inventories:
194
 
                    # correct possible inconsistencies:
195
 
                    #     * there was a bug in revision updates with 'x' bit 
196
 
                    #       support.
197
 
                    try:
198
 
                        if candidates[ie.revision].executable != ie.executable:
199
 
                            candidates[ie.revision].executable = False
200
 
                            ie.executable = False
201
 
                    except AttributeError:
202
 
                        pass
203
 
                    # must now be the same.
204
 
                    assert candidates[ie.revision] == ie
205
 
                else:
206
 
                    # add this revision as a candidate.
207
 
                    candidates[ie.revision] = ie
208
 
 
209
 
        # common case optimisation
210
 
        if len(candidates) == 1:
211
 
            # if there is only one candidate revision found
212
 
            # then we can opening the versioned file to access ancestry:
213
 
            # there cannot be any ancestors to eliminate when there is 
214
 
            # only one revision available.
215
 
            heads[ie.revision] = ie
216
 
            return heads
217
 
 
218
 
        # eliminate ancestors amongst the available candidates:
219
 
        # heads are those that are not an ancestor of any other candidate
220
 
        # - this provides convergence at a per-file level.
221
 
        for ie in candidates.values():
222
 
            # may be an ancestor of a known head:
223
 
            already_present = 0 != len(
224
 
                [head for head in heads 
225
 
                 if ie.revision in head_ancestors[head]])
226
 
            if already_present:
227
 
                # an ancestor of an analyzed candidate.
228
 
                continue
229
 
            # not an ancestor of a known head:
230
 
            # load the versioned file for this file id if needed
231
 
            if entry_vf is None:
232
 
                entry_vf = versioned_file_store.get_weave_or_empty(
233
 
                    self.file_id, transaction)
234
 
            ancestors = get_ancestors(entry_vf, ie)
235
 
            # may knock something else out:
236
 
            check_heads = list(heads.keys())
237
 
            for head in check_heads:
238
 
                if head in ancestors:
239
 
                    # this previously discovered 'head' is not
240
 
                    # really a head - its an ancestor of the newly 
241
 
                    # found head,
242
 
                    heads.pop(head)
243
 
            head_ancestors[ie.revision] = ancestors
244
 
            heads[ie.revision] = ie
245
 
        return heads
246
 
 
247
 
    def get_tar_item(self, root, dp, now, tree):
248
 
        """Get a tarfile item and a file stream for its content."""
249
 
        item = tarfile.TarInfo(pathjoin(root, dp))
250
 
        # TODO: would be cool to actually set it to the timestamp of the
251
 
        # revision it was last changed
252
 
        item.mtime = now
253
 
        fileobj = self._put_in_tar(item, tree)
254
 
        return item, fileobj
255
 
 
256
 
    def has_text(self):
257
 
        """Return true if the object this entry represents has textual data.
258
 
 
259
 
        Note that textual data includes binary content.
260
 
 
261
 
        Also note that all entries get weave files created for them.
262
 
        This attribute is primarily used when upgrading from old trees that
263
 
        did not have the weave index for all inventory entries.
264
 
        """
265
 
        return False
266
 
 
267
 
    def __init__(self, file_id, name, parent_id, text_id=None):
 
114
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
115
                 'text_id', 'parent_id', 'children',
 
116
                 'text_version', 'entry_version', ]
 
117
 
 
118
 
 
119
    def __init__(self, file_id, name, kind, parent_id, text_id=None):
268
120
        """Create an InventoryEntry
269
121
        
270
122
        The filename must be a single component, relative to the
271
123
        parent directory; it cannot be a whole path or relative name.
272
124
 
273
 
        >>> e = InventoryFile('123', 'hello.c', ROOT_ID)
 
125
        >>> e = InventoryEntry('123', 'hello.c', 'file', ROOT_ID)
274
126
        >>> e.name
275
127
        'hello.c'
276
128
        >>> e.file_id
277
129
        '123'
278
 
        >>> e = InventoryFile('123', 'src/hello.c', ROOT_ID)
 
130
        >>> e = InventoryEntry('123', 'src/hello.c', 'file', ROOT_ID)
279
131
        Traceback (most recent call last):
280
 
        InvalidEntryName: Invalid entry name: src/hello.c
 
132
        BzrCheckError: InventoryEntry name 'src/hello.c' is invalid
281
133
        """
282
134
        assert isinstance(name, basestring), name
283
135
        if '/' in name or '\\' in name:
284
 
            raise InvalidEntryName(name=name)
285
 
        self.executable = False
286
 
        self.revision = None
 
136
            raise BzrCheckError('InventoryEntry name %r is invalid' % name)
 
137
        
 
138
        self.text_version = None
 
139
        self.entry_version = None
287
140
        self.text_sha1 = None
288
141
        self.text_size = None
289
142
        self.file_id = file_id
290
143
        self.name = name
 
144
        self.kind = kind
291
145
        self.text_id = text_id
292
146
        self.parent_id = parent_id
293
 
        self.symlink_target = None
294
 
 
295
 
    def kind_character(self):
296
 
        """Return a short kind indicator useful for appending to names."""
297
 
        raise BzrError('unknown kind %r' % self.kind)
298
 
 
299
 
    known_kinds = ('file', 'directory', 'symlink')
300
 
 
301
 
    def _put_in_tar(self, item, tree):
302
 
        """populate item for stashing in a tar, and return the content stream.
303
 
 
304
 
        If no content is available, return None.
305
 
        """
306
 
        raise BzrError("don't know how to export {%s} of kind %r" %
307
 
                       (self.file_id, self.kind))
308
 
 
309
 
    def put_on_disk(self, dest, dp, tree):
310
 
        """Create a representation of self on disk in the prefix dest.
311
 
        
312
 
        This is a template method - implement _put_on_disk in subclasses.
313
 
        """
314
 
        fullpath = pathjoin(dest, dp)
315
 
        self._put_on_disk(fullpath, tree)
316
 
        # mutter("  export {%s} kind %s to %s", self.file_id,
317
 
        #         self.kind, fullpath)
318
 
 
319
 
    def _put_on_disk(self, fullpath, tree):
320
 
        """Put this entry onto disk at fullpath, from tree tree."""
321
 
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
 
147
        if kind == 'directory':
 
148
            self.children = {}
 
149
        elif kind == 'file':
 
150
            pass
 
151
        else:
 
152
            raise BzrError("unhandled entry kind %r" % kind)
 
153
 
 
154
 
322
155
 
323
156
    def sorted_children(self):
324
 
        return sorted(self.children.items())
325
 
 
326
 
    @staticmethod
327
 
    def versionable_kind(kind):
328
 
        return kind in ('file', 'directory', 'symlink')
329
 
 
330
 
    def check(self, checker, rev_id, inv, tree):
331
 
        """Check this inventory entry is intact.
332
 
 
333
 
        This is a template method, override _check for kind specific
334
 
        tests.
335
 
 
336
 
        :param checker: Check object providing context for the checks; 
337
 
             can be used to find out what parts of the repository have already
338
 
             been checked.
339
 
        :param rev_id: Revision id from which this InventoryEntry was loaded.
340
 
             Not necessarily the last-changed revision for this file.
341
 
        :param inv: Inventory from which the entry was loaded.
342
 
        :param tree: RevisionTree for this entry.
343
 
        """
344
 
        if self.parent_id is not None:
345
 
            if not inv.has_id(self.parent_id):
346
 
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
347
 
                        % (self.parent_id, rev_id))
348
 
        self._check(checker, rev_id, tree)
349
 
 
350
 
    def _check(self, checker, rev_id, tree):
351
 
        """Check this inventory entry for kind specific errors."""
352
 
        raise BzrCheckError('unknown entry kind %r in revision {%s}' % 
353
 
                            (self.kind, rev_id))
 
157
        l = self.children.items()
 
158
        l.sort()
 
159
        return l
 
160
 
354
161
 
355
162
    def copy(self):
356
 
        """Clone this inventory entry."""
357
 
        raise NotImplementedError
358
 
 
359
 
    @staticmethod
360
 
    def describe_change(old_entry, new_entry):
361
 
        """Describe the change between old_entry and this.
362
 
        
363
 
        This smells of being an InterInventoryEntry situation, but as its
364
 
        the first one, we're making it a static method for now.
365
 
 
366
 
        An entry with a different parent, or different name is considered 
367
 
        to be renamed. Reparenting is an internal detail.
368
 
        Note that renaming the parent does not trigger a rename for the
369
 
        child entry itself.
370
 
        """
371
 
        # TODO: Perhaps return an object rather than just a string
372
 
        if old_entry is new_entry:
373
 
            # also the case of both being None
374
 
            return 'unchanged'
375
 
        elif old_entry is None:
376
 
            return 'added'
377
 
        elif new_entry is None:
378
 
            return 'removed'
379
 
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
380
 
        if text_modified or meta_modified:
381
 
            modified = True
382
 
        else:
383
 
            modified = False
384
 
        # TODO 20060511 (mbp, rbc) factor out 'detect_rename' here.
385
 
        if old_entry.parent_id != new_entry.parent_id:
386
 
            renamed = True
387
 
        elif old_entry.name != new_entry.name:
388
 
            renamed = True
389
 
        else:
390
 
            renamed = False
391
 
        if renamed and not modified:
392
 
            return InventoryEntry.RENAMED
393
 
        if modified and not renamed:
394
 
            return 'modified'
395
 
        if modified and renamed:
396
 
            return InventoryEntry.MODIFIED_AND_RENAMED
397
 
        return 'unchanged'
 
163
        other = InventoryEntry(self.file_id, self.name, self.kind,
 
164
                               self.parent_id)
 
165
        other.text_id = self.text_id
 
166
        other.text_sha1 = self.text_sha1
 
167
        other.text_size = self.text_size
 
168
        other.text_version = self.text_version
 
169
        # note that children are *not* copied; they're pulled across when
 
170
        # others are added
 
171
        return other
 
172
 
398
173
 
399
174
    def __repr__(self):
400
 
        return ("%s(%r, %r, parent_id=%r, revision=%r)"
 
175
        return ("%s(%r, %r, kind=%r, parent_id=%r)"
401
176
                % (self.__class__.__name__,
402
177
                   self.file_id,
403
178
                   self.name,
404
 
                   self.parent_id,
405
 
                   self.revision))
406
 
 
407
 
    def snapshot(self, revision, path, previous_entries,
408
 
                 work_tree, commit_builder):
409
 
        """Make a snapshot of this entry which may or may not have changed.
410
 
        
411
 
        This means that all its fields are populated, that it has its
412
 
        text stored in the text store or weave.
413
 
        """
414
 
        # mutter('new parents of %s are %r', path, previous_entries)
415
 
        self._read_tree_state(path, work_tree)
416
 
        # TODO: Where should we determine whether to reuse a
417
 
        # previous revision id or create a new revision? 20060606
418
 
        if len(previous_entries) == 1:
419
 
            # cannot be unchanged unless there is only one parent file rev.
420
 
            parent_ie = previous_entries.values()[0]
421
 
            if self._unchanged(parent_ie):
422
 
                # mutter("found unchanged entry")
423
 
                self.revision = parent_ie.revision
424
 
                return "unchanged"
425
 
        return self._snapshot_into_revision(revision, previous_entries, 
426
 
                                            work_tree, commit_builder)
427
 
 
428
 
    def _snapshot_into_revision(self, revision, previous_entries, work_tree,
429
 
                                commit_builder):
430
 
        """Record this revision unconditionally into a store.
431
 
 
432
 
        The entry's last-changed revision property (`revision`) is updated to 
433
 
        that of the new revision.
434
 
        
435
 
        :param revision: id of the new revision that is being recorded.
436
 
 
437
 
        :returns: String description of the commit (e.g. "merged", "modified"), etc.
438
 
        """
439
 
        # mutter('new revision {%s} for {%s}', revision, self.file_id)
440
 
        self.revision = revision
441
 
        self._snapshot_text(previous_entries, work_tree, commit_builder)
442
 
 
443
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder): 
444
 
        """Record the 'text' of this entry, whatever form that takes.
445
 
        
446
 
        This default implementation simply adds an empty text.
447
 
        """
448
 
        raise NotImplementedError(self._snapshot_text)
449
 
 
 
179
                   self.kind,
 
180
                   self.parent_id))
 
181
 
 
182
    
450
183
    def __eq__(self, other):
451
184
        if not isinstance(other, InventoryEntry):
452
185
            return NotImplemented
453
186
 
454
 
        return ((self.file_id == other.file_id)
455
 
                and (self.name == other.name)
456
 
                and (other.symlink_target == self.symlink_target)
457
 
                and (self.text_sha1 == other.text_sha1)
458
 
                and (self.text_size == other.text_size)
459
 
                and (self.text_id == other.text_id)
460
 
                and (self.parent_id == other.parent_id)
461
 
                and (self.kind == other.kind)
462
 
                and (self.revision == other.revision)
463
 
                and (self.executable == other.executable)
464
 
                )
 
187
        return (self.file_id == other.file_id) \
 
188
               and (self.name == other.name) \
 
189
               and (self.text_sha1 == other.text_sha1) \
 
190
               and (self.text_size == other.text_size) \
 
191
               and (self.text_id == other.text_id) \
 
192
               and (self.parent_id == other.parent_id) \
 
193
               and (self.kind == other.kind) \
 
194
               and (self.text_version == other.text_version) \
 
195
               and (self.entry_version == other.entry_version)
 
196
 
465
197
 
466
198
    def __ne__(self, other):
467
199
        return not (self == other)
469
201
    def __hash__(self):
470
202
        raise ValueError('not hashable')
471
203
 
472
 
    def _unchanged(self, previous_ie):
473
 
        """Has this entry changed relative to previous_ie.
474
 
 
475
 
        This method should be overridden in child classes.
476
 
        """
477
 
        compatible = True
478
 
        # different inv parent
479
 
        if previous_ie.parent_id != self.parent_id:
480
 
            compatible = False
481
 
        # renamed
482
 
        elif previous_ie.name != self.name:
483
 
            compatible = False
484
 
        return compatible
485
 
 
486
 
    def _read_tree_state(self, path, work_tree):
487
 
        """Populate fields in the inventory entry from the given tree.
488
 
        
489
 
        Note that this should be modified to be a noop on virtual trees
490
 
        as all entries created there are prepopulated.
491
 
        """
492
 
        # TODO: Rather than running this manually, we should check the 
493
 
        # working sha1 and other expensive properties when they're
494
 
        # first requested, or preload them if they're already known
495
 
        pass            # nothing to do by default
496
 
 
497
 
    def _forget_tree_state(self):
498
 
        pass
499
204
 
500
205
 
501
206
class RootEntry(InventoryEntry):
502
 
 
503
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
504
 
                 'text_id', 'parent_id', 'children', 'executable', 
505
 
                 'revision', 'symlink_target']
506
 
 
507
 
    def _check(self, checker, rev_id, tree):
508
 
        """See InventoryEntry._check"""
509
 
 
510
207
    def __init__(self, file_id):
511
208
        self.file_id = file_id
512
209
        self.children = {}
513
 
        self.kind = 'directory'
 
210
        self.kind = 'root_directory'
514
211
        self.parent_id = None
515
 
        self.name = u''
516
 
        self.revision = None
517
 
        warn('RootEntry is deprecated as of bzr 0.10.  Please use '
518
 
             'InventoryDirectory instead.',
519
 
            DeprecationWarning, stacklevel=2)
 
212
        self.name = ''
520
213
 
521
214
    def __eq__(self, other):
522
215
        if not isinstance(other, RootEntry):
526
219
               and (self.children == other.children)
527
220
 
528
221
 
529
 
class InventoryDirectory(InventoryEntry):
530
 
    """A directory in an inventory."""
531
 
 
532
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
533
 
                 'text_id', 'parent_id', 'children', 'executable', 
534
 
                 'revision', 'symlink_target']
535
 
 
536
 
    def _check(self, checker, rev_id, tree):
537
 
        """See InventoryEntry._check"""
538
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
539
 
            raise BzrCheckError('directory {%s} has text in revision {%s}'
540
 
                                % (self.file_id, rev_id))
541
 
 
542
 
    def copy(self):
543
 
        other = InventoryDirectory(self.file_id, self.name, self.parent_id)
544
 
        other.revision = self.revision
545
 
        # note that children are *not* copied; they're pulled across when
546
 
        # others are added
547
 
        return other
548
 
 
549
 
    def __init__(self, file_id, name, parent_id):
550
 
        super(InventoryDirectory, self).__init__(file_id, name, parent_id)
551
 
        self.children = {}
552
 
        self.kind = 'directory'
553
 
 
554
 
    def kind_character(self):
555
 
        """See InventoryEntry.kind_character."""
556
 
        return '/'
557
 
 
558
 
    def _put_in_tar(self, item, tree):
559
 
        """See InventoryEntry._put_in_tar."""
560
 
        item.type = tarfile.DIRTYPE
561
 
        fileobj = None
562
 
        item.name += '/'
563
 
        item.size = 0
564
 
        item.mode = 0755
565
 
        return fileobj
566
 
 
567
 
    def _put_on_disk(self, fullpath, tree):
568
 
        """See InventoryEntry._put_on_disk."""
569
 
        os.mkdir(fullpath)
570
 
 
571
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
572
 
        """See InventoryEntry._snapshot_text."""
573
 
        commit_builder.modified_directory(self.file_id, file_parents)
574
 
 
575
 
 
576
 
class InventoryFile(InventoryEntry):
577
 
    """A file in an inventory."""
578
 
 
579
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
580
 
                 'text_id', 'parent_id', 'children', 'executable', 
581
 
                 'revision', 'symlink_target']
582
 
 
583
 
    def _check(self, checker, tree_revision_id, tree):
584
 
        """See InventoryEntry._check"""
585
 
        t = (self.file_id, self.revision)
586
 
        if t in checker.checked_texts:
587
 
            prev_sha = checker.checked_texts[t]
588
 
            if prev_sha != self.text_sha1:
589
 
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
590
 
                                    (self.file_id, tree_revision_id))
591
 
            else:
592
 
                checker.repeated_text_cnt += 1
593
 
                return
594
 
 
595
 
        if self.file_id not in checker.checked_weaves:
596
 
            mutter('check weave {%s}', self.file_id)
597
 
            w = tree.get_weave(self.file_id)
598
 
            # Not passing a progress bar, because it creates a new
599
 
            # progress, which overwrites the current progress,
600
 
            # and doesn't look nice
601
 
            w.check()
602
 
            checker.checked_weaves[self.file_id] = True
603
 
        else:
604
 
            w = tree.get_weave(self.file_id)
605
 
 
606
 
        mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
607
 
        checker.checked_text_cnt += 1
608
 
        # We can't check the length, because Weave doesn't store that
609
 
        # information, and the whole point of looking at the weave's
610
 
        # sha1sum is that we don't have to extract the text.
611
 
        if self.text_sha1 != w.get_sha1(self.revision):
612
 
            raise BzrCheckError('text {%s} version {%s} wrong sha1' 
613
 
                                % (self.file_id, self.revision))
614
 
        checker.checked_texts[t] = self.text_sha1
615
 
 
616
 
    def copy(self):
617
 
        other = InventoryFile(self.file_id, self.name, self.parent_id)
618
 
        other.executable = self.executable
619
 
        other.text_id = self.text_id
620
 
        other.text_sha1 = self.text_sha1
621
 
        other.text_size = self.text_size
622
 
        other.revision = self.revision
623
 
        return other
624
 
 
625
 
    def detect_changes(self, old_entry):
626
 
        """See InventoryEntry.detect_changes."""
627
 
        assert self.text_sha1 is not None
628
 
        assert old_entry.text_sha1 is not None
629
 
        text_modified = (self.text_sha1 != old_entry.text_sha1)
630
 
        meta_modified = (self.executable != old_entry.executable)
631
 
        return text_modified, meta_modified
632
 
 
633
 
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
634
 
             output_to, reverse=False):
635
 
        """See InventoryEntry._diff."""
636
 
        try:
637
 
            from_text = tree.get_file(self.file_id).readlines()
638
 
            if to_entry:
639
 
                to_text = to_tree.get_file(to_entry.file_id).readlines()
640
 
            else:
641
 
                to_text = []
642
 
            if not reverse:
643
 
                text_diff(from_label, from_text,
644
 
                          to_label, to_text, output_to)
645
 
            else:
646
 
                text_diff(to_label, to_text,
647
 
                          from_label, from_text, output_to)
648
 
        except BinaryFile:
649
 
            if reverse:
650
 
                label_pair = (to_label, from_label)
651
 
            else:
652
 
                label_pair = (from_label, to_label)
653
 
            print >> output_to, "Binary files %s and %s differ" % label_pair
654
 
 
655
 
    def has_text(self):
656
 
        """See InventoryEntry.has_text."""
657
 
        return True
658
 
 
659
 
    def __init__(self, file_id, name, parent_id):
660
 
        super(InventoryFile, self).__init__(file_id, name, parent_id)
661
 
        self.kind = 'file'
662
 
 
663
 
    def kind_character(self):
664
 
        """See InventoryEntry.kind_character."""
665
 
        return ''
666
 
 
667
 
    def _put_in_tar(self, item, tree):
668
 
        """See InventoryEntry._put_in_tar."""
669
 
        item.type = tarfile.REGTYPE
670
 
        fileobj = tree.get_file(self.file_id)
671
 
        item.size = self.text_size
672
 
        if tree.is_executable(self.file_id):
673
 
            item.mode = 0755
674
 
        else:
675
 
            item.mode = 0644
676
 
        return fileobj
677
 
 
678
 
    def _put_on_disk(self, fullpath, tree):
679
 
        """See InventoryEntry._put_on_disk."""
680
 
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
681
 
        if tree.is_executable(self.file_id):
682
 
            os.chmod(fullpath, 0755)
683
 
 
684
 
    def _read_tree_state(self, path, work_tree):
685
 
        """See InventoryEntry._read_tree_state."""
686
 
        self.text_sha1 = work_tree.get_file_sha1(self.file_id, path=path)
687
 
        # FIXME: 20050930 probe for the text size when getting sha1
688
 
        # in _read_tree_state
689
 
        self.executable = work_tree.is_executable(self.file_id, path=path)
690
 
 
691
 
    def __repr__(self):
692
 
        return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s)"
693
 
                % (self.__class__.__name__,
694
 
                   self.file_id,
695
 
                   self.name,
696
 
                   self.parent_id,
697
 
                   self.text_sha1,
698
 
                   self.text_size))
699
 
 
700
 
    def _forget_tree_state(self):
701
 
        self.text_sha1 = None
702
 
 
703
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
704
 
        """See InventoryEntry._snapshot_text."""
705
 
        def get_content_byte_lines():
706
 
            return work_tree.get_file(self.file_id).readlines()
707
 
        self.text_sha1, self.text_size = commit_builder.modified_file_text(
708
 
            self.file_id, file_parents, get_content_byte_lines, self.text_sha1, self.text_size)
709
 
 
710
 
    def _unchanged(self, previous_ie):
711
 
        """See InventoryEntry._unchanged."""
712
 
        compatible = super(InventoryFile, self)._unchanged(previous_ie)
713
 
        if self.text_sha1 != previous_ie.text_sha1:
714
 
            compatible = False
715
 
        else:
716
 
            # FIXME: 20050930 probe for the text size when getting sha1
717
 
            # in _read_tree_state
718
 
            self.text_size = previous_ie.text_size
719
 
        if self.executable != previous_ie.executable:
720
 
            compatible = False
721
 
        return compatible
722
 
 
723
 
 
724
 
class InventoryLink(InventoryEntry):
725
 
    """A file in an inventory."""
726
 
 
727
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
728
 
                 'text_id', 'parent_id', 'children', 'executable', 
729
 
                 'revision', 'symlink_target']
730
 
 
731
 
    def _check(self, checker, rev_id, tree):
732
 
        """See InventoryEntry._check"""
733
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
734
 
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
735
 
                    % (self.file_id, rev_id))
736
 
        if self.symlink_target is None:
737
 
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
738
 
                    % (self.file_id, rev_id))
739
 
 
740
 
    def copy(self):
741
 
        other = InventoryLink(self.file_id, self.name, self.parent_id)
742
 
        other.symlink_target = self.symlink_target
743
 
        other.revision = self.revision
744
 
        return other
745
 
 
746
 
    def detect_changes(self, old_entry):
747
 
        """See InventoryEntry.detect_changes."""
748
 
        # FIXME: which _modified field should we use ? RBC 20051003
749
 
        text_modified = (self.symlink_target != old_entry.symlink_target)
750
 
        if text_modified:
751
 
            mutter("    symlink target changed")
752
 
        meta_modified = False
753
 
        return text_modified, meta_modified
754
 
 
755
 
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
756
 
             output_to, reverse=False):
757
 
        """See InventoryEntry._diff."""
758
 
        from_text = self.symlink_target
759
 
        if to_entry is not None:
760
 
            to_text = to_entry.symlink_target
761
 
            if reverse:
762
 
                temp = from_text
763
 
                from_text = to_text
764
 
                to_text = temp
765
 
            print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
766
 
        else:
767
 
            if not reverse:
768
 
                print >>output_to, '=== target was %r' % self.symlink_target
769
 
            else:
770
 
                print >>output_to, '=== target is %r' % self.symlink_target
771
 
 
772
 
    def __init__(self, file_id, name, parent_id):
773
 
        super(InventoryLink, self).__init__(file_id, name, parent_id)
774
 
        self.kind = 'symlink'
775
 
 
776
 
    def kind_character(self):
777
 
        """See InventoryEntry.kind_character."""
778
 
        return ''
779
 
 
780
 
    def _put_in_tar(self, item, tree):
781
 
        """See InventoryEntry._put_in_tar."""
782
 
        item.type = tarfile.SYMTYPE
783
 
        fileobj = None
784
 
        item.size = 0
785
 
        item.mode = 0755
786
 
        item.linkname = self.symlink_target
787
 
        return fileobj
788
 
 
789
 
    def _put_on_disk(self, fullpath, tree):
790
 
        """See InventoryEntry._put_on_disk."""
791
 
        try:
792
 
            os.symlink(self.symlink_target, fullpath)
793
 
        except OSError,e:
794
 
            raise BzrError("Failed to create symlink %r -> %r, error: %s" % (fullpath, self.symlink_target, e))
795
 
 
796
 
    def _read_tree_state(self, path, work_tree):
797
 
        """See InventoryEntry._read_tree_state."""
798
 
        self.symlink_target = work_tree.get_symlink_target(self.file_id)
799
 
 
800
 
    def _forget_tree_state(self):
801
 
        self.symlink_target = None
802
 
 
803
 
    def _unchanged(self, previous_ie):
804
 
        """See InventoryEntry._unchanged."""
805
 
        compatible = super(InventoryLink, self)._unchanged(previous_ie)
806
 
        if self.symlink_target != previous_ie.symlink_target:
807
 
            compatible = False
808
 
        return compatible
809
 
 
810
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
811
 
        """See InventoryEntry._snapshot_text."""
812
 
        commit_builder.modified_link(
813
 
            self.file_id, file_parents, self.symlink_target)
814
 
 
815
222
 
816
223
class Inventory(object):
817
224
    """Inventory of versioned files in a tree.
831
238
    inserted, other than through the Inventory API.
832
239
 
833
240
    >>> inv = Inventory()
834
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
835
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
241
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
 
242
    InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT')
836
243
    >>> inv['123-123'].name
837
244
    'hello.c'
838
245
 
846
253
    May also look up by name:
847
254
 
848
255
    >>> [x[0] for x in inv.iter_entries()]
849
 
    ['', u'hello.c']
 
256
    ['hello.c']
850
257
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
851
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
852
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678', sha1=None, len=None)
 
258
    >>> inv.add(InventoryEntry('123-123', 'hello.c', 'file', ROOT_ID))
 
259
    InventoryEntry('123-123', 'hello.c', kind='file', parent_id='TREE_ROOT-12345678-12345678')
853
260
    """
854
 
    def __init__(self, root_id=ROOT_ID, revision_id=None):
 
261
    def __init__(self, root_id=ROOT_ID):
855
262
        """Create or read an inventory.
856
263
 
857
264
        If a working directory is specified, the inventory is read
861
268
        The inventory is created with a default root directory, with
862
269
        an id of None.
863
270
        """
864
 
        # We are letting Branch.create() create a unique inventory
 
271
        # We are letting Branch(init=True) create a unique inventory
865
272
        # root id. Rather than generating a random one here.
866
273
        #if root_id is None:
867
274
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
868
 
        self.root = InventoryDirectory(root_id, '', None)
869
 
        # FIXME: this isn't ever used, changing it to self.revision may break
870
 
        # things. TODO make everything use self.revision_id
871
 
        self.revision_id = revision_id
 
275
        self.root = RootEntry(root_id)
872
276
        self._byid = {self.root.file_id: self.root}
873
277
 
 
278
 
874
279
    def copy(self):
875
 
        # TODO: jam 20051218 Should copy also copy the revision_id?
876
 
        entries = self.iter_entries()
877
 
        other = Inventory(entries.next()[1].file_id)
 
280
        other = Inventory(self.root.file_id)
878
281
        # copy recursively so we know directories will be added before
879
282
        # their children.  There are more efficient ways than this...
880
 
        for path, entry in entries():
 
283
        for path, entry in self.iter_entries():
 
284
            if entry == self.root:
 
285
                continue
881
286
            other.add(entry.copy())
882
287
        return other
883
288
 
 
289
 
884
290
    def __iter__(self):
885
291
        return iter(self._byid)
886
292
 
 
293
 
887
294
    def __len__(self):
888
295
        """Returns number of entries."""
889
296
        return len(self._byid)
890
297
 
 
298
 
891
299
    def iter_entries(self, from_dir=None):
892
300
        """Return (path, entry) pairs, in order by name."""
893
 
        if from_dir is None:
894
 
            assert self.root
895
 
            from_dir = self.root
896
 
            yield '', self.root
897
 
        elif isinstance(from_dir, basestring):
898
 
            from_dir = self._byid[from_dir]
899
 
            
900
 
        # unrolling the recursive called changed the time from
901
 
        # 440ms/663ms (inline/total) to 116ms/116ms
902
 
        children = from_dir.children.items()
903
 
        children.sort()
904
 
        children = collections.deque(children)
905
 
        stack = [(u'', children)]
906
 
        while stack:
907
 
            from_dir_relpath, children = stack[-1]
908
 
 
909
 
            while children:
910
 
                name, ie = children.popleft()
911
 
 
912
 
                # we know that from_dir_relpath never ends in a slash
913
 
                # and 'f' doesn't begin with one, we can do a string op, rather
914
 
                # than the checks of pathjoin(), though this means that all paths
915
 
                # start with a slash
916
 
                path = from_dir_relpath + '/' + name
917
 
 
918
 
                yield path[1:], ie
919
 
 
920
 
                if ie.kind != 'directory':
921
 
                    continue
922
 
 
923
 
                # But do this child first
924
 
                new_children = ie.children.items()
925
 
                new_children.sort()
926
 
                new_children = collections.deque(new_children)
927
 
                stack.append((path, new_children))
928
 
                # Break out of inner loop, so that we start outer loop with child
929
 
                break
930
 
            else:
931
 
                # if we finished all children, pop it off the stack
932
 
                stack.pop()
933
 
 
934
 
    def iter_entries_by_dir(self, from_dir=None):
935
 
        """Iterate over the entries in a directory first order.
936
 
 
937
 
        This returns all entries for a directory before returning
938
 
        the entries for children of a directory. This is not
939
 
        lexicographically sorted order, and is a hybrid between
940
 
        depth-first and breadth-first.
941
 
 
942
 
        :return: This yields (path, entry) pairs
943
 
        """
944
 
        # TODO? Perhaps this should return the from_dir so that the root is
945
 
        # yielded? or maybe an option?
946
 
        if from_dir is None:
947
 
            assert self.root
948
 
            from_dir = self.root
949
 
            yield '', self.root
950
 
        elif isinstance(from_dir, basestring):
951
 
            from_dir = self._byid[from_dir]
952
 
            
953
 
        stack = [(u'', from_dir)]
954
 
        while stack:
955
 
            cur_relpath, cur_dir = stack.pop()
956
 
 
957
 
            child_dirs = []
958
 
            for child_name, child_ie in sorted(cur_dir.children.iteritems()):
959
 
 
960
 
                child_relpath = cur_relpath + child_name
961
 
 
962
 
                yield child_relpath, child_ie
963
 
 
964
 
                if child_ie.kind == 'directory':
965
 
                    child_dirs.append((child_relpath+'/', child_ie))
966
 
            stack.extend(reversed(child_dirs))
 
301
        if from_dir == None:
 
302
            assert self.root
 
303
            from_dir = self.root
 
304
        elif isinstance(from_dir, basestring):
 
305
            from_dir = self._byid[from_dir]
 
306
            
 
307
        kids = from_dir.children.items()
 
308
        kids.sort()
 
309
        for name, ie in kids:
 
310
            yield name, ie
 
311
            if ie.kind == 'directory':
 
312
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
 
313
                    yield os.path.join(name, cn), cie
 
314
 
967
315
 
968
316
    def entries(self):
969
317
        """Return list of (path, ie) for all entries except the root.
975
323
            kids = dir_ie.children.items()
976
324
            kids.sort()
977
325
            for name, ie in kids:
978
 
                child_path = pathjoin(dir_path, name)
 
326
                child_path = os.path.join(dir_path, name)
979
327
                accum.append((child_path, ie))
980
328
                if ie.kind == 'directory':
981
329
                    descend(ie, child_path)
982
330
 
983
 
        descend(self.root, u'')
 
331
        descend(self.root, '')
984
332
        return accum
985
333
 
 
334
 
986
335
    def directories(self):
987
336
        """Return (path, entry) pairs for all directories, including the root.
988
337
        """
994
343
            kids.sort()
995
344
 
996
345
            for name, child_ie in kids:
997
 
                child_path = pathjoin(parent_path, name)
 
346
                child_path = os.path.join(parent_path, name)
998
347
                descend(child_ie, child_path)
999
 
        descend(self.root, u'')
 
348
        descend(self.root, '')
1000
349
        return accum
1001
350
        
 
351
 
 
352
 
1002
353
    def __contains__(self, file_id):
1003
354
        """True if this entry contains a file with given id.
1004
355
 
1005
356
        >>> inv = Inventory()
1006
 
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1007
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
357
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
 
358
        InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
1008
359
        >>> '123' in inv
1009
360
        True
1010
361
        >>> '456' in inv
1012
363
        """
1013
364
        return file_id in self._byid
1014
365
 
 
366
 
1015
367
    def __getitem__(self, file_id):
1016
368
        """Return the entry for given file_id.
1017
369
 
1018
370
        >>> inv = Inventory()
1019
 
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
1020
 
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
371
        >>> inv.add(InventoryEntry('123123', 'hello.c', 'file', ROOT_ID))
 
372
        InventoryEntry('123123', 'hello.c', kind='file', parent_id='TREE_ROOT')
1021
373
        >>> inv['123123'].name
1022
374
        'hello.c'
1023
375
        """
1024
376
        try:
1025
377
            return self._byid[file_id]
1026
378
        except KeyError:
1027
 
            if file_id is None:
 
379
            if file_id == None:
1028
380
                raise BzrError("can't look up file_id None")
1029
381
            else:
1030
382
                raise BzrError("file_id {%s} not in inventory" % file_id)
1031
383
 
 
384
 
1032
385
    def get_file_kind(self, file_id):
1033
386
        return self._byid[file_id].kind
1034
387
 
1035
388
    def get_child(self, parent_id, filename):
1036
389
        return self[parent_id].children.get(filename)
1037
390
 
 
391
 
1038
392
    def add(self, entry):
1039
393
        """Add entry to inventory.
1040
394
 
1054
408
        except KeyError:
1055
409
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
1056
410
 
1057
 
        if entry.name in parent.children:
 
411
        if parent.children.has_key(entry.name):
1058
412
            raise BzrError("%s is already versioned" %
1059
 
                    pathjoin(self.id2path(parent.file_id), entry.name))
 
413
                    appendpath(self.id2path(parent.file_id), entry.name))
1060
414
 
1061
415
        self._byid[entry.file_id] = entry
1062
416
        parent.children[entry.name] = entry
1063
417
        return entry
1064
418
 
1065
 
    def add_path(self, relpath, kind, file_id=None, parent_id=None):
 
419
 
 
420
    def add_path(self, relpath, kind, file_id=None):
1066
421
        """Add entry from a path.
1067
422
 
1068
423
        The immediate parent must already be versioned.
1069
424
 
1070
425
        Returns the new entry object."""
 
426
        from bzrlib.branch import gen_file_id
1071
427
        
1072
 
        parts = osutils.splitpath(relpath)
1073
 
 
 
428
        parts = bzrlib.osutils.splitpath(relpath)
1074
429
        if len(parts) == 0:
1075
 
            if file_id is None:
1076
 
                file_id = bzrlib.workingtree.gen_root_id()
1077
 
            self.root = InventoryDirectory(file_id, '', None)
1078
 
            self._byid = {self.root.file_id: self.root}
1079
 
            return
1080
 
        else:
1081
 
            parent_path = parts[:-1]
1082
 
            parent_id = self.path2id(parent_path)
1083
 
            if parent_id is None:
1084
 
                raise NotVersionedError(path=parent_path)
1085
 
        ie = make_entry(kind, parts[-1], parent_id, file_id)
 
430
            raise BzrError("cannot re-add root of inventory")
 
431
 
 
432
        if file_id == None:
 
433
            file_id = gen_file_id(relpath)
 
434
 
 
435
        parent_path = parts[:-1]
 
436
        parent_id = self.path2id(parent_path)
 
437
        if parent_id == None:
 
438
            raise NotVersionedError(parent_path)
 
439
 
 
440
        ie = InventoryEntry(file_id, parts[-1],
 
441
                            kind=kind, parent_id=parent_id)
1086
442
        return self.add(ie)
1087
443
 
 
444
 
1088
445
    def __delitem__(self, file_id):
1089
446
        """Remove entry by id.
1090
447
 
1091
448
        >>> inv = Inventory()
1092
 
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1093
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
449
        >>> inv.add(InventoryEntry('123', 'foo.c', 'file', ROOT_ID))
 
450
        InventoryEntry('123', 'foo.c', kind='file', parent_id='TREE_ROOT')
1094
451
        >>> '123' in inv
1095
452
        True
1096
453
        >>> del inv['123']
1099
456
        """
1100
457
        ie = self[file_id]
1101
458
 
1102
 
        assert ie.parent_id is None or \
1103
 
            self[ie.parent_id].children[ie.name] == ie
 
459
        assert self[ie.parent_id].children[ie.name] == ie
1104
460
        
 
461
        # TODO: Test deleting all children; maybe hoist to a separate
 
462
        # deltree method?
 
463
        if ie.kind == 'directory':
 
464
            for cie in ie.children.values():
 
465
                del self[cie.file_id]
 
466
            del ie.children
 
467
 
1105
468
        del self._byid[file_id]
1106
 
        if ie.parent_id is not None:
1107
 
            del self[ie.parent_id].children[ie.name]
 
469
        del self[ie.parent_id].children[ie.name]
 
470
 
1108
471
 
1109
472
    def __eq__(self, other):
1110
473
        """Compare two sets by comparing their contents.
1113
476
        >>> i2 = Inventory()
1114
477
        >>> i1 == i2
1115
478
        True
1116
 
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
1117
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
479
        >>> i1.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
 
480
        InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
1118
481
        >>> i1 == i2
1119
482
        False
1120
 
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
1121
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
483
        >>> i2.add(InventoryEntry('123', 'foo', 'file', ROOT_ID))
 
484
        InventoryEntry('123', 'foo', kind='file', parent_id='TREE_ROOT')
1122
485
        >>> i1 == i2
1123
486
        True
1124
487
        """
1125
488
        if not isinstance(other, Inventory):
1126
489
            return NotImplemented
1127
490
 
 
491
        if len(self._byid) != len(other._byid):
 
492
            # shortcut: obviously not the same
 
493
            return False
 
494
 
1128
495
        return self._byid == other._byid
1129
496
 
 
497
 
1130
498
    def __ne__(self, other):
1131
499
        return not self.__eq__(other)
1132
500
 
 
501
 
1133
502
    def __hash__(self):
1134
503
        raise ValueError('not hashable')
1135
504
 
1136
 
    def _iter_file_id_parents(self, file_id):
1137
 
        """Yield the parents of file_id up to the root."""
1138
 
        while file_id is not None:
1139
 
            try:
1140
 
                ie = self._byid[file_id]
1141
 
            except KeyError:
1142
 
                raise BzrError("file_id {%s} not found in inventory" % file_id)
1143
 
            yield ie
1144
 
            file_id = ie.parent_id
1145
505
 
1146
506
    def get_idpath(self, file_id):
1147
507
        """Return a list of file_ids for the path to an entry.
1152
512
        root directory as depth 1.
1153
513
        """
1154
514
        p = []
1155
 
        for parent in self._iter_file_id_parents(file_id):
1156
 
            p.insert(0, parent.file_id)
 
515
        while file_id != None:
 
516
            try:
 
517
                ie = self._byid[file_id]
 
518
            except KeyError:
 
519
                raise BzrError("file_id {%s} not found in inventory" % file_id)
 
520
            p.insert(0, ie.file_id)
 
521
            file_id = ie.parent_id
1157
522
        return p
1158
523
 
 
524
 
1159
525
    def id2path(self, file_id):
1160
 
        """Return as a string the path to file_id.
1161
 
        
1162
 
        >>> i = Inventory()
1163
 
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
1164
 
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
1165
 
        >>> print i.id2path('foo-id')
1166
 
        src/foo.c
1167
 
        """
 
526
        """Return as a list the path to file_id."""
 
527
 
1168
528
        # get all names, skipping root
1169
 
        return '/'.join(reversed(
1170
 
            [parent.name for parent in 
1171
 
             self._iter_file_id_parents(file_id)][:-1]))
 
529
        p = [self._byid[fid].name for fid in self.get_idpath(file_id)[1:]]
 
530
        return os.sep.join(p)
1172
531
            
 
532
 
 
533
 
1173
534
    def path2id(self, name):
1174
535
        """Walk down through directories to return entry of last component.
1175
536
 
1179
540
        This returns the entry of the last component in the path,
1180
541
        which may be either a file or a directory.
1181
542
 
1182
 
        Returns None IFF the path is not found.
 
543
        Returns None iff the path is not found.
1183
544
        """
1184
545
        if isinstance(name, types.StringTypes):
1185
546
            name = splitpath(name)
1186
547
 
1187
 
        # mutter("lookup path %r" % name)
 
548
        mutter("lookup path %r" % name)
1188
549
 
1189
550
        parent = self.root
1190
551
        for f in name:
1199
560
 
1200
561
        return parent.file_id
1201
562
 
 
563
 
1202
564
    def has_filename(self, names):
1203
565
        return bool(self.path2id(names))
1204
566
 
 
567
 
1205
568
    def has_id(self, file_id):
1206
569
        return self._byid.has_key(file_id)
1207
570
 
 
571
 
1208
572
    def rename(self, file_id, new_parent_id, new_name):
1209
573
        """Move a file within the inventory.
1210
574
 
1235
599
        file_ie.parent_id = new_parent_id
1236
600
 
1237
601
 
1238
 
def make_entry(kind, name, parent_id, file_id=None):
1239
 
    """Create an inventory entry.
1240
 
 
1241
 
    :param kind: the type of inventory entry to create.
1242
 
    :param name: the basename of the entry.
1243
 
    :param parent_id: the parent_id of the entry.
1244
 
    :param file_id: the file_id to use. if None, one will be created.
1245
 
    """
1246
 
    if file_id is None:
1247
 
        file_id = bzrlib.workingtree.gen_file_id(name)
1248
 
 
1249
 
    norm_name, can_access = osutils.normalized_filename(name)
1250
 
    if norm_name != name:
1251
 
        if can_access:
1252
 
            name = norm_name
1253
 
        else:
1254
 
            # TODO: jam 20060701 This would probably be more useful
1255
 
            #       if the error was raised with the full path
1256
 
            raise errors.InvalidNormalization(name)
1257
 
 
1258
 
    if kind == 'directory':
1259
 
        return InventoryDirectory(file_id, name, parent_id)
1260
 
    elif kind == 'file':
1261
 
        return InventoryFile(file_id, name, parent_id)
1262
 
    elif kind == 'symlink':
1263
 
        return InventoryLink(file_id, name, parent_id)
1264
 
    else:
1265
 
        raise BzrError("unknown kind %r" % kind)
1266
602
 
1267
603
 
1268
604
_NAME_RE = None
1269
605
 
1270
606
def is_valid_name(name):
1271
607
    global _NAME_RE
1272
 
    if _NAME_RE is None:
 
608
    if _NAME_RE == None:
1273
609
        _NAME_RE = re.compile(r'^[^/\\]+$')
1274
610
        
1275
611
    return bool(_NAME_RE.match(name))