← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Robert Collins
  • Date: 2005-10-02 22:47:02 UTC
  • mto: This revision was merged to the branch mainline in revision 1397.
  • Revision ID: robertc@robertcollins.net-20051002224701-8a8b20b90de559a6
support ghosts in commits

Show diffs side-by-side

added added

removed removed

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