~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Martin Pool
  • Date: 2005-07-04 08:06:51 UTC
  • Revision ID: mbp@sourcefrog.net-20050704080651-6ecec49164359e48
- track pending-merges

- unit tests for this

Show diffs side-by-side

added added

removed removed

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