~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-11-21 12:34:18 UTC
  • mfrom: (1551.9.3 Aaron's mergeable stuff)
  • Revision ID: pqm@pqm.ubuntu.com-20061121123418-3d0b2fb05cbe6b43
Revert buggy apport changes

Show diffs side-by-side

added added

removed removed

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