~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: 2007-08-01 17:14:51 UTC
  • mfrom: (2662.1.1 bzr.easy_install)
  • Revision ID: pqm@pqm.ubuntu.com-20070801171451-en3tds1hzlru2j83
allow ``easy_install bzr`` runs without fatal errors. (#125521, bialix,
 r=mbp)

Show diffs side-by-side

added added

removed removed

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