~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-05-19 06:14:38 UTC
  • mfrom: (1704.2.23 bzr.mbp.integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060519061438-6300caf3926c3cff
(mbp) small fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
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
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
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
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
 
17
# FIXME: This refactoring of the workingtree code doesn't seem to keep 
18
18
# the WorkingTree's copy of the inventory in sync with the branch.  The
19
19
# branch modifies its working inventory when it does a commit to make
20
20
# missing files permanently removed.
27
27
# created, but it's not for now.
28
28
ROOT_ID = "TREE_ROOT"
29
29
 
30
 
from bzrlib.lazy_import import lazy_import
31
 
lazy_import(globals(), """
32
 
import collections
33
 
import copy
34
 
import os
 
30
 
 
31
import os.path
35
32
import re
 
33
import sys
36
34
import tarfile
 
35
import types
37
36
 
38
37
import bzrlib
39
 
from bzrlib import (
40
 
    chk_map,
41
 
    errors,
42
 
    generate_ids,
43
 
    osutils,
44
 
    symbol_versioning,
45
 
    )
46
 
""")
47
 
 
48
 
from bzrlib.errors import (
49
 
    BzrCheckError,
50
 
    BzrError,
51
 
    )
52
 
from bzrlib.symbol_versioning import deprecated_in, deprecated_method
 
38
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
 
39
                            pathjoin, sha_strings)
 
40
from bzrlib.errors import (NotVersionedError, InvalidEntryName,
 
41
                           BzrError, BzrCheckError, BinaryFile)
53
42
from bzrlib.trace import mutter
54
 
from bzrlib.static_tuple import StaticTuple
55
43
 
56
44
 
57
45
class InventoryEntry(object):
69
57
        file_id of the parent directory, or ROOT_ID
70
58
 
71
59
    revision
72
 
        the revision_id in which this variation of this file was
 
60
        the revision_id in which this variation of this file was 
73
61
        introduced.
74
62
 
75
63
    executable
78
66
 
79
67
    text_sha1
80
68
        sha-1 of the text of the file
81
 
 
 
69
        
82
70
    text_size
83
71
        size in bytes of the text of the file
84
 
 
 
72
        
85
73
    (reading a version 4 tree created a text_id field.)
86
74
 
87
75
    >>> i = Inventory()
88
76
    >>> i.path2id('')
89
77
    'TREE_ROOT'
90
78
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
91
 
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
 
79
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
92
80
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
93
 
    InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None, revision=None)
94
 
    >>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}
 
81
    InventoryFile('2323', 'hello.c', parent_id='123')
 
82
    >>> shouldbe = {0: 'src', 1: pathjoin('src','hello.c')}
95
83
    >>> for ix, j in enumerate(i.iter_entries()):
96
84
    ...   print (j[0] == shouldbe[ix], j[1])
 
85
    ... 
 
86
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT'))
 
87
    (True, InventoryFile('2323', 'hello.c', parent_id='123'))
 
88
    >>> i.add(InventoryFile('2323', 'bye.c', '123'))
 
89
    Traceback (most recent call last):
97
90
    ...
98
 
    (True, InventoryDirectory('TREE_ROOT', u'', parent_id=None, revision=None))
99
 
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
100
 
    (True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None, revision=None))
 
91
    BzrError: inventory already contains entry with id {2323}
101
92
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
102
 
    InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None, revision=None)
 
93
    InventoryFile('2324', 'bye.c', parent_id='123')
103
94
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
104
 
    InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
 
95
    InventoryDirectory('2325', 'wibble', parent_id='123')
105
96
    >>> i.path2id('src/wibble')
106
97
    '2325'
107
98
    >>> '2325' in i
108
99
    True
109
100
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
110
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None, revision=None)
 
101
    InventoryFile('2326', 'wibble.c', parent_id='2325')
111
102
    >>> i['2326']
112
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None, revision=None)
 
103
    InventoryFile('2326', 'wibble.c', parent_id='2325')
113
104
    >>> for path, entry in i.iter_entries():
114
105
    ...     print path
115
 
    ...
116
 
    <BLANKLINE>
 
106
    ...     assert i.path2id(path)
 
107
    ... 
117
108
    src
118
109
    src/bye.c
119
110
    src/hello.c
125
116
 
126
117
    # Constants returned by describe_change()
127
118
    #
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
 
119
    # TODO: These should probably move to some kind of FileChangeDescription 
 
120
    # class; that's like what's inside a TreeDelta but we want to be able to 
130
121
    # generate them just for one file at a time.
131
122
    RENAMED = 'renamed'
132
123
    MODIFIED_AND_RENAMED = 'modified and renamed'
 
124
    
 
125
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
126
                 'text_id', 'parent_id', 'children', 'executable', 
 
127
                 'revision']
133
128
 
134
 
    __slots__ = []
 
129
    def _add_text_to_weave(self, new_lines, parents, weave_store, transaction):
 
130
        versionedfile = weave_store.get_weave_or_empty(self.file_id,
 
131
                                                       transaction)
 
132
        versionedfile.add_lines(self.revision, parents, new_lines)
 
133
        versionedfile.clear_cache()
135
134
 
136
135
    def detect_changes(self, old_entry):
137
136
        """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
 
137
        
 
138
        _read_tree_state must have been called on self and old_entry prior to 
140
139
        calling detect_changes.
141
140
        """
142
141
        return False, False
143
142
 
 
143
    def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
144
             output_to, reverse=False):
 
145
        """Perform a diff from this to to_entry.
 
146
 
 
147
        text_diff will be used for textual difference calculation.
 
148
        This is a template method, override _diff in child classes.
 
149
        """
 
150
        self._read_tree_state(tree.id2path(self.file_id), tree)
 
151
        if to_entry:
 
152
            # cannot diff from one kind to another - you must do a removal
 
153
            # and an addif they do not match.
 
154
            assert self.kind == to_entry.kind
 
155
            to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
 
156
                                      to_tree)
 
157
        self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
 
158
                   output_to, reverse)
 
159
 
144
160
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
145
161
             output_to, reverse=False):
146
162
        """Perform a diff between two entries of the same kind."""
147
163
 
148
 
    def parent_candidates(self, previous_inventories):
149
 
        """Find possible per-file graph parents.
150
 
 
151
 
        This is currently defined by:
152
 
         - Select the last changed revision in the parent inventory.
153
 
         - Do deal with a short lived bug in bzr 0.8's development two entries
154
 
           that have the same last changed but different 'x' bit settings are
155
 
           changed in-place.
 
164
    def find_previous_heads(self, previous_inventories,
 
165
                            versioned_file_store,
 
166
                            transaction,
 
167
                            entry_vf=None):
 
168
        """Return the revisions and entries that directly preceed this.
 
169
 
 
170
        Returned as a map from revision to inventory entry.
 
171
 
 
172
        This is a map containing the file revisions in all parents
 
173
        for which the file exists, and its revision is not a parent of
 
174
        any other. If the file is new, the set will be empty.
 
175
 
 
176
        :param versioned_file_store: A store where ancestry data on this
 
177
                                     file id can be queried.
 
178
        :param transaction: The transaction that queries to the versioned 
 
179
                            file store should be completed under.
 
180
        :param entry_vf: The entry versioned file, if its already available.
156
181
        """
 
182
        def get_ancestors(weave, entry):
 
183
            return set(weave.get_ancestry(entry.revision))
157
184
        # revision:ie mapping for each ie found in previous_inventories.
158
185
        candidates = {}
 
186
        # revision:ie mapping with one revision for each head.
 
187
        heads = {}
 
188
        # revision: ancestor list for each head
 
189
        head_ancestors = {}
159
190
        # identify candidate head revision ids.
160
191
        for inv in previous_inventories:
161
192
            if self.file_id in inv:
162
193
                ie = inv[self.file_id]
 
194
                assert ie.file_id == self.file_id
163
195
                if ie.revision in candidates:
164
196
                    # same revision value in two different inventories:
165
197
                    # correct possible inconsistencies:
166
 
                    #     * there was a bug in revision updates with 'x' bit
 
198
                    #     * there was a bug in revision updates with 'x' bit 
167
199
                    #       support.
168
200
                    try:
169
201
                        if candidates[ie.revision].executable != ie.executable:
171
203
                            ie.executable = False
172
204
                    except AttributeError:
173
205
                        pass
 
206
                    # must now be the same.
 
207
                    assert candidates[ie.revision] == ie
174
208
                else:
175
209
                    # add this revision as a candidate.
176
210
                    candidates[ie.revision] = ie
177
 
        return candidates
178
 
 
179
 
    @deprecated_method(deprecated_in((1, 6, 0)))
 
211
 
 
212
        # common case optimisation
 
213
        if len(candidates) == 1:
 
214
            # if there is only one candidate revision found
 
215
            # then we can opening the versioned file to access ancestry:
 
216
            # there cannot be any ancestors to eliminate when there is 
 
217
            # only one revision available.
 
218
            heads[ie.revision] = ie
 
219
            return heads
 
220
 
 
221
        # eliminate ancestors amongst the available candidates:
 
222
        # heads are those that are not an ancestor of any other candidate
 
223
        # - this provides convergence at a per-file level.
 
224
        for ie in candidates.values():
 
225
            # may be an ancestor of a known head:
 
226
            already_present = 0 != len(
 
227
                [head for head in heads 
 
228
                 if ie.revision in head_ancestors[head]])
 
229
            if already_present:
 
230
                # an ancestor of an analyzed candidate.
 
231
                continue
 
232
            # not an ancestor of a known head:
 
233
            # load the versioned file for this file id if needed
 
234
            if entry_vf is None:
 
235
                entry_vf = versioned_file_store.get_weave_or_empty(
 
236
                    self.file_id, transaction)
 
237
            ancestors = get_ancestors(entry_vf, ie)
 
238
            # may knock something else out:
 
239
            check_heads = list(heads.keys())
 
240
            for head in check_heads:
 
241
                if head in ancestors:
 
242
                    # this previously discovered 'head' is not
 
243
                    # really a head - its an ancestor of the newly 
 
244
                    # found head,
 
245
                    heads.pop(head)
 
246
            head_ancestors[ie.revision] = ancestors
 
247
            heads[ie.revision] = ie
 
248
        return heads
 
249
 
180
250
    def get_tar_item(self, root, dp, now, tree):
181
251
        """Get a tarfile item and a file stream for its content."""
182
 
        item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
 
252
        item = tarfile.TarInfo(pathjoin(root, dp))
183
253
        # TODO: would be cool to actually set it to the timestamp of the
184
254
        # revision it was last changed
185
255
        item.mtime = now
199
269
 
200
270
    def __init__(self, file_id, name, parent_id, text_id=None):
201
271
        """Create an InventoryEntry
202
 
 
 
272
        
203
273
        The filename must be a single component, relative to the
204
274
        parent directory; it cannot be a whole path or relative name.
205
275
 
212
282
        Traceback (most recent call last):
213
283
        InvalidEntryName: Invalid entry name: src/hello.c
214
284
        """
 
285
        assert isinstance(name, basestring), name
215
286
        if '/' in name or '\\' in name:
216
 
            raise errors.InvalidEntryName(name=name)
 
287
            raise InvalidEntryName(name=name)
217
288
        self.executable = False
218
289
        self.revision = None
219
290
        self.text_sha1 = None
223
294
        self.text_id = text_id
224
295
        self.parent_id = parent_id
225
296
        self.symlink_target = None
226
 
        self.reference_revision = None
227
297
 
228
298
    def kind_character(self):
229
299
        """Return a short kind indicator useful for appending to names."""
230
300
        raise BzrError('unknown kind %r' % self.kind)
231
301
 
232
 
    known_kinds = ('file', 'directory', 'symlink')
 
302
    known_kinds = ('file', 'directory', 'symlink', 'root_directory')
233
303
 
234
304
    def _put_in_tar(self, item, tree):
235
305
        """populate item for stashing in a tar, and return the content stream.
239
309
        raise BzrError("don't know how to export {%s} of kind %r" %
240
310
                       (self.file_id, self.kind))
241
311
 
242
 
    @deprecated_method(deprecated_in((1, 6, 0)))
243
312
    def put_on_disk(self, dest, dp, tree):
244
313
        """Create a representation of self on disk in the prefix dest.
245
 
 
 
314
        
246
315
        This is a template method - implement _put_on_disk in subclasses.
247
316
        """
248
 
        fullpath = osutils.pathjoin(dest, dp)
 
317
        fullpath = pathjoin(dest, dp)
249
318
        self._put_on_disk(fullpath, tree)
250
 
        # mutter("  export {%s} kind %s to %s", self.file_id,
251
 
        #         self.kind, fullpath)
 
319
        mutter("  export {%s} kind %s to %s", self.file_id,
 
320
                self.kind, fullpath)
252
321
 
253
322
    def _put_on_disk(self, fullpath, tree):
254
323
        """Put this entry onto disk at fullpath, from tree tree."""
255
324
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
256
325
 
257
326
    def sorted_children(self):
258
 
        return sorted(self.children.items())
 
327
        l = self.children.items()
 
328
        l.sort()
 
329
        return l
259
330
 
260
331
    @staticmethod
261
332
    def versionable_kind(kind):
262
 
        return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
 
333
        return kind in ('file', 'directory', 'symlink')
263
334
 
264
 
    def check(self, checker, rev_id, inv):
 
335
    def check(self, checker, rev_id, inv, tree):
265
336
        """Check this inventory entry is intact.
266
337
 
267
338
        This is a template method, override _check for kind specific
268
339
        tests.
269
340
 
270
 
        :param checker: Check object providing context for the checks;
 
341
        :param checker: Check object providing context for the checks; 
271
342
             can be used to find out what parts of the repository have already
272
343
             been checked.
273
344
        :param rev_id: Revision id from which this InventoryEntry was loaded.
274
345
             Not necessarily the last-changed revision for this file.
275
346
        :param inv: Inventory from which the entry was loaded.
 
347
        :param tree: RevisionTree for this entry.
276
348
        """
277
 
        if self.parent_id is not None:
 
349
        if self.parent_id != None:
278
350
            if not inv.has_id(self.parent_id):
279
351
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
280
352
                        % (self.parent_id, rev_id))
281
 
        checker._add_entry_to_text_key_references(inv, self)
282
 
        self._check(checker, rev_id)
 
353
        self._check(checker, rev_id, tree)
283
354
 
284
 
    def _check(self, checker, rev_id):
 
355
    def _check(self, checker, rev_id, tree):
285
356
        """Check this inventory entry for kind specific errors."""
286
 
        checker._report_items.append(
287
 
            'unknown entry kind %r in revision {%s}' % (self.kind, rev_id))
 
357
        raise BzrCheckError('unknown entry kind %r in revision {%s}' % 
 
358
                            (self.kind, rev_id))
288
359
 
289
360
    def copy(self):
290
361
        """Clone this inventory entry."""
293
364
    @staticmethod
294
365
    def describe_change(old_entry, new_entry):
295
366
        """Describe the change between old_entry and this.
296
 
 
 
367
        
297
368
        This smells of being an InterInventoryEntry situation, but as its
298
369
        the first one, we're making it a static method for now.
299
370
 
300
 
        An entry with a different parent, or different name is considered
 
371
        An entry with a different parent, or different name is considered 
301
372
        to be renamed. Reparenting is an internal detail.
302
373
        Note that renaming the parent does not trigger a rename for the
303
374
        child entry itself.
310
381
            return 'added'
311
382
        elif new_entry is None:
312
383
            return 'removed'
313
 
        if old_entry.kind != new_entry.kind:
314
 
            return 'modified'
315
384
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
316
385
        if text_modified or meta_modified:
317
386
            modified = True
333
402
        return 'unchanged'
334
403
 
335
404
    def __repr__(self):
336
 
        return ("%s(%r, %r, parent_id=%r, revision=%r)"
 
405
        return ("%s(%r, %r, parent_id=%r)"
337
406
                % (self.__class__.__name__,
338
407
                   self.file_id,
339
408
                   self.name,
340
 
                   self.parent_id,
341
 
                   self.revision))
 
409
                   self.parent_id))
 
410
 
 
411
    def snapshot(self, revision, path, previous_entries,
 
412
                 work_tree, weave_store, transaction):
 
413
        """Make a snapshot of this entry which may or may not have changed.
 
414
        
 
415
        This means that all its fields are populated, that it has its
 
416
        text stored in the text store or weave.
 
417
        """
 
418
        mutter('new parents of %s are %r', path, previous_entries)
 
419
        self._read_tree_state(path, work_tree)
 
420
        if len(previous_entries) == 1:
 
421
            # cannot be unchanged unless there is only one parent file rev.
 
422
            parent_ie = previous_entries.values()[0]
 
423
            if self._unchanged(parent_ie):
 
424
                mutter("found unchanged entry")
 
425
                self.revision = parent_ie.revision
 
426
                return "unchanged"
 
427
        return self._snapshot_into_revision(revision, previous_entries, 
 
428
                                            work_tree, weave_store, transaction)
 
429
 
 
430
    def _snapshot_into_revision(self, revision, previous_entries, work_tree,
 
431
                                weave_store, transaction):
 
432
        """Record this revision unconditionally into a store.
 
433
 
 
434
        The entry's last-changed revision property (`revision`) is updated to 
 
435
        that of the new revision.
 
436
        
 
437
        :param revision: id of the new revision that is being recorded.
 
438
 
 
439
        :returns: String description of the commit (e.g. "merged", "modified"), etc.
 
440
        """
 
441
        mutter('new revision {%s} for {%s}', revision, self.file_id)
 
442
        self.revision = revision
 
443
        self._snapshot_text(previous_entries, work_tree, weave_store,
 
444
                            transaction)
 
445
 
 
446
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction): 
 
447
        """Record the 'text' of this entry, whatever form that takes.
 
448
        
 
449
        This default implementation simply adds an empty text.
 
450
        """
 
451
        mutter('storing file {%s} in revision {%s}',
 
452
               self.file_id, self.revision)
 
453
        self._add_text_to_weave([], file_parents.keys(), weave_store, transaction)
342
454
 
343
455
    def __eq__(self, other):
344
 
        if other is self:
345
 
            # For the case when objects are cached
346
 
            return True
347
456
        if not isinstance(other, InventoryEntry):
348
457
            return NotImplemented
349
458
 
357
466
                and (self.kind == other.kind)
358
467
                and (self.revision == other.revision)
359
468
                and (self.executable == other.executable)
360
 
                and (self.reference_revision == other.reference_revision)
361
469
                )
362
470
 
363
471
    def __ne__(self, other):
369
477
    def _unchanged(self, previous_ie):
370
478
        """Has this entry changed relative to previous_ie.
371
479
 
372
 
        This method should be overridden in child classes.
 
480
        This method should be overriden in child classes.
373
481
        """
374
482
        compatible = True
375
483
        # different inv parent
378
486
        # renamed
379
487
        elif previous_ie.name != self.name:
380
488
            compatible = False
381
 
        elif previous_ie.kind != self.kind:
382
 
            compatible = False
383
489
        return compatible
384
490
 
385
491
    def _read_tree_state(self, path, work_tree):
386
492
        """Populate fields in the inventory entry from the given tree.
387
 
 
 
493
        
388
494
        Note that this should be modified to be a noop on virtual trees
389
495
        as all entries created there are prepopulated.
390
496
        """
391
 
        # TODO: Rather than running this manually, we should check the
 
497
        # TODO: Rather than running this manually, we should check the 
392
498
        # working sha1 and other expensive properties when they're
393
499
        # first requested, or preload them if they're already known
394
500
        pass            # nothing to do by default
399
505
 
400
506
class RootEntry(InventoryEntry):
401
507
 
402
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
403
 
                 'text_id', 'parent_id', 'children', 'executable',
404
 
                 'revision', 'symlink_target', 'reference_revision']
405
 
 
406
 
    def _check(self, checker, rev_id):
 
508
    def _check(self, checker, rev_id, tree):
407
509
        """See InventoryEntry._check"""
408
510
 
409
511
    def __init__(self, file_id):
410
512
        self.file_id = file_id
411
513
        self.children = {}
412
 
        self.kind = 'directory'
 
514
        self.kind = 'root_directory'
413
515
        self.parent_id = None
414
516
        self.name = u''
415
 
        self.revision = None
416
 
        symbol_versioning.warn('RootEntry is deprecated as of bzr 0.10.'
417
 
                               '  Please use InventoryDirectory instead.',
418
 
                               DeprecationWarning, stacklevel=2)
419
517
 
420
518
    def __eq__(self, other):
421
519
        if not isinstance(other, RootEntry):
422
520
            return NotImplemented
423
 
 
 
521
        
424
522
        return (self.file_id == other.file_id) \
425
523
               and (self.children == other.children)
426
524
 
428
526
class InventoryDirectory(InventoryEntry):
429
527
    """A directory in an inventory."""
430
528
 
431
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
432
 
                 'text_id', 'parent_id', 'children', 'executable',
433
 
                 'revision', 'symlink_target', 'reference_revision']
434
 
 
435
 
    def _check(self, checker, rev_id):
 
529
    def _check(self, checker, rev_id, tree):
436
530
        """See InventoryEntry._check"""
437
 
        if (self.text_sha1 is not None or self.text_size is not None or
438
 
            self.text_id is not None):
439
 
            checker._report_items.append('directory {%s} has text in revision {%s}'
 
531
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
532
            raise BzrCheckError('directory {%s} has text in revision {%s}'
440
533
                                % (self.file_id, rev_id))
441
 
        # In non rich root repositories we do not expect a file graph for the
442
 
        # root.
443
 
        if self.name == '' and not checker.rich_roots:
444
 
            return
445
 
        # Directories are stored as an empty file, but the file should exist
446
 
        # to provide a per-fileid log. The hash of every directory content is
447
 
        # "da..." below (the sha1sum of '').
448
 
        checker.add_pending_item(rev_id,
449
 
            ('texts', self.file_id, self.revision), 'text',
450
 
             'da39a3ee5e6b4b0d3255bfef95601890afd80709')
451
534
 
452
535
    def copy(self):
453
536
        other = InventoryDirectory(self.file_id, self.name, self.parent_id)
482
565
class InventoryFile(InventoryEntry):
483
566
    """A file in an inventory."""
484
567
 
485
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
486
 
                 'text_id', 'parent_id', 'children', 'executable',
487
 
                 'revision', 'symlink_target', 'reference_revision']
488
 
 
489
 
    def _check(self, checker, tree_revision_id):
 
568
    def _check(self, checker, tree_revision_id, tree):
490
569
        """See InventoryEntry._check"""
491
 
        # TODO: check size too.
492
 
        checker.add_pending_item(tree_revision_id,
493
 
            ('texts', self.file_id, self.revision), 'text',
494
 
             self.text_sha1)
495
 
        if self.text_size is None:
496
 
            checker._report_items.append(
497
 
                'fileid {%s} in {%s} has None for text_size' % (self.file_id,
498
 
                tree_revision_id))
 
570
        t = (self.file_id, self.revision)
 
571
        if t in checker.checked_texts:
 
572
            prev_sha = checker.checked_texts[t]
 
573
            if prev_sha != self.text_sha1:
 
574
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
 
575
                                    (self.file_id, tree_revision_id))
 
576
            else:
 
577
                checker.repeated_text_cnt += 1
 
578
                return
 
579
 
 
580
        if self.file_id not in checker.checked_weaves:
 
581
            mutter('check weave {%s}', self.file_id)
 
582
            w = tree.get_weave(self.file_id)
 
583
            # Not passing a progress bar, because it creates a new
 
584
            # progress, which overwrites the current progress,
 
585
            # and doesn't look nice
 
586
            w.check()
 
587
            checker.checked_weaves[self.file_id] = True
 
588
        else:
 
589
            w = tree.get_weave(self.file_id)
 
590
 
 
591
        mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
 
592
        checker.checked_text_cnt += 1
 
593
        # We can't check the length, because Weave doesn't store that
 
594
        # information, and the whole point of looking at the weave's
 
595
        # sha1sum is that we don't have to extract the text.
 
596
        if self.text_sha1 != w.get_sha1(self.revision):
 
597
            raise BzrCheckError('text {%s} version {%s} wrong sha1' 
 
598
                                % (self.file_id, self.revision))
 
599
        checker.checked_texts[t] = self.text_sha1
499
600
 
500
601
    def copy(self):
501
602
        other = InventoryFile(self.file_id, self.name, self.parent_id)
508
609
 
509
610
    def detect_changes(self, old_entry):
510
611
        """See InventoryEntry.detect_changes."""
 
612
        assert self.text_sha1 != None
 
613
        assert old_entry.text_sha1 != None
511
614
        text_modified = (self.text_sha1 != old_entry.text_sha1)
512
615
        meta_modified = (self.executable != old_entry.executable)
513
616
        return text_modified, meta_modified
515
618
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
516
619
             output_to, reverse=False):
517
620
        """See InventoryEntry._diff."""
518
 
        from bzrlib.diff import DiffText
519
 
        from_file_id = self.file_id
520
 
        if to_entry:
521
 
            to_file_id = to_entry.file_id
522
 
        else:
523
 
            to_file_id = None
524
 
        if reverse:
525
 
            to_file_id, from_file_id = from_file_id, to_file_id
526
 
            tree, to_tree = to_tree, tree
527
 
            from_label, to_label = to_label, from_label
528
 
        differ = DiffText(tree, to_tree, output_to, 'utf-8', '', '',
529
 
                          text_diff)
530
 
        return differ.diff_text(from_file_id, to_file_id, from_label, to_label)
 
621
        try:
 
622
            from_text = tree.get_file(self.file_id).readlines()
 
623
            if to_entry:
 
624
                to_text = to_tree.get_file(to_entry.file_id).readlines()
 
625
            else:
 
626
                to_text = []
 
627
            if not reverse:
 
628
                text_diff(from_label, from_text,
 
629
                          to_label, to_text, output_to)
 
630
            else:
 
631
                text_diff(to_label, to_text,
 
632
                          from_label, from_text, output_to)
 
633
        except BinaryFile:
 
634
            if reverse:
 
635
                label_pair = (to_label, from_label)
 
636
            else:
 
637
                label_pair = (from_label, to_label)
 
638
            print >> output_to, "Binary files %s and %s differ" % label_pair
531
639
 
532
640
    def has_text(self):
533
641
        """See InventoryEntry.has_text."""
554
662
 
555
663
    def _put_on_disk(self, fullpath, tree):
556
664
        """See InventoryEntry._put_on_disk."""
557
 
        osutils.pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
 
665
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
558
666
        if tree.is_executable(self.file_id):
559
667
            os.chmod(fullpath, 0755)
560
668
 
561
669
    def _read_tree_state(self, path, work_tree):
562
670
        """See InventoryEntry._read_tree_state."""
563
 
        self.text_sha1 = work_tree.get_file_sha1(self.file_id, path=path)
564
 
        # FIXME: 20050930 probe for the text size when getting sha1
565
 
        # in _read_tree_state
566
 
        self.executable = work_tree.is_executable(self.file_id, path=path)
567
 
 
568
 
    def __repr__(self):
569
 
        return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s, revision=%s)"
570
 
                % (self.__class__.__name__,
571
 
                   self.file_id,
572
 
                   self.name,
573
 
                   self.parent_id,
574
 
                   self.text_sha1,
575
 
                   self.text_size,
576
 
                   self.revision))
 
671
        self.text_sha1 = work_tree.get_file_sha1(self.file_id)
 
672
        self.executable = work_tree.is_executable(self.file_id)
577
673
 
578
674
    def _forget_tree_state(self):
579
675
        self.text_sha1 = None
 
676
        self.executable = None
 
677
 
 
678
    def _snapshot_text(self, file_parents, work_tree, versionedfile_store, transaction):
 
679
        """See InventoryEntry._snapshot_text."""
 
680
        mutter('storing text of file {%s} in revision {%s} into %r',
 
681
               self.file_id, self.revision, versionedfile_store)
 
682
        # special case to avoid diffing on renames or 
 
683
        # reparenting
 
684
        if (len(file_parents) == 1
 
685
            and self.text_sha1 == file_parents.values()[0].text_sha1
 
686
            and self.text_size == file_parents.values()[0].text_size):
 
687
            previous_ie = file_parents.values()[0]
 
688
            versionedfile = versionedfile_store.get_weave(self.file_id, transaction)
 
689
            versionedfile.clone_text(self.revision, previous_ie.revision, file_parents.keys())
 
690
        else:
 
691
            new_lines = work_tree.get_file(self.file_id).readlines()
 
692
            self._add_text_to_weave(new_lines, file_parents.keys(), versionedfile_store,
 
693
                                    transaction)
 
694
            self.text_sha1 = sha_strings(new_lines)
 
695
            self.text_size = sum(map(len, new_lines))
 
696
 
580
697
 
581
698
    def _unchanged(self, previous_ie):
582
699
        """See InventoryEntry._unchanged."""
595
712
class InventoryLink(InventoryEntry):
596
713
    """A file in an inventory."""
597
714
 
598
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
599
 
                 'text_id', 'parent_id', 'children', 'executable',
600
 
                 'revision', 'symlink_target', 'reference_revision']
 
715
    __slots__ = ['symlink_target']
601
716
 
602
 
    def _check(self, checker, tree_revision_id):
 
717
    def _check(self, checker, rev_id, tree):
603
718
        """See InventoryEntry._check"""
604
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
605
 
            checker._report_items.append(
606
 
               'symlink {%s} has text in revision {%s}'
607
 
                    % (self.file_id, tree_revision_id))
608
 
        if self.symlink_target is None:
609
 
            checker._report_items.append(
610
 
                'symlink {%s} has no target in revision {%s}'
611
 
                    % (self.file_id, tree_revision_id))
612
 
        # Symlinks are stored as ''
613
 
        checker.add_pending_item(tree_revision_id,
614
 
            ('texts', self.file_id, self.revision), 'text',
615
 
             'da39a3ee5e6b4b0d3255bfef95601890afd80709')
 
719
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
720
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
 
721
                    % (self.file_id, rev_id))
 
722
        if self.symlink_target == None:
 
723
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
 
724
                    % (self.file_id, rev_id))
616
725
 
617
726
    def copy(self):
618
727
        other = InventoryLink(self.file_id, self.name, self.parent_id)
632
741
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
633
742
             output_to, reverse=False):
634
743
        """See InventoryEntry._diff."""
635
 
        from bzrlib.diff import DiffSymlink
636
 
        old_target = self.symlink_target
 
744
        from_text = self.symlink_target
637
745
        if to_entry is not None:
638
 
            new_target = to_entry.symlink_target
639
 
        else:
640
 
            new_target = None
641
 
        if not reverse:
642
 
            old_tree = tree
643
 
            new_tree = to_tree
644
 
        else:
645
 
            old_tree = to_tree
646
 
            new_tree = tree
647
 
            new_target, old_target = old_target, new_target
648
 
        differ = DiffSymlink(old_tree, new_tree, output_to)
649
 
        return differ.diff_symlink(old_target, new_target)
 
746
            to_text = to_entry.symlink_target
 
747
            if reverse:
 
748
                temp = from_text
 
749
                from_text = to_text
 
750
                to_text = temp
 
751
            print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
 
752
        else:
 
753
            if not reverse:
 
754
                print >>output_to, '=== target was %r' % self.symlink_target
 
755
            else:
 
756
                print >>output_to, '=== target is %r' % self.symlink_target
650
757
 
651
758
    def __init__(self, file_id, name, parent_id):
652
759
        super(InventoryLink, self).__init__(file_id, name, parent_id)
687
794
        return compatible
688
795
 
689
796
 
690
 
class TreeReference(InventoryEntry):
691
 
 
692
 
    kind = 'tree-reference'
693
 
 
694
 
    def __init__(self, file_id, name, parent_id, revision=None,
695
 
                 reference_revision=None):
696
 
        InventoryEntry.__init__(self, file_id, name, parent_id)
697
 
        self.revision = revision
698
 
        self.reference_revision = reference_revision
699
 
 
700
 
    def copy(self):
701
 
        return TreeReference(self.file_id, self.name, self.parent_id,
702
 
                             self.revision, self.reference_revision)
703
 
 
704
 
    def _read_tree_state(self, path, work_tree):
705
 
        """Populate fields in the inventory entry from the given tree.
706
 
        """
707
 
        self.reference_revision = work_tree.get_reference_revision(
708
 
            self.file_id, path)
709
 
 
710
 
    def _forget_tree_state(self):
711
 
        self.reference_revision = None
712
 
 
713
 
    def _unchanged(self, previous_ie):
714
 
        """See InventoryEntry._unchanged."""
715
 
        compatible = super(TreeReference, self)._unchanged(previous_ie)
716
 
        if self.reference_revision != previous_ie.reference_revision:
717
 
            compatible = False
718
 
        return compatible
719
 
 
720
 
 
721
 
class CommonInventory(object):
722
 
    """Basic inventory logic, defined in terms of primitives like has_id.
723
 
 
724
 
    An inventory is the metadata about the contents of a tree.
725
 
 
726
 
    This is broadly a map from file_id to entries such as directories, files,
727
 
    symlinks and tree references. Each entry maintains its own metadata like
728
 
    SHA1 and length for files, or children for a directory.
729
 
 
 
797
class Inventory(object):
 
798
    """Inventory of versioned files in a tree.
 
799
 
 
800
    This describes which file_id is present at each point in the tree,
 
801
    and possibly the SHA-1 or other information about the file.
730
802
    Entries can be looked up either by path or by file_id.
731
803
 
 
804
    The inventory represents a typical unix file tree, with
 
805
    directories containing files and subdirectories.  We never store
 
806
    the full path to a file, because renaming a directory implicitly
 
807
    moves all of its contents.  This class internally maintains a
 
808
    lookup tree that allows the children under a directory to be
 
809
    returned quickly.
 
810
 
732
811
    InventoryEntry objects must not be modified after they are
733
812
    inserted, other than through the Inventory API.
734
 
    """
735
 
 
736
 
    def __contains__(self, file_id):
737
 
        """True if this entry contains a file with given id.
738
 
 
739
 
        >>> inv = Inventory()
740
 
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
741
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)
742
 
        >>> '123' in inv
743
 
        True
744
 
        >>> '456' in inv
745
 
        False
746
 
 
747
 
        Note that this method along with __iter__ are not encouraged for use as
748
 
        they are less clear than specific query methods - they may be rmeoved
749
 
        in the future.
750
 
        """
751
 
        return self.has_id(file_id)
752
 
 
753
 
    def has_filename(self, filename):
754
 
        return bool(self.path2id(filename))
755
 
 
756
 
    def id2path(self, file_id):
757
 
        """Return as a string the path to file_id.
758
 
 
759
 
        >>> i = Inventory()
760
 
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
761
 
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
762
 
        >>> print i.id2path('foo-id')
763
 
        src/foo.c
764
 
 
765
 
        :raises NoSuchId: If file_id is not present in the inventory.
766
 
        """
767
 
        # get all names, skipping root
768
 
        return '/'.join(reversed(
769
 
            [parent.name for parent in
770
 
             self._iter_file_id_parents(file_id)][:-1]))
771
 
 
772
 
    def iter_entries(self, from_dir=None, recursive=True):
773
 
        """Return (path, entry) pairs, in order by name.
774
 
        
775
 
        :param from_dir: if None, start from the root,
776
 
          otherwise start from this directory (either file-id or entry)
777
 
        :param recursive: recurse into directories or not
778
 
        """
779
 
        if from_dir is None:
780
 
            if self.root is None:
781
 
                return
782
 
            from_dir = self.root
783
 
            yield '', self.root
784
 
        elif isinstance(from_dir, basestring):
785
 
            from_dir = self[from_dir]
786
 
 
787
 
        # unrolling the recursive called changed the time from
788
 
        # 440ms/663ms (inline/total) to 116ms/116ms
789
 
        children = from_dir.children.items()
790
 
        children.sort()
791
 
        if not recursive:
792
 
            for name, ie in children:
793
 
                yield name, ie
794
 
            return
795
 
        children = collections.deque(children)
796
 
        stack = [(u'', children)]
797
 
        while stack:
798
 
            from_dir_relpath, children = stack[-1]
799
 
 
800
 
            while children:
801
 
                name, ie = children.popleft()
802
 
 
803
 
                # we know that from_dir_relpath never ends in a slash
804
 
                # and 'f' doesn't begin with one, we can do a string op, rather
805
 
                # than the checks of pathjoin(), though this means that all paths
806
 
                # start with a slash
807
 
                path = from_dir_relpath + '/' + name
808
 
 
809
 
                yield path[1:], ie
810
 
 
811
 
                if ie.kind != 'directory':
812
 
                    continue
813
 
 
814
 
                # But do this child first
815
 
                new_children = ie.children.items()
816
 
                new_children.sort()
817
 
                new_children = collections.deque(new_children)
818
 
                stack.append((path, new_children))
819
 
                # Break out of inner loop, so that we start outer loop with child
820
 
                break
821
 
            else:
822
 
                # if we finished all children, pop it off the stack
823
 
                stack.pop()
824
 
 
825
 
    def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None,
826
 
        yield_parents=False):
827
 
        """Iterate over the entries in a directory first order.
828
 
 
829
 
        This returns all entries for a directory before returning
830
 
        the entries for children of a directory. This is not
831
 
        lexicographically sorted order, and is a hybrid between
832
 
        depth-first and breadth-first.
833
 
 
834
 
        :param yield_parents: If True, yield the parents from the root leading
835
 
            down to specific_file_ids that have been requested. This has no
836
 
            impact if specific_file_ids is None.
837
 
        :return: This yields (path, entry) pairs
838
 
        """
839
 
        if specific_file_ids and not isinstance(specific_file_ids, set):
840
 
            specific_file_ids = set(specific_file_ids)
841
 
        # TODO? Perhaps this should return the from_dir so that the root is
842
 
        # yielded? or maybe an option?
843
 
        if from_dir is None:
844
 
            if self.root is None:
845
 
                return
846
 
            # Optimize a common case
847
 
            if (not yield_parents and specific_file_ids is not None and
848
 
                len(specific_file_ids) == 1):
849
 
                file_id = list(specific_file_ids)[0]
850
 
                if file_id in self:
851
 
                    yield self.id2path(file_id), self[file_id]
852
 
                return
853
 
            from_dir = self.root
854
 
            if (specific_file_ids is None or yield_parents or
855
 
                self.root.file_id in specific_file_ids):
856
 
                yield u'', self.root
857
 
        elif isinstance(from_dir, basestring):
858
 
            from_dir = self[from_dir]
859
 
 
860
 
        if specific_file_ids is not None:
861
 
            # TODO: jam 20070302 This could really be done as a loop rather
862
 
            #       than a bunch of recursive calls.
863
 
            parents = set()
864
 
            byid = self
865
 
            def add_ancestors(file_id):
866
 
                if file_id not in byid:
867
 
                    return
868
 
                parent_id = byid[file_id].parent_id
869
 
                if parent_id is None:
870
 
                    return
871
 
                if parent_id not in parents:
872
 
                    parents.add(parent_id)
873
 
                    add_ancestors(parent_id)
874
 
            for file_id in specific_file_ids:
875
 
                add_ancestors(file_id)
876
 
        else:
877
 
            parents = None
878
 
 
879
 
        stack = [(u'', from_dir)]
880
 
        while stack:
881
 
            cur_relpath, cur_dir = stack.pop()
882
 
 
883
 
            child_dirs = []
884
 
            for child_name, child_ie in sorted(cur_dir.children.iteritems()):
885
 
 
886
 
                child_relpath = cur_relpath + child_name
887
 
 
888
 
                if (specific_file_ids is None or
889
 
                    child_ie.file_id in specific_file_ids or
890
 
                    (yield_parents and child_ie.file_id in parents)):
891
 
                    yield child_relpath, child_ie
892
 
 
893
 
                if child_ie.kind == 'directory':
894
 
                    if parents is None or child_ie.file_id in parents:
895
 
                        child_dirs.append((child_relpath+'/', child_ie))
896
 
            stack.extend(reversed(child_dirs))
897
 
 
898
 
    def _make_delta(self, old):
899
 
        """Make an inventory delta from two inventories."""
900
 
        old_ids = set(old)
901
 
        new_ids = set(self)
902
 
        adds = new_ids - old_ids
903
 
        deletes = old_ids - new_ids
904
 
        common = old_ids.intersection(new_ids)
905
 
        delta = []
906
 
        for file_id in deletes:
907
 
            delta.append((old.id2path(file_id), None, file_id, None))
908
 
        for file_id in adds:
909
 
            delta.append((None, self.id2path(file_id), file_id, self[file_id]))
910
 
        for file_id in common:
911
 
            if old[file_id] != self[file_id]:
912
 
                delta.append((old.id2path(file_id), self.id2path(file_id),
913
 
                    file_id, self[file_id]))
914
 
        return delta
915
 
 
916
 
    def _get_mutable_inventory(self):
917
 
        """Returns a mutable copy of the object.
918
 
 
919
 
        Some inventories are immutable, yet working trees, for example, needs
920
 
        to mutate exisiting inventories instead of creating a new one.
921
 
        """
922
 
        raise NotImplementedError(self._get_mutable_inventory)
923
 
 
924
 
    def make_entry(self, kind, name, parent_id, file_id=None):
925
 
        """Simple thunk to bzrlib.inventory.make_entry."""
926
 
        return make_entry(kind, name, parent_id, file_id)
927
 
 
928
 
    def entries(self):
929
 
        """Return list of (path, ie) for all entries except the root.
930
 
 
931
 
        This may be faster than iter_entries.
932
 
        """
933
 
        accum = []
934
 
        def descend(dir_ie, dir_path):
935
 
            kids = dir_ie.children.items()
936
 
            kids.sort()
937
 
            for name, ie in kids:
938
 
                child_path = osutils.pathjoin(dir_path, name)
939
 
                accum.append((child_path, ie))
940
 
                if ie.kind == 'directory':
941
 
                    descend(ie, child_path)
942
 
 
943
 
        descend(self.root, u'')
944
 
        return accum
945
 
 
946
 
    def directories(self):
947
 
        """Return (path, entry) pairs for all directories, including the root.
948
 
        """
949
 
        accum = []
950
 
        def descend(parent_ie, parent_path):
951
 
            accum.append((parent_path, parent_ie))
952
 
 
953
 
            kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
954
 
            kids.sort()
955
 
 
956
 
            for name, child_ie in kids:
957
 
                child_path = osutils.pathjoin(parent_path, name)
958
 
                descend(child_ie, child_path)
959
 
        descend(self.root, u'')
960
 
        return accum
961
 
 
962
 
    def path2id(self, relpath):
963
 
        """Walk down through directories to return entry of last component.
964
 
 
965
 
        :param relpath: may be either a list of path components, or a single
966
 
            string, in which case it is automatically split.
967
 
 
968
 
        This returns the entry of the last component in the path,
969
 
        which may be either a file or a directory.
970
 
 
971
 
        Returns None IFF the path is not found.
972
 
        """
973
 
        if isinstance(relpath, basestring):
974
 
            names = osutils.splitpath(relpath)
975
 
        else:
976
 
            names = relpath
977
 
 
978
 
        try:
979
 
            parent = self.root
980
 
        except errors.NoSuchId:
981
 
            # root doesn't exist yet so nothing else can
982
 
            return None
983
 
        if parent is None:
984
 
            return None
985
 
        for f in names:
986
 
            try:
987
 
                children = getattr(parent, 'children', None)
988
 
                if children is None:
989
 
                    return None
990
 
                cie = children[f]
991
 
                parent = cie
992
 
            except KeyError:
993
 
                # or raise an error?
994
 
                return None
995
 
 
996
 
        return parent.file_id
997
 
 
998
 
    def filter(self, specific_fileids):
999
 
        """Get an inventory view filtered against a set of file-ids.
1000
 
 
1001
 
        Children of directories and parents are included.
1002
 
 
1003
 
        The result may or may not reference the underlying inventory
1004
 
        so it should be treated as immutable.
1005
 
        """
1006
 
        interesting_parents = set()
1007
 
        for fileid in specific_fileids:
1008
 
            try:
1009
 
                interesting_parents.update(self.get_idpath(fileid))
1010
 
            except errors.NoSuchId:
1011
 
                # This fileid is not in the inventory - that's ok
1012
 
                pass
1013
 
        entries = self.iter_entries()
1014
 
        if self.root is None:
1015
 
            return Inventory(root_id=None)
1016
 
        other = Inventory(entries.next()[1].file_id)
1017
 
        other.root.revision = self.root.revision
1018
 
        other.revision_id = self.revision_id
1019
 
        directories_to_expand = set()
1020
 
        for path, entry in entries:
1021
 
            file_id = entry.file_id
1022
 
            if (file_id in specific_fileids
1023
 
                or entry.parent_id in directories_to_expand):
1024
 
                if entry.kind == 'directory':
1025
 
                    directories_to_expand.add(file_id)
1026
 
            elif file_id not in interesting_parents:
1027
 
                continue
1028
 
            other.add(entry.copy())
1029
 
        return other
1030
 
 
1031
 
    def get_idpath(self, file_id):
1032
 
        """Return a list of file_ids for the path to an entry.
1033
 
 
1034
 
        The list contains one element for each directory followed by
1035
 
        the id of the file itself.  So the length of the returned list
1036
 
        is equal to the depth of the file in the tree, counting the
1037
 
        root directory as depth 1.
1038
 
        """
1039
 
        p = []
1040
 
        for parent in self._iter_file_id_parents(file_id):
1041
 
            p.insert(0, parent.file_id)
1042
 
        return p
1043
 
 
1044
 
 
1045
 
class Inventory(CommonInventory):
1046
 
    """Mutable dict based in-memory inventory.
1047
 
 
1048
 
    We never store the full path to a file, because renaming a directory
1049
 
    implicitly moves all of its contents.  This class internally maintains a
1050
 
    lookup tree that allows the children under a directory to be
1051
 
    returned quickly.
1052
813
 
1053
814
    >>> inv = Inventory()
1054
815
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
1055
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)
 
816
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
1056
817
    >>> inv['123-123'].name
1057
818
    'hello.c'
1058
819
 
1059
 
    Id's may be looked up from paths:
1060
 
 
1061
 
    >>> inv.path2id('hello.c')
1062
 
    '123-123'
 
820
    May be treated as an iterator or set to look up file ids:
 
821
    
 
822
    >>> bool(inv.path2id('hello.c'))
 
823
    True
1063
824
    >>> '123-123' in inv
1064
825
    True
1065
826
 
1066
 
    There are iterators over the contents:
 
827
    May also look up by name:
1067
828
 
1068
 
    >>> [entry[0] for entry in inv.iter_entries()]
1069
 
    ['', u'hello.c']
 
829
    >>> [x[0] for x in inv.iter_entries()]
 
830
    ['hello.c']
 
831
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
 
832
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
 
833
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
1070
834
    """
1071
 
 
1072
835
    def __init__(self, root_id=ROOT_ID, revision_id=None):
1073
836
        """Create or read an inventory.
1074
837
 
1079
842
        The inventory is created with a default root directory, with
1080
843
        an id of None.
1081
844
        """
1082
 
        if root_id is not None:
1083
 
            self._set_root(InventoryDirectory(root_id, u'', None))
1084
 
        else:
1085
 
            self.root = None
1086
 
            self._byid = {}
 
845
        # We are letting Branch.create() create a unique inventory
 
846
        # root id. Rather than generating a random one here.
 
847
        #if root_id is None:
 
848
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
 
849
        self.root = RootEntry(root_id)
1087
850
        self.revision_id = revision_id
1088
 
 
1089
 
    def __repr__(self):
1090
 
        # More than one page of ouput is not useful anymore to debug
1091
 
        max_len = 2048
1092
 
        closing = '...}'
1093
 
        contents = repr(self._byid)
1094
 
        if len(contents) > max_len:
1095
 
            contents = contents[:(max_len-len(closing))] + closing
1096
 
        return "<Inventory object at %x, contents=%r>" % (id(self), contents)
1097
 
 
1098
 
    def apply_delta(self, delta):
1099
 
        """Apply a delta to this inventory.
1100
 
 
1101
 
        See the inventory developers documentation for the theory behind
1102
 
        inventory deltas.
1103
 
 
1104
 
        If delta application fails the inventory is left in an indeterminate
1105
 
        state and must not be used.
1106
 
 
1107
 
        :param delta: A list of changes to apply. After all the changes are
1108
 
            applied the final inventory must be internally consistent, but it
1109
 
            is ok to supply changes which, if only half-applied would have an
1110
 
            invalid result - such as supplying two changes which rename two
1111
 
            files, 'A' and 'B' with each other : [('A', 'B', 'A-id', a_entry),
1112
 
            ('B', 'A', 'B-id', b_entry)].
1113
 
 
1114
 
            Each change is a tuple, of the form (old_path, new_path, file_id,
1115
 
            new_entry).
1116
 
 
1117
 
            When new_path is None, the change indicates the removal of an entry
1118
 
            from the inventory and new_entry will be ignored (using None is
1119
 
            appropriate). If new_path is not None, then new_entry must be an
1120
 
            InventoryEntry instance, which will be incorporated into the
1121
 
            inventory (and replace any existing entry with the same file id).
1122
 
 
1123
 
            When old_path is None, the change indicates the addition of
1124
 
            a new entry to the inventory.
1125
 
 
1126
 
            When neither new_path nor old_path are None, the change is a
1127
 
            modification to an entry, such as a rename, reparent, kind change
1128
 
            etc.
1129
 
 
1130
 
            The children attribute of new_entry is ignored. This is because
1131
 
            this method preserves children automatically across alterations to
1132
 
            the parent of the children, and cases where the parent id of a
1133
 
            child is changing require the child to be passed in as a separate
1134
 
            change regardless. E.g. in the recursive deletion of a directory -
1135
 
            the directory's children must be included in the delta, or the
1136
 
            final inventory will be invalid.
1137
 
 
1138
 
            Note that a file_id must only appear once within a given delta.
1139
 
            An AssertionError is raised otherwise.
1140
 
        """
1141
 
        # Check that the delta is legal. It would be nice if this could be
1142
 
        # done within the loops below but it's safer to validate the delta
1143
 
        # before starting to mutate the inventory, as there isn't a rollback
1144
 
        # facility.
1145
 
        list(_check_delta_unique_ids(_check_delta_unique_new_paths(
1146
 
            _check_delta_unique_old_paths(_check_delta_ids_match_entry(
1147
 
            _check_delta_ids_are_valid(
1148
 
            _check_delta_new_path_entry_both_or_None(
1149
 
            delta)))))))
1150
 
 
1151
 
        children = {}
1152
 
        # Remove all affected items which were in the original inventory,
1153
 
        # starting with the longest paths, thus ensuring parents are examined
1154
 
        # after their children, which means that everything we examine has no
1155
 
        # modified children remaining by the time we examine it.
1156
 
        for old_path, file_id in sorted(((op, f) for op, np, f, e in delta
1157
 
                                        if op is not None), reverse=True):
1158
 
            # Preserve unaltered children of file_id for later reinsertion.
1159
 
            file_id_children = getattr(self[file_id], 'children', {})
1160
 
            if len(file_id_children):
1161
 
                children[file_id] = file_id_children
1162
 
            if self.id2path(file_id) != old_path:
1163
 
                raise errors.InconsistentDelta(old_path, file_id,
1164
 
                    "Entry was at wrong other path %r." % self.id2path(file_id))
1165
 
            # Remove file_id and the unaltered children. If file_id is not
1166
 
            # being deleted it will be reinserted back later.
1167
 
            self.remove_recursive_id(file_id)
1168
 
        # Insert all affected which should be in the new inventory, reattaching
1169
 
        # their children if they had any. This is done from shortest path to
1170
 
        # longest, ensuring that items which were modified and whose parents in
1171
 
        # the resulting inventory were also modified, are inserted after their
1172
 
        # parents.
1173
 
        for new_path, f, new_entry in sorted((np, f, e) for op, np, f, e in
1174
 
                                          delta if np is not None):
1175
 
            if new_entry.kind == 'directory':
1176
 
                # Pop the child which to allow detection of children whose
1177
 
                # parents were deleted and which were not reattached to a new
1178
 
                # parent.
1179
 
                replacement = InventoryDirectory(new_entry.file_id,
1180
 
                    new_entry.name, new_entry.parent_id)
1181
 
                replacement.revision = new_entry.revision
1182
 
                replacement.children = children.pop(replacement.file_id, {})
1183
 
                new_entry = replacement
1184
 
            try:
1185
 
                self.add(new_entry)
1186
 
            except errors.DuplicateFileId:
1187
 
                raise errors.InconsistentDelta(new_path, new_entry.file_id,
1188
 
                    "New id is already present in target.")
1189
 
            except AttributeError:
1190
 
                raise errors.InconsistentDelta(new_path, new_entry.file_id,
1191
 
                    "Parent is not a directory.")
1192
 
            if self.id2path(new_entry.file_id) != new_path:
1193
 
                raise errors.InconsistentDelta(new_path, new_entry.file_id,
1194
 
                    "New path is not consistent with parent path.")
1195
 
        if len(children):
1196
 
            # Get the parent id that was deleted
1197
 
            parent_id, children = children.popitem()
1198
 
            raise errors.InconsistentDelta("<deleted>", parent_id,
1199
 
                "The file id was deleted but its children were not deleted.")
1200
 
 
1201
 
    def create_by_apply_delta(self, inventory_delta, new_revision_id,
1202
 
                              propagate_caches=False):
1203
 
        """See CHKInventory.create_by_apply_delta()"""
1204
 
        new_inv = self.copy()
1205
 
        new_inv.apply_delta(inventory_delta)
1206
 
        new_inv.revision_id = new_revision_id
1207
 
        return new_inv
1208
 
 
1209
 
    def _set_root(self, ie):
1210
 
        self.root = ie
1211
851
        self._byid = {self.root.file_id: self.root}
1212
852
 
 
853
 
1213
854
    def copy(self):
1214
855
        # TODO: jam 20051218 Should copy also copy the revision_id?
1215
 
        entries = self.iter_entries()
1216
 
        if self.root is None:
1217
 
            return Inventory(root_id=None)
1218
 
        other = Inventory(entries.next()[1].file_id)
1219
 
        other.root.revision = self.root.revision
 
856
        other = Inventory(self.root.file_id)
1220
857
        # copy recursively so we know directories will be added before
1221
858
        # their children.  There are more efficient ways than this...
1222
 
        for path, entry in entries:
 
859
        for path, entry in self.iter_entries():
 
860
            if entry == self.root:
 
861
                continue
1223
862
            other.add(entry.copy())
1224
863
        return other
1225
864
 
1226
 
    def _get_mutable_inventory(self):
1227
 
        """See CommonInventory._get_mutable_inventory."""
1228
 
        return copy.deepcopy(self)
1229
865
 
1230
866
    def __iter__(self):
1231
 
        """Iterate over all file-ids."""
1232
867
        return iter(self._byid)
1233
868
 
1234
 
    def iter_just_entries(self):
1235
 
        """Iterate over all entries.
1236
 
        
1237
 
        Unlike iter_entries(), just the entries are returned (not (path, ie))
1238
 
        and the order of entries is undefined.
1239
 
 
1240
 
        XXX: We may not want to merge this into bzr.dev.
1241
 
        """
1242
 
        if self.root is None:
1243
 
            return
1244
 
        for _, ie in self._byid.iteritems():
1245
 
            yield ie
1246
869
 
1247
870
    def __len__(self):
1248
871
        """Returns number of entries."""
1249
872
        return len(self._byid)
1250
873
 
 
874
 
 
875
    def iter_entries(self, from_dir=None):
 
876
        """Return (path, entry) pairs, in order by name."""
 
877
        if from_dir == None:
 
878
            assert self.root
 
879
            from_dir = self.root
 
880
        elif isinstance(from_dir, basestring):
 
881
            from_dir = self._byid[from_dir]
 
882
            
 
883
        kids = from_dir.children.items()
 
884
        kids.sort()
 
885
        for name, ie in kids:
 
886
            yield name, ie
 
887
            if ie.kind == 'directory':
 
888
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
 
889
                    yield pathjoin(name, cn), cie
 
890
 
 
891
 
 
892
    def entries(self):
 
893
        """Return list of (path, ie) for all entries except the root.
 
894
 
 
895
        This may be faster than iter_entries.
 
896
        """
 
897
        accum = []
 
898
        def descend(dir_ie, dir_path):
 
899
            kids = dir_ie.children.items()
 
900
            kids.sort()
 
901
            for name, ie in kids:
 
902
                child_path = pathjoin(dir_path, name)
 
903
                accum.append((child_path, ie))
 
904
                if ie.kind == 'directory':
 
905
                    descend(ie, child_path)
 
906
 
 
907
        descend(self.root, u'')
 
908
        return accum
 
909
 
 
910
 
 
911
    def directories(self):
 
912
        """Return (path, entry) pairs for all directories, including the root.
 
913
        """
 
914
        accum = []
 
915
        def descend(parent_ie, parent_path):
 
916
            accum.append((parent_path, parent_ie))
 
917
            
 
918
            kids = [(ie.name, ie) for ie in parent_ie.children.itervalues() if ie.kind == 'directory']
 
919
            kids.sort()
 
920
 
 
921
            for name, child_ie in kids:
 
922
                child_path = pathjoin(parent_path, name)
 
923
                descend(child_ie, child_path)
 
924
        descend(self.root, u'')
 
925
        return accum
 
926
        
 
927
 
 
928
 
 
929
    def __contains__(self, file_id):
 
930
        """True if this entry contains a file with given id.
 
931
 
 
932
        >>> inv = Inventory()
 
933
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
 
934
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
 
935
        >>> '123' in inv
 
936
        True
 
937
        >>> '456' in inv
 
938
        False
 
939
        """
 
940
        return file_id in self._byid
 
941
 
 
942
 
1251
943
    def __getitem__(self, file_id):
1252
944
        """Return the entry for given file_id.
1253
945
 
1254
946
        >>> inv = Inventory()
1255
947
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
1256
 
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)
 
948
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
1257
949
        >>> inv['123123'].name
1258
950
        'hello.c'
1259
951
        """
1260
952
        try:
1261
953
            return self._byid[file_id]
1262
954
        except KeyError:
1263
 
            # really we're passing an inventory, not a tree...
1264
 
            raise errors.NoSuchId(self, file_id)
 
955
            if file_id == None:
 
956
                raise BzrError("can't look up file_id None")
 
957
            else:
 
958
                raise BzrError("file_id {%s} not in inventory" % file_id)
 
959
 
1265
960
 
1266
961
    def get_file_kind(self, file_id):
1267
962
        return self._byid[file_id].kind
1269
964
    def get_child(self, parent_id, filename):
1270
965
        return self[parent_id].children.get(filename)
1271
966
 
1272
 
    def _add_child(self, entry):
1273
 
        """Add an entry to the inventory, without adding it to its parent"""
1274
 
        if entry.file_id in self._byid:
1275
 
            raise BzrError("inventory already contains entry with id {%s}" %
1276
 
                           entry.file_id)
1277
 
        self._byid[entry.file_id] = entry
1278
 
        for child in getattr(entry, 'children', {}).itervalues():
1279
 
            self._add_child(child)
1280
 
        return entry
1281
967
 
1282
968
    def add(self, entry):
1283
969
        """Add entry to inventory.
1285
971
        To add  a file to a branch ready to be committed, use Branch.add,
1286
972
        which calls this.
1287
973
 
1288
 
        :return: entry
 
974
        Returns the new entry object.
1289
975
        """
1290
976
        if entry.file_id in self._byid:
1291
 
            raise errors.DuplicateFileId(entry.file_id,
1292
 
                                         self._byid[entry.file_id])
1293
 
        if entry.parent_id is None:
1294
 
            self.root = entry
1295
 
        else:
1296
 
            try:
1297
 
                parent = self._byid[entry.parent_id]
1298
 
            except KeyError:
1299
 
                raise errors.InconsistentDelta("<unknown>", entry.parent_id,
1300
 
                    "Parent not in inventory.")
1301
 
            if entry.name in parent.children:
1302
 
                raise errors.InconsistentDelta(
1303
 
                    self.id2path(parent.children[entry.name].file_id),
1304
 
                    entry.file_id,
1305
 
                    "Path already versioned")
1306
 
            parent.children[entry.name] = entry
1307
 
        return self._add_child(entry)
1308
 
 
1309
 
    def add_path(self, relpath, kind, file_id=None, parent_id=None):
 
977
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
 
978
 
 
979
        if entry.parent_id == ROOT_ID or entry.parent_id is None:
 
980
            entry.parent_id = self.root.file_id
 
981
 
 
982
        try:
 
983
            parent = self._byid[entry.parent_id]
 
984
        except KeyError:
 
985
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
 
986
 
 
987
        if parent.children.has_key(entry.name):
 
988
            raise BzrError("%s is already versioned" %
 
989
                    pathjoin(self.id2path(parent.file_id), entry.name))
 
990
 
 
991
        self._byid[entry.file_id] = entry
 
992
        parent.children[entry.name] = entry
 
993
        return entry
 
994
 
 
995
 
 
996
    def add_path(self, relpath, kind, file_id=None):
1310
997
        """Add entry from a path.
1311
998
 
1312
999
        The immediate parent must already be versioned.
1313
1000
 
1314
1001
        Returns the new entry object."""
1315
 
 
1316
 
        parts = osutils.splitpath(relpath)
 
1002
        
 
1003
        parts = bzrlib.osutils.splitpath(relpath)
1317
1004
 
1318
1005
        if len(parts) == 0:
1319
1006
            if file_id is None:
1320
 
                file_id = generate_ids.gen_root_id()
1321
 
            self.root = InventoryDirectory(file_id, '', None)
 
1007
                file_id = bzrlib.workingtree.gen_root_id()
 
1008
            self.root = RootEntry(file_id)
1322
1009
            self._byid = {self.root.file_id: self.root}
1323
 
            return self.root
 
1010
            return
1324
1011
        else:
 
1012
            if file_id is None:
 
1013
                file_id = bzrlib.workingtree.gen_file_id(parts[-1])
1325
1014
            parent_path = parts[:-1]
1326
1015
            parent_id = self.path2id(parent_path)
1327
 
            if parent_id is None:
1328
 
                raise errors.NotVersionedError(path=parent_path)
1329
 
        ie = make_entry(kind, parts[-1], parent_id, file_id)
 
1016
            if parent_id == None:
 
1017
                raise NotVersionedError(path=parent_path)
 
1018
        if kind == 'directory':
 
1019
            ie = InventoryDirectory(file_id, parts[-1], parent_id)
 
1020
        elif kind == 'file':
 
1021
            ie = InventoryFile(file_id, parts[-1], parent_id)
 
1022
        elif kind == 'symlink':
 
1023
            ie = InventoryLink(file_id, parts[-1], parent_id)
 
1024
        else:
 
1025
            raise BzrError("unknown kind %r" % kind)
1330
1026
        return self.add(ie)
1331
1027
 
 
1028
 
1332
1029
    def __delitem__(self, file_id):
1333
1030
        """Remove entry by id.
1334
1031
 
1335
1032
        >>> inv = Inventory()
1336
1033
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1337
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)
 
1034
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1338
1035
        >>> '123' in inv
1339
1036
        True
1340
1037
        >>> del inv['123']
1342
1039
        False
1343
1040
        """
1344
1041
        ie = self[file_id]
 
1042
 
 
1043
        assert ie.parent_id is None or \
 
1044
            self[ie.parent_id].children[ie.name] == ie
 
1045
        
1345
1046
        del self._byid[file_id]
1346
1047
        if ie.parent_id is not None:
1347
1048
            del self[ie.parent_id].children[ie.name]
1348
1049
 
 
1050
 
1349
1051
    def __eq__(self, other):
1350
1052
        """Compare two sets by comparing their contents.
1351
1053
 
1354
1056
        >>> i1 == i2
1355
1057
        True
1356
1058
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
1357
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)
 
1059
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1358
1060
        >>> i1 == i2
1359
1061
        False
1360
1062
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
1361
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None, revision=None)
 
1063
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1362
1064
        >>> i1 == i2
1363
1065
        True
1364
1066
        """
1365
1067
        if not isinstance(other, Inventory):
1366
1068
            return NotImplemented
1367
1069
 
 
1070
        if len(self._byid) != len(other._byid):
 
1071
            # shortcut: obviously not the same
 
1072
            return False
 
1073
 
1368
1074
        return self._byid == other._byid
1369
1075
 
 
1076
 
1370
1077
    def __ne__(self, other):
1371
1078
        return not self.__eq__(other)
1372
1079
 
 
1080
 
1373
1081
    def __hash__(self):
1374
1082
        raise ValueError('not hashable')
1375
1083
 
1376
1084
    def _iter_file_id_parents(self, file_id):
1377
1085
        """Yield the parents of file_id up to the root."""
1378
 
        while file_id is not None:
 
1086
        while file_id != None:
1379
1087
            try:
1380
1088
                ie = self._byid[file_id]
1381
1089
            except KeyError:
1382
 
                raise errors.NoSuchId(tree=None, file_id=file_id)
 
1090
                raise BzrError("file_id {%s} not found in inventory" % file_id)
1383
1091
            yield ie
1384
1092
            file_id = ie.parent_id
1385
1093
 
 
1094
    def get_idpath(self, file_id):
 
1095
        """Return a list of file_ids for the path to an entry.
 
1096
 
 
1097
        The list contains one element for each directory followed by
 
1098
        the id of the file itself.  So the length of the returned list
 
1099
        is equal to the depth of the file in the tree, counting the
 
1100
        root directory as depth 1.
 
1101
        """
 
1102
        p = []
 
1103
        for parent in self._iter_file_id_parents(file_id):
 
1104
            p.insert(0, parent.file_id)
 
1105
        return p
 
1106
 
 
1107
    def id2path(self, file_id):
 
1108
        """Return as a string the path to file_id.
 
1109
        
 
1110
        >>> i = Inventory()
 
1111
        >>> e = i.add(InventoryDirectory('src-id', 'src', ROOT_ID))
 
1112
        >>> e = i.add(InventoryFile('foo-id', 'foo.c', parent_id='src-id'))
 
1113
        >>> print i.id2path('foo-id')
 
1114
        src/foo.c
 
1115
        """
 
1116
        # get all names, skipping root
 
1117
        return '/'.join(reversed(
 
1118
            [parent.name for parent in 
 
1119
             self._iter_file_id_parents(file_id)][:-1]))
 
1120
            
 
1121
    def path2id(self, name):
 
1122
        """Walk down through directories to return entry of last component.
 
1123
 
 
1124
        names may be either a list of path components, or a single
 
1125
        string, in which case it is automatically split.
 
1126
 
 
1127
        This returns the entry of the last component in the path,
 
1128
        which may be either a file or a directory.
 
1129
 
 
1130
        Returns None iff the path is not found.
 
1131
        """
 
1132
        if isinstance(name, types.StringTypes):
 
1133
            name = splitpath(name)
 
1134
 
 
1135
        mutter("lookup path %r" % name)
 
1136
 
 
1137
        parent = self.root
 
1138
        for f in name:
 
1139
            try:
 
1140
                cie = parent.children[f]
 
1141
                assert cie.name == f
 
1142
                assert cie.parent_id == parent.file_id
 
1143
                parent = cie
 
1144
            except KeyError:
 
1145
                # or raise an error?
 
1146
                return None
 
1147
 
 
1148
        return parent.file_id
 
1149
 
 
1150
 
 
1151
    def has_filename(self, names):
 
1152
        return bool(self.path2id(names))
 
1153
 
 
1154
 
1386
1155
    def has_id(self, file_id):
1387
 
        return (file_id in self._byid)
1388
 
 
1389
 
    def _make_delta(self, old):
1390
 
        """Make an inventory delta from two inventories."""
1391
 
        old_getter = getattr(old, '_byid', old)
1392
 
        new_getter = self._byid
1393
 
        old_ids = set(old_getter)
1394
 
        new_ids = set(new_getter)
1395
 
        adds = new_ids - old_ids
1396
 
        deletes = old_ids - new_ids
1397
 
        if not adds and not deletes:
1398
 
            common = new_ids
1399
 
        else:
1400
 
            common = old_ids.intersection(new_ids)
1401
 
        delta = []
1402
 
        for file_id in deletes:
1403
 
            delta.append((old.id2path(file_id), None, file_id, None))
1404
 
        for file_id in adds:
1405
 
            delta.append((None, self.id2path(file_id), file_id, self[file_id]))
1406
 
        for file_id in common:
1407
 
            new_ie = new_getter[file_id]
1408
 
            old_ie = old_getter[file_id]
1409
 
            # If xml_serializer returns the cached InventoryEntries (rather
1410
 
            # than always doing .copy()), inlining the 'is' check saves 2.7M
1411
 
            # calls to __eq__.  Under lsprof this saves 20s => 6s.
1412
 
            # It is a minor improvement without lsprof.
1413
 
            if old_ie is new_ie or old_ie == new_ie:
1414
 
                continue
1415
 
            else:
1416
 
                delta.append((old.id2path(file_id), self.id2path(file_id),
1417
 
                              file_id, new_ie))
1418
 
        return delta
1419
 
 
1420
 
    def remove_recursive_id(self, file_id):
1421
 
        """Remove file_id, and children, from the inventory.
1422
 
 
1423
 
        :param file_id: A file_id to remove.
1424
 
        """
1425
 
        to_find_delete = [self._byid[file_id]]
1426
 
        to_delete = []
1427
 
        while to_find_delete:
1428
 
            ie = to_find_delete.pop()
1429
 
            to_delete.append(ie.file_id)
1430
 
            if ie.kind == 'directory':
1431
 
                to_find_delete.extend(ie.children.values())
1432
 
        for file_id in reversed(to_delete):
1433
 
            ie = self[file_id]
1434
 
            del self._byid[file_id]
1435
 
        if ie.parent_id is not None:
1436
 
            del self[ie.parent_id].children[ie.name]
1437
 
        else:
1438
 
            self.root = None
 
1156
        return self._byid.has_key(file_id)
 
1157
 
1439
1158
 
1440
1159
    def rename(self, file_id, new_parent_id, new_name):
1441
1160
        """Move a file within the inventory.
1442
1161
 
1443
1162
        This can change either the name, or the parent, or both.
1444
1163
 
1445
 
        This does not move the working file.
1446
 
        """
1447
 
        new_name = ensure_normalized_name(new_name)
 
1164
        This does not move the working file."""
1448
1165
        if not is_valid_name(new_name):
1449
1166
            raise BzrError("not an acceptable filename: %r" % new_name)
1450
1167
 
1464
1181
 
1465
1182
        del old_parent.children[file_ie.name]
1466
1183
        new_parent.children[new_name] = file_ie
1467
 
 
 
1184
        
1468
1185
        file_ie.name = new_name
1469
1186
        file_ie.parent_id = new_parent_id
1470
1187
 
1471
 
    def is_root(self, file_id):
1472
 
        return self.root is not None and file_id == self.root.file_id
1473
 
 
1474
 
 
1475
 
class CHKInventory(CommonInventory):
1476
 
    """An inventory persisted in a CHK store.
1477
 
 
1478
 
    By design, a CHKInventory is immutable so many of the methods
1479
 
    supported by Inventory - add, rename, apply_delta, etc - are *not*
1480
 
    supported. To create a new CHKInventory, use create_by_apply_delta()
1481
 
    or from_inventory(), say.
1482
 
 
1483
 
    Internally, a CHKInventory has one or two CHKMaps:
1484
 
 
1485
 
    * id_to_entry - a map from (file_id,) => InventoryEntry as bytes
1486
 
    * parent_id_basename_to_file_id - a map from (parent_id, basename_utf8)
1487
 
        => file_id as bytes
1488
 
 
1489
 
    The second map is optional and not present in early CHkRepository's.
1490
 
 
1491
 
    No caching is performed: every method call or item access will perform
1492
 
    requests to the storage layer. As such, keep references to objects you
1493
 
    want to reuse.
1494
 
    """
1495
 
 
1496
 
    def __init__(self, search_key_name):
1497
 
        CommonInventory.__init__(self)
1498
 
        self._fileid_to_entry_cache = {}
1499
 
        self._path_to_fileid_cache = {}
1500
 
        self._search_key_name = search_key_name
1501
 
        self.root_id = None
1502
 
 
1503
 
    def __eq__(self, other):
1504
 
        """Compare two sets by comparing their contents."""
1505
 
        if not isinstance(other, CHKInventory):
1506
 
            return NotImplemented
1507
 
 
1508
 
        this_key = self.id_to_entry.key()
1509
 
        other_key = other.id_to_entry.key()
1510
 
        this_pid_key = self.parent_id_basename_to_file_id.key()
1511
 
        other_pid_key = other.parent_id_basename_to_file_id.key()
1512
 
        if None in (this_key, this_pid_key, other_key, other_pid_key):
1513
 
            return False
1514
 
        return this_key == other_key and this_pid_key == other_pid_key
1515
 
 
1516
 
    def _entry_to_bytes(self, entry):
1517
 
        """Serialise entry as a single bytestring.
1518
 
 
1519
 
        :param Entry: An inventory entry.
1520
 
        :return: A bytestring for the entry.
1521
 
 
1522
 
        The BNF:
1523
 
        ENTRY ::= FILE | DIR | SYMLINK | TREE
1524
 
        FILE ::= "file: " COMMON SEP SHA SEP SIZE SEP EXECUTABLE
1525
 
        DIR ::= "dir: " COMMON
1526
 
        SYMLINK ::= "symlink: " COMMON SEP TARGET_UTF8
1527
 
        TREE ::= "tree: " COMMON REFERENCE_REVISION
1528
 
        COMMON ::= FILE_ID SEP PARENT_ID SEP NAME_UTF8 SEP REVISION
1529
 
        SEP ::= "\n"
1530
 
        """
1531
 
        if entry.parent_id is not None:
1532
 
            parent_str = entry.parent_id
1533
 
        else:
1534
 
            parent_str = ''
1535
 
        name_str = entry.name.encode("utf8")
1536
 
        if entry.kind == 'file':
1537
 
            if entry.executable:
1538
 
                exec_str = "Y"
1539
 
            else:
1540
 
                exec_str = "N"
1541
 
            return "file: %s\n%s\n%s\n%s\n%s\n%d\n%s" % (
1542
 
                entry.file_id, parent_str, name_str, entry.revision,
1543
 
                entry.text_sha1, entry.text_size, exec_str)
1544
 
        elif entry.kind == 'directory':
1545
 
            return "dir: %s\n%s\n%s\n%s" % (
1546
 
                entry.file_id, parent_str, name_str, entry.revision)
1547
 
        elif entry.kind == 'symlink':
1548
 
            return "symlink: %s\n%s\n%s\n%s\n%s" % (
1549
 
                entry.file_id, parent_str, name_str, entry.revision,
1550
 
                entry.symlink_target.encode("utf8"))
1551
 
        elif entry.kind == 'tree-reference':
1552
 
            return "tree: %s\n%s\n%s\n%s\n%s" % (
1553
 
                entry.file_id, parent_str, name_str, entry.revision,
1554
 
                entry.reference_revision)
1555
 
        else:
1556
 
            raise ValueError("unknown kind %r" % entry.kind)
1557
 
 
1558
 
    def _expand_fileids_to_parents_and_children(self, file_ids):
1559
 
        """Give a more wholistic view starting with the given file_ids.
1560
 
 
1561
 
        For any file_id which maps to a directory, we will include all children
1562
 
        of that directory. We will also include all directories which are
1563
 
        parents of the given file_ids, but we will not include their children.
1564
 
 
1565
 
        eg:
1566
 
          /     # TREE_ROOT
1567
 
          foo/  # foo-id
1568
 
            baz # baz-id
1569
 
            frob/ # frob-id
1570
 
              fringle # fringle-id
1571
 
          bar/  # bar-id
1572
 
            bing # bing-id
1573
 
 
1574
 
        if given [foo-id] we will include
1575
 
            TREE_ROOT as interesting parents
1576
 
        and 
1577
 
            foo-id, baz-id, frob-id, fringle-id
1578
 
        As interesting ids.
1579
 
        """
1580
 
        interesting = set()
1581
 
        # TODO: Pre-pass over the list of fileids to see if anything is already
1582
 
        #       deserialized in self._fileid_to_entry_cache
1583
 
 
1584
 
        directories_to_expand = set()
1585
 
        children_of_parent_id = {}
1586
 
        # It is okay if some of the fileids are missing
1587
 
        for entry in self._getitems(file_ids):
1588
 
            if entry.kind == 'directory':
1589
 
                directories_to_expand.add(entry.file_id)
1590
 
            interesting.add(entry.parent_id)
1591
 
            children_of_parent_id.setdefault(entry.parent_id, []
1592
 
                                             ).append(entry.file_id)
1593
 
 
1594
 
        # Now, interesting has all of the direct parents, but not the
1595
 
        # parents of those parents. It also may have some duplicates with
1596
 
        # specific_fileids
1597
 
        remaining_parents = interesting.difference(file_ids)
1598
 
        # When we hit the TREE_ROOT, we'll get an interesting parent of None,
1599
 
        # but we don't actually want to recurse into that
1600
 
        interesting.add(None) # this will auto-filter it in the loop
1601
 
        remaining_parents.discard(None) 
1602
 
        while remaining_parents:
1603
 
            next_parents = set()
1604
 
            for entry in self._getitems(remaining_parents):
1605
 
                next_parents.add(entry.parent_id)
1606
 
                children_of_parent_id.setdefault(entry.parent_id, []
1607
 
                                                 ).append(entry.file_id)
1608
 
            # Remove any search tips we've already processed
1609
 
            remaining_parents = next_parents.difference(interesting)
1610
 
            interesting.update(remaining_parents)
1611
 
            # We should probably also .difference(directories_to_expand)
1612
 
        interesting.update(file_ids)
1613
 
        interesting.discard(None)
1614
 
        while directories_to_expand:
1615
 
            # Expand directories by looking in the
1616
 
            # parent_id_basename_to_file_id map
1617
 
            keys = [StaticTuple(f,).intern() for f in directories_to_expand]
1618
 
            directories_to_expand = set()
1619
 
            items = self.parent_id_basename_to_file_id.iteritems(keys)
1620
 
            next_file_ids = set([item[1] for item in items])
1621
 
            next_file_ids = next_file_ids.difference(interesting)
1622
 
            interesting.update(next_file_ids)
1623
 
            for entry in self._getitems(next_file_ids):
1624
 
                if entry.kind == 'directory':
1625
 
                    directories_to_expand.add(entry.file_id)
1626
 
                children_of_parent_id.setdefault(entry.parent_id, []
1627
 
                                                 ).append(entry.file_id)
1628
 
        return interesting, children_of_parent_id
1629
 
 
1630
 
    def filter(self, specific_fileids):
1631
 
        """Get an inventory view filtered against a set of file-ids.
1632
 
 
1633
 
        Children of directories and parents are included.
1634
 
 
1635
 
        The result may or may not reference the underlying inventory
1636
 
        so it should be treated as immutable.
1637
 
        """
1638
 
        (interesting,
1639
 
         parent_to_children) = self._expand_fileids_to_parents_and_children(
1640
 
                                specific_fileids)
1641
 
        # There is some overlap here, but we assume that all interesting items
1642
 
        # are in the _fileid_to_entry_cache because we had to read them to
1643
 
        # determine if they were a dir we wanted to recurse, or just a file
1644
 
        # This should give us all the entries we'll want to add, so start
1645
 
        # adding
1646
 
        other = Inventory(self.root_id)
1647
 
        other.root.revision = self.root.revision
1648
 
        other.revision_id = self.revision_id
1649
 
        if not interesting or not parent_to_children:
1650
 
            # empty filter, or filtering entrys that don't exist
1651
 
            # (if even 1 existed, then we would have populated
1652
 
            # parent_to_children with at least the tree root.)
1653
 
            return other
1654
 
        cache = self._fileid_to_entry_cache
1655
 
        try:
1656
 
            remaining_children = collections.deque(parent_to_children[self.root_id])
1657
 
        except:
1658
 
            import pdb; pdb.set_trace()
1659
 
            raise
1660
 
        while remaining_children:
1661
 
            file_id = remaining_children.popleft()
1662
 
            ie = cache[file_id]
1663
 
            if ie.kind == 'directory':
1664
 
                ie = ie.copy() # We create a copy to depopulate the .children attribute
1665
 
            # TODO: depending on the uses of 'other' we should probably alwyas
1666
 
            #       '.copy()' to prevent someone from mutating other and
1667
 
            #       invaliding our internal cache
1668
 
            other.add(ie)
1669
 
            if file_id in parent_to_children:
1670
 
                remaining_children.extend(parent_to_children[file_id])
1671
 
        return other
1672
 
 
1673
 
    @staticmethod
1674
 
    def _bytes_to_utf8name_key(bytes):
1675
 
        """Get the file_id, revision_id key out of bytes."""
1676
 
        # We don't normally care about name, except for times when we want
1677
 
        # to filter out empty names because of non rich-root...
1678
 
        sections = bytes.split('\n')
1679
 
        kind, file_id = sections[0].split(': ')
1680
 
        return (sections[2], intern(file_id), intern(sections[3]))
1681
 
 
1682
 
    def _bytes_to_entry(self, bytes):
1683
 
        """Deserialise a serialised entry."""
1684
 
        sections = bytes.split('\n')
1685
 
        if sections[0].startswith("file: "):
1686
 
            result = InventoryFile(sections[0][6:],
1687
 
                sections[2].decode('utf8'),
1688
 
                sections[1])
1689
 
            result.text_sha1 = sections[4]
1690
 
            result.text_size = int(sections[5])
1691
 
            result.executable = sections[6] == "Y"
1692
 
        elif sections[0].startswith("dir: "):
1693
 
            result = CHKInventoryDirectory(sections[0][5:],
1694
 
                sections[2].decode('utf8'),
1695
 
                sections[1], self)
1696
 
        elif sections[0].startswith("symlink: "):
1697
 
            result = InventoryLink(sections[0][9:],
1698
 
                sections[2].decode('utf8'),
1699
 
                sections[1])
1700
 
            result.symlink_target = sections[4].decode('utf8')
1701
 
        elif sections[0].startswith("tree: "):
1702
 
            result = TreeReference(sections[0][6:],
1703
 
                sections[2].decode('utf8'),
1704
 
                sections[1])
1705
 
            result.reference_revision = sections[4]
1706
 
        else:
1707
 
            raise ValueError("Not a serialised entry %r" % bytes)
1708
 
        result.file_id = intern(result.file_id)
1709
 
        result.revision = intern(sections[3])
1710
 
        if result.parent_id == '':
1711
 
            result.parent_id = None
1712
 
        self._fileid_to_entry_cache[result.file_id] = result
1713
 
        return result
1714
 
 
1715
 
    def _get_mutable_inventory(self):
1716
 
        """See CommonInventory._get_mutable_inventory."""
1717
 
        entries = self.iter_entries()
1718
 
        inv = Inventory(None, self.revision_id)
1719
 
        for path, inv_entry in entries:
1720
 
            inv.add(inv_entry.copy())
1721
 
        return inv
1722
 
 
1723
 
    def create_by_apply_delta(self, inventory_delta, new_revision_id,
1724
 
        propagate_caches=False):
1725
 
        """Create a new CHKInventory by applying inventory_delta to this one.
1726
 
 
1727
 
        See the inventory developers documentation for the theory behind
1728
 
        inventory deltas.
1729
 
 
1730
 
        :param inventory_delta: The inventory delta to apply. See
1731
 
            Inventory.apply_delta for details.
1732
 
        :param new_revision_id: The revision id of the resulting CHKInventory.
1733
 
        :param propagate_caches: If True, the caches for this inventory are
1734
 
          copied to and updated for the result.
1735
 
        :return: The new CHKInventory.
1736
 
        """
1737
 
        split = osutils.split
1738
 
        result = CHKInventory(self._search_key_name)
1739
 
        if propagate_caches:
1740
 
            # Just propagate the path-to-fileid cache for now
1741
 
            result._path_to_fileid_cache = dict(self._path_to_fileid_cache.iteritems())
1742
 
        search_key_func = chk_map.search_key_registry.get(self._search_key_name)
1743
 
        self.id_to_entry._ensure_root()
1744
 
        maximum_size = self.id_to_entry._root_node.maximum_size
1745
 
        result.revision_id = new_revision_id
1746
 
        result.id_to_entry = chk_map.CHKMap(
1747
 
            self.id_to_entry._store,
1748
 
            self.id_to_entry.key(),
1749
 
            search_key_func=search_key_func)
1750
 
        result.id_to_entry._ensure_root()
1751
 
        result.id_to_entry._root_node.set_maximum_size(maximum_size)
1752
 
        # Change to apply to the parent_id_basename delta. The dict maps
1753
 
        # (parent_id, basename) -> (old_key, new_value). We use a dict because
1754
 
        # when a path has its id replaced (e.g. the root is changed, or someone
1755
 
        # does bzr mv a b, bzr mv c a, we should output a single change to this
1756
 
        # map rather than two.
1757
 
        parent_id_basename_delta = {}
1758
 
        if self.parent_id_basename_to_file_id is not None:
1759
 
            result.parent_id_basename_to_file_id = chk_map.CHKMap(
1760
 
                self.parent_id_basename_to_file_id._store,
1761
 
                self.parent_id_basename_to_file_id.key(),
1762
 
                search_key_func=search_key_func)
1763
 
            result.parent_id_basename_to_file_id._ensure_root()
1764
 
            self.parent_id_basename_to_file_id._ensure_root()
1765
 
            result_p_id_root = result.parent_id_basename_to_file_id._root_node
1766
 
            p_id_root = self.parent_id_basename_to_file_id._root_node
1767
 
            result_p_id_root.set_maximum_size(p_id_root.maximum_size)
1768
 
            result_p_id_root._key_width = p_id_root._key_width
1769
 
        else:
1770
 
            result.parent_id_basename_to_file_id = None
1771
 
        result.root_id = self.root_id
1772
 
        id_to_entry_delta = []
1773
 
        # inventory_delta is only traversed once, so we just update the
1774
 
        # variable.
1775
 
        # Check for repeated file ids
1776
 
        inventory_delta = _check_delta_unique_ids(inventory_delta)
1777
 
        # Repeated old paths
1778
 
        inventory_delta = _check_delta_unique_old_paths(inventory_delta)
1779
 
        # Check for repeated new paths
1780
 
        inventory_delta = _check_delta_unique_new_paths(inventory_delta)
1781
 
        # Check for entries that don't match the fileid
1782
 
        inventory_delta = _check_delta_ids_match_entry(inventory_delta)
1783
 
        # Check for nonsense fileids
1784
 
        inventory_delta = _check_delta_ids_are_valid(inventory_delta)
1785
 
        # Check for new_path <-> entry consistency
1786
 
        inventory_delta = _check_delta_new_path_entry_both_or_None(
1787
 
            inventory_delta)
1788
 
        # All changed entries need to have their parents be directories and be
1789
 
        # at the right path. This set contains (path, id) tuples.
1790
 
        parents = set()
1791
 
        # When we delete an item, all the children of it must be either deleted
1792
 
        # or altered in their own right. As we batch process the change via
1793
 
        # CHKMap.apply_delta, we build a set of things to use to validate the
1794
 
        # delta.
1795
 
        deletes = set()
1796
 
        altered = set()
1797
 
        for old_path, new_path, file_id, entry in inventory_delta:
1798
 
            # file id changes
1799
 
            if new_path == '':
1800
 
                result.root_id = file_id
1801
 
            if new_path is None:
1802
 
                # Make a delete:
1803
 
                new_key = None
1804
 
                new_value = None
1805
 
                # Update caches
1806
 
                if propagate_caches:
1807
 
                    try:
1808
 
                        del result._path_to_fileid_cache[old_path]
1809
 
                    except KeyError:
1810
 
                        pass
1811
 
                deletes.add(file_id)
1812
 
            else:
1813
 
                new_key = StaticTuple(file_id,)
1814
 
                new_value = result._entry_to_bytes(entry)
1815
 
                # Update caches. It's worth doing this whether
1816
 
                # we're propagating the old caches or not.
1817
 
                result._path_to_fileid_cache[new_path] = file_id
1818
 
                parents.add((split(new_path)[0], entry.parent_id))
1819
 
            if old_path is None:
1820
 
                old_key = None
1821
 
            else:
1822
 
                old_key = StaticTuple(file_id,)
1823
 
                if self.id2path(file_id) != old_path:
1824
 
                    raise errors.InconsistentDelta(old_path, file_id,
1825
 
                        "Entry was at wrong other path %r." %
1826
 
                        self.id2path(file_id))
1827
 
                altered.add(file_id)
1828
 
            id_to_entry_delta.append(StaticTuple(old_key, new_key, new_value))
1829
 
            if result.parent_id_basename_to_file_id is not None:
1830
 
                # parent_id, basename changes
1831
 
                if old_path is None:
1832
 
                    old_key = None
1833
 
                else:
1834
 
                    old_entry = self[file_id]
1835
 
                    old_key = self._parent_id_basename_key(old_entry)
1836
 
                if new_path is None:
1837
 
                    new_key = None
1838
 
                    new_value = None
1839
 
                else:
1840
 
                    new_key = self._parent_id_basename_key(entry)
1841
 
                    new_value = file_id
1842
 
                # If the two keys are the same, the value will be unchanged
1843
 
                # as its always the file id for this entry.
1844
 
                if old_key != new_key:
1845
 
                    # Transform a change into explicit delete/add preserving
1846
 
                    # a possible match on the key from a different file id.
1847
 
                    if old_key is not None:
1848
 
                        parent_id_basename_delta.setdefault(
1849
 
                            old_key, [None, None])[0] = old_key
1850
 
                    if new_key is not None:
1851
 
                        parent_id_basename_delta.setdefault(
1852
 
                            new_key, [None, None])[1] = new_value
1853
 
        # validate that deletes are complete.
1854
 
        for file_id in deletes:
1855
 
            entry = self[file_id]
1856
 
            if entry.kind != 'directory':
1857
 
                continue
1858
 
            # This loop could potentially be better by using the id_basename
1859
 
            # map to just get the child file ids.
1860
 
            for child in entry.children.values():
1861
 
                if child.file_id not in altered:
1862
 
                    raise errors.InconsistentDelta(self.id2path(child.file_id),
1863
 
                        child.file_id, "Child not deleted or reparented when "
1864
 
                        "parent deleted.")
1865
 
        result.id_to_entry.apply_delta(id_to_entry_delta)
1866
 
        if parent_id_basename_delta:
1867
 
            # Transform the parent_id_basename delta data into a linear delta
1868
 
            # with only one record for a given key. Optimally this would allow
1869
 
            # re-keying, but its simpler to just output that as a delete+add
1870
 
            # to spend less time calculating the delta.
1871
 
            delta_list = []
1872
 
            for key, (old_key, value) in parent_id_basename_delta.iteritems():
1873
 
                if value is not None:
1874
 
                    delta_list.append((old_key, key, value))
1875
 
                else:
1876
 
                    delta_list.append((old_key, None, None))
1877
 
            result.parent_id_basename_to_file_id.apply_delta(delta_list)
1878
 
        parents.discard(('', None))
1879
 
        for parent_path, parent in parents:
1880
 
            try:
1881
 
                if result[parent].kind != 'directory':
1882
 
                    raise errors.InconsistentDelta(result.id2path(parent), parent,
1883
 
                        'Not a directory, but given children')
1884
 
            except errors.NoSuchId:
1885
 
                raise errors.InconsistentDelta("<unknown>", parent,
1886
 
                    "Parent is not present in resulting inventory.")
1887
 
            if result.path2id(parent_path) != parent:
1888
 
                raise errors.InconsistentDelta(parent_path, parent,
1889
 
                    "Parent has wrong path %r." % result.path2id(parent_path))
1890
 
        return result
1891
 
 
1892
 
    @classmethod
1893
 
    def deserialise(klass, chk_store, bytes, expected_revision_id):
1894
 
        """Deserialise a CHKInventory.
1895
 
 
1896
 
        :param chk_store: A CHK capable VersionedFiles instance.
1897
 
        :param bytes: The serialised bytes.
1898
 
        :param expected_revision_id: The revision ID we think this inventory is
1899
 
            for.
1900
 
        :return: A CHKInventory
1901
 
        """
1902
 
        lines = bytes.split('\n')
1903
 
        if lines[-1] != '':
1904
 
            raise AssertionError('bytes to deserialize must end with an eol')
1905
 
        lines.pop()
1906
 
        if lines[0] != 'chkinventory:':
1907
 
            raise ValueError("not a serialised CHKInventory: %r" % bytes)
1908
 
        info = {}
1909
 
        allowed_keys = frozenset(['root_id', 'revision_id', 'search_key_name',
1910
 
                                  'parent_id_basename_to_file_id',
1911
 
                                  'id_to_entry'])
1912
 
        for line in lines[1:]:
1913
 
            key, value = line.split(': ', 1)
1914
 
            if key not in allowed_keys:
1915
 
                raise errors.BzrError('Unknown key in inventory: %r\n%r'
1916
 
                                      % (key, bytes))
1917
 
            if key in info:
1918
 
                raise errors.BzrError('Duplicate key in inventory: %r\n%r'
1919
 
                                      % (key, bytes))
1920
 
            info[key] = value
1921
 
        revision_id = intern(info['revision_id'])
1922
 
        root_id = intern(info['root_id'])
1923
 
        search_key_name = intern(info.get('search_key_name', 'plain'))
1924
 
        parent_id_basename_to_file_id = intern(info.get(
1925
 
            'parent_id_basename_to_file_id', None))
1926
 
        if not parent_id_basename_to_file_id.startswith('sha1:'):
1927
 
            raise ValueError('parent_id_basename_to_file_id should be a sha1'
1928
 
                             ' key not %r' % (parent_id_basename_to_file_id,))
1929
 
        id_to_entry = info['id_to_entry']
1930
 
        if not id_to_entry.startswith('sha1:'):
1931
 
            raise ValueError('id_to_entry should be a sha1'
1932
 
                             ' key not %r' % (id_to_entry,))
1933
 
 
1934
 
        result = CHKInventory(search_key_name)
1935
 
        result.revision_id = revision_id
1936
 
        result.root_id = root_id
1937
 
        search_key_func = chk_map.search_key_registry.get(
1938
 
                            result._search_key_name)
1939
 
        if parent_id_basename_to_file_id is not None:
1940
 
            result.parent_id_basename_to_file_id = chk_map.CHKMap(
1941
 
                chk_store, StaticTuple(parent_id_basename_to_file_id,),
1942
 
                search_key_func=search_key_func)
1943
 
        else:
1944
 
            result.parent_id_basename_to_file_id = None
1945
 
 
1946
 
        result.id_to_entry = chk_map.CHKMap(chk_store,
1947
 
                                            StaticTuple(id_to_entry,),
1948
 
                                            search_key_func=search_key_func)
1949
 
        if (result.revision_id,) != expected_revision_id:
1950
 
            raise ValueError("Mismatched revision id and expected: %r, %r" %
1951
 
                (result.revision_id, expected_revision_id))
1952
 
        return result
1953
 
 
1954
 
    @classmethod
1955
 
    def from_inventory(klass, chk_store, inventory, maximum_size=0, search_key_name='plain'):
1956
 
        """Create a CHKInventory from an existing inventory.
1957
 
 
1958
 
        The content of inventory is copied into the chk_store, and a
1959
 
        CHKInventory referencing that is returned.
1960
 
 
1961
 
        :param chk_store: A CHK capable VersionedFiles instance.
1962
 
        :param inventory: The inventory to copy.
1963
 
        :param maximum_size: The CHKMap node size limit.
1964
 
        :param search_key_name: The identifier for the search key function
1965
 
        """
1966
 
        result = klass(search_key_name)
1967
 
        result.revision_id = inventory.revision_id
1968
 
        result.root_id = inventory.root.file_id
1969
 
 
1970
 
        entry_to_bytes = result._entry_to_bytes
1971
 
        parent_id_basename_key = result._parent_id_basename_key
1972
 
        id_to_entry_dict = {}
1973
 
        parent_id_basename_dict = {}
1974
 
        for path, entry in inventory.iter_entries():
1975
 
            key = StaticTuple(entry.file_id,).intern()
1976
 
            id_to_entry_dict[key] = entry_to_bytes(entry)
1977
 
            p_id_key = parent_id_basename_key(entry)
1978
 
            parent_id_basename_dict[p_id_key] = entry.file_id
1979
 
 
1980
 
        result._populate_from_dicts(chk_store, id_to_entry_dict,
1981
 
            parent_id_basename_dict, maximum_size=maximum_size)
1982
 
        return result
1983
 
 
1984
 
    def _populate_from_dicts(self, chk_store, id_to_entry_dict,
1985
 
                             parent_id_basename_dict, maximum_size):
1986
 
        search_key_func = chk_map.search_key_registry.get(self._search_key_name)
1987
 
        root_key = chk_map.CHKMap.from_dict(chk_store, id_to_entry_dict,
1988
 
                   maximum_size=maximum_size, key_width=1,
1989
 
                   search_key_func=search_key_func)
1990
 
        self.id_to_entry = chk_map.CHKMap(chk_store, root_key,
1991
 
                                          search_key_func)
1992
 
        root_key = chk_map.CHKMap.from_dict(chk_store,
1993
 
                   parent_id_basename_dict,
1994
 
                   maximum_size=maximum_size, key_width=2,
1995
 
                   search_key_func=search_key_func)
1996
 
        self.parent_id_basename_to_file_id = chk_map.CHKMap(chk_store,
1997
 
                                                    root_key, search_key_func)
1998
 
 
1999
 
    def _parent_id_basename_key(self, entry):
2000
 
        """Create a key for a entry in a parent_id_basename_to_file_id index."""
2001
 
        if entry.parent_id is not None:
2002
 
            parent_id = entry.parent_id
2003
 
        else:
2004
 
            parent_id = ''
2005
 
        return StaticTuple(parent_id, entry.name.encode('utf8')).intern()
2006
 
 
2007
 
    def __getitem__(self, file_id):
2008
 
        """map a single file_id -> InventoryEntry."""
2009
 
        if file_id is None:
2010
 
            raise errors.NoSuchId(self, file_id)
2011
 
        result = self._fileid_to_entry_cache.get(file_id, None)
2012
 
        if result is not None:
2013
 
            return result
2014
 
        try:
2015
 
            return self._bytes_to_entry(
2016
 
                self.id_to_entry.iteritems([StaticTuple(file_id,)]).next()[1])
2017
 
        except StopIteration:
2018
 
            # really we're passing an inventory, not a tree...
2019
 
            raise errors.NoSuchId(self, file_id)
2020
 
 
2021
 
    def _getitems(self, file_ids):
2022
 
        """Similar to __getitem__, but lets you query for multiple.
2023
 
        
2024
 
        The returned order is undefined. And currently if an item doesn't
2025
 
        exist, it isn't included in the output.
2026
 
        """
2027
 
        result = []
2028
 
        remaining = []
2029
 
        for file_id in file_ids:
2030
 
            entry = self._fileid_to_entry_cache.get(file_id, None)
2031
 
            if entry is None:
2032
 
                remaining.append(file_id)
2033
 
            else:
2034
 
                result.append(entry)
2035
 
        file_keys = [StaticTuple(f,).intern() for f in remaining]
2036
 
        for file_key, value in self.id_to_entry.iteritems(file_keys):
2037
 
            entry = self._bytes_to_entry(value)
2038
 
            result.append(entry)
2039
 
            self._fileid_to_entry_cache[entry.file_id] = entry
2040
 
        return result
2041
 
 
2042
 
    def has_id(self, file_id):
2043
 
        # Perhaps have an explicit 'contains' method on CHKMap ?
2044
 
        if self._fileid_to_entry_cache.get(file_id, None) is not None:
2045
 
            return True
2046
 
        return len(list(
2047
 
            self.id_to_entry.iteritems([StaticTuple(file_id,)]))) == 1
2048
 
 
2049
 
    def is_root(self, file_id):
2050
 
        return file_id == self.root_id
2051
 
 
2052
 
    def _iter_file_id_parents(self, file_id):
2053
 
        """Yield the parents of file_id up to the root."""
2054
 
        while file_id is not None:
2055
 
            try:
2056
 
                ie = self[file_id]
2057
 
            except KeyError:
2058
 
                raise errors.NoSuchId(tree=self, file_id=file_id)
2059
 
            yield ie
2060
 
            file_id = ie.parent_id
2061
 
 
2062
 
    def __iter__(self):
2063
 
        """Iterate over all file-ids."""
2064
 
        for key, _ in self.id_to_entry.iteritems():
2065
 
            yield key[-1]
2066
 
 
2067
 
    def iter_just_entries(self):
2068
 
        """Iterate over all entries.
2069
 
        
2070
 
        Unlike iter_entries(), just the entries are returned (not (path, ie))
2071
 
        and the order of entries is undefined.
2072
 
 
2073
 
        XXX: We may not want to merge this into bzr.dev.
2074
 
        """
2075
 
        for key, entry in self.id_to_entry.iteritems():
2076
 
            file_id = key[0]
2077
 
            ie = self._fileid_to_entry_cache.get(file_id, None)
2078
 
            if ie is None:
2079
 
                ie = self._bytes_to_entry(entry)
2080
 
                self._fileid_to_entry_cache[file_id] = ie
2081
 
            yield ie
2082
 
 
2083
 
    def iter_changes(self, basis):
2084
 
        """Generate a Tree.iter_changes change list between this and basis.
2085
 
 
2086
 
        :param basis: Another CHKInventory.
2087
 
        :return: An iterator over the changes between self and basis, as per
2088
 
            tree.iter_changes().
2089
 
        """
2090
 
        # We want: (file_id, (path_in_source, path_in_target),
2091
 
        # changed_content, versioned, parent, name, kind,
2092
 
        # executable)
2093
 
        for key, basis_value, self_value in \
2094
 
            self.id_to_entry.iter_changes(basis.id_to_entry):
2095
 
            file_id = key[0]
2096
 
            if basis_value is not None:
2097
 
                basis_entry = basis._bytes_to_entry(basis_value)
2098
 
                path_in_source = basis.id2path(file_id)
2099
 
                basis_parent = basis_entry.parent_id
2100
 
                basis_name = basis_entry.name
2101
 
                basis_executable = basis_entry.executable
2102
 
            else:
2103
 
                path_in_source = None
2104
 
                basis_parent = None
2105
 
                basis_name = None
2106
 
                basis_executable = None
2107
 
            if self_value is not None:
2108
 
                self_entry = self._bytes_to_entry(self_value)
2109
 
                path_in_target = self.id2path(file_id)
2110
 
                self_parent = self_entry.parent_id
2111
 
                self_name = self_entry.name
2112
 
                self_executable = self_entry.executable
2113
 
            else:
2114
 
                path_in_target = None
2115
 
                self_parent = None
2116
 
                self_name = None
2117
 
                self_executable = None
2118
 
            if basis_value is None:
2119
 
                # add
2120
 
                kind = (None, self_entry.kind)
2121
 
                versioned = (False, True)
2122
 
            elif self_value is None:
2123
 
                # delete
2124
 
                kind = (basis_entry.kind, None)
2125
 
                versioned = (True, False)
2126
 
            else:
2127
 
                kind = (basis_entry.kind, self_entry.kind)
2128
 
                versioned = (True, True)
2129
 
            changed_content = False
2130
 
            if kind[0] != kind[1]:
2131
 
                changed_content = True
2132
 
            elif kind[0] == 'file':
2133
 
                if (self_entry.text_size != basis_entry.text_size or
2134
 
                    self_entry.text_sha1 != basis_entry.text_sha1):
2135
 
                    changed_content = True
2136
 
            elif kind[0] == 'symlink':
2137
 
                if self_entry.symlink_target != basis_entry.symlink_target:
2138
 
                    changed_content = True
2139
 
            elif kind[0] == 'tree-reference':
2140
 
                if (self_entry.reference_revision !=
2141
 
                    basis_entry.reference_revision):
2142
 
                    changed_content = True
2143
 
            parent = (basis_parent, self_parent)
2144
 
            name = (basis_name, self_name)
2145
 
            executable = (basis_executable, self_executable)
2146
 
            if (not changed_content
2147
 
                and parent[0] == parent[1]
2148
 
                and name[0] == name[1]
2149
 
                and executable[0] == executable[1]):
2150
 
                # Could happen when only the revision changed for a directory
2151
 
                # for instance.
2152
 
                continue
2153
 
            yield (file_id, (path_in_source, path_in_target), changed_content,
2154
 
                versioned, parent, name, kind, executable)
2155
 
 
2156
 
    def __len__(self):
2157
 
        """Return the number of entries in the inventory."""
2158
 
        return len(self.id_to_entry)
2159
 
 
2160
 
    def _make_delta(self, old):
2161
 
        """Make an inventory delta from two inventories."""
2162
 
        if type(old) != CHKInventory:
2163
 
            return CommonInventory._make_delta(self, old)
2164
 
        delta = []
2165
 
        for key, old_value, self_value in \
2166
 
            self.id_to_entry.iter_changes(old.id_to_entry):
2167
 
            file_id = key[0]
2168
 
            if old_value is not None:
2169
 
                old_path = old.id2path(file_id)
2170
 
            else:
2171
 
                old_path = None
2172
 
            if self_value is not None:
2173
 
                entry = self._bytes_to_entry(self_value)
2174
 
                self._fileid_to_entry_cache[file_id] = entry
2175
 
                new_path = self.id2path(file_id)
2176
 
            else:
2177
 
                entry = None
2178
 
                new_path = None
2179
 
            delta.append((old_path, new_path, file_id, entry))
2180
 
        return delta
2181
 
 
2182
 
    def path2id(self, relpath):
2183
 
        """See CommonInventory.path2id()."""
2184
 
        # TODO: perhaps support negative hits?
2185
 
        result = self._path_to_fileid_cache.get(relpath, None)
2186
 
        if result is not None:
2187
 
            return result
2188
 
        if isinstance(relpath, basestring):
2189
 
            names = osutils.splitpath(relpath)
2190
 
        else:
2191
 
            names = relpath
2192
 
        current_id = self.root_id
2193
 
        if current_id is None:
2194
 
            return None
2195
 
        parent_id_index = self.parent_id_basename_to_file_id
2196
 
        cur_path = None
2197
 
        for basename in names:
2198
 
            if cur_path is None:
2199
 
                cur_path = basename
2200
 
            else:
2201
 
                cur_path = cur_path + '/' + basename
2202
 
            basename_utf8 = basename.encode('utf8')
2203
 
            file_id = self._path_to_fileid_cache.get(cur_path, None)
2204
 
            if file_id is None:
2205
 
                key_filter = [StaticTuple(current_id, basename_utf8)]
2206
 
                items = parent_id_index.iteritems(key_filter)
2207
 
                for (parent_id, name_utf8), file_id in items:
2208
 
                    if parent_id != current_id or name_utf8 != basename_utf8:
2209
 
                        raise errors.BzrError("corrupt inventory lookup! "
2210
 
                            "%r %r %r %r" % (parent_id, current_id, name_utf8,
2211
 
                            basename_utf8))
2212
 
                if file_id is None:
2213
 
                    return None
2214
 
                else:
2215
 
                    self._path_to_fileid_cache[cur_path] = file_id
2216
 
            current_id = file_id
2217
 
        return current_id
2218
 
 
2219
 
    def to_lines(self):
2220
 
        """Serialise the inventory to lines."""
2221
 
        lines = ["chkinventory:\n"]
2222
 
        if self._search_key_name != 'plain':
2223
 
            # custom ordering grouping things that don't change together
2224
 
            lines.append('search_key_name: %s\n' % (self._search_key_name,))
2225
 
            lines.append("root_id: %s\n" % self.root_id)
2226
 
            lines.append('parent_id_basename_to_file_id: %s\n' %
2227
 
                (self.parent_id_basename_to_file_id.key()[0],))
2228
 
            lines.append("revision_id: %s\n" % self.revision_id)
2229
 
            lines.append("id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
2230
 
        else:
2231
 
            lines.append("revision_id: %s\n" % self.revision_id)
2232
 
            lines.append("root_id: %s\n" % self.root_id)
2233
 
            if self.parent_id_basename_to_file_id is not None:
2234
 
                lines.append('parent_id_basename_to_file_id: %s\n' %
2235
 
                    (self.parent_id_basename_to_file_id.key()[0],))
2236
 
            lines.append("id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
2237
 
        return lines
2238
 
 
2239
 
    @property
2240
 
    def root(self):
2241
 
        """Get the root entry."""
2242
 
        return self[self.root_id]
2243
 
 
2244
 
 
2245
 
class CHKInventoryDirectory(InventoryDirectory):
2246
 
    """A directory in an inventory."""
2247
 
 
2248
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
2249
 
                 'text_id', 'parent_id', '_children', 'executable',
2250
 
                 'revision', 'symlink_target', 'reference_revision',
2251
 
                 '_chk_inventory']
2252
 
 
2253
 
    def __init__(self, file_id, name, parent_id, chk_inventory):
2254
 
        # Don't call InventoryDirectory.__init__ - it isn't right for this
2255
 
        # class.
2256
 
        InventoryEntry.__init__(self, file_id, name, parent_id)
2257
 
        self._children = None
2258
 
        self.kind = 'directory'
2259
 
        self._chk_inventory = chk_inventory
2260
 
 
2261
 
    @property
2262
 
    def children(self):
2263
 
        """Access the list of children of this directory.
2264
 
 
2265
 
        With a parent_id_basename_to_file_id index, loads all the children,
2266
 
        without loads the entire index. Without is bad. A more sophisticated
2267
 
        proxy object might be nice, to allow partial loading of children as
2268
 
        well when specific names are accessed. (So path traversal can be
2269
 
        written in the obvious way but not examine siblings.).
2270
 
        """
2271
 
        if self._children is not None:
2272
 
            return self._children
2273
 
        # No longer supported
2274
 
        if self._chk_inventory.parent_id_basename_to_file_id is None:
2275
 
            raise AssertionError("Inventories without"
2276
 
                " parent_id_basename_to_file_id are no longer supported")
2277
 
        result = {}
2278
 
        # XXX: Todo - use proxy objects for the children rather than loading
2279
 
        # all when the attribute is referenced.
2280
 
        parent_id_index = self._chk_inventory.parent_id_basename_to_file_id
2281
 
        child_keys = set()
2282
 
        for (parent_id, name_utf8), file_id in parent_id_index.iteritems(
2283
 
            key_filter=[StaticTuple(self.file_id,)]):
2284
 
            child_keys.add(StaticTuple(file_id,))
2285
 
        cached = set()
2286
 
        for file_id_key in child_keys:
2287
 
            entry = self._chk_inventory._fileid_to_entry_cache.get(
2288
 
                file_id_key[0], None)
2289
 
            if entry is not None:
2290
 
                result[entry.name] = entry
2291
 
                cached.add(file_id_key)
2292
 
        child_keys.difference_update(cached)
2293
 
        # populate; todo: do by name
2294
 
        id_to_entry = self._chk_inventory.id_to_entry
2295
 
        for file_id_key, bytes in id_to_entry.iteritems(child_keys):
2296
 
            entry = self._chk_inventory._bytes_to_entry(bytes)
2297
 
            result[entry.name] = entry
2298
 
            self._chk_inventory._fileid_to_entry_cache[file_id_key[0]] = entry
2299
 
        self._children = result
2300
 
        return result
2301
 
 
2302
 
entry_factory = {
2303
 
    'directory': InventoryDirectory,
2304
 
    'file': InventoryFile,
2305
 
    'symlink': InventoryLink,
2306
 
    'tree-reference': TreeReference
2307
 
}
2308
 
 
2309
 
def make_entry(kind, name, parent_id, file_id=None):
2310
 
    """Create an inventory entry.
2311
 
 
2312
 
    :param kind: the type of inventory entry to create.
2313
 
    :param name: the basename of the entry.
2314
 
    :param parent_id: the parent_id of the entry.
2315
 
    :param file_id: the file_id to use. if None, one will be created.
2316
 
    """
2317
 
    if file_id is None:
2318
 
        file_id = generate_ids.gen_file_id(name)
2319
 
    name = ensure_normalized_name(name)
2320
 
    try:
2321
 
        factory = entry_factory[kind]
2322
 
    except KeyError:
2323
 
        raise errors.BadFileKindError(name, kind)
2324
 
    return factory(file_id, name, parent_id)
2325
 
 
2326
 
 
2327
 
def ensure_normalized_name(name):
2328
 
    """Normalize name.
2329
 
 
2330
 
    :raises InvalidNormalization: When name is not normalized, and cannot be
2331
 
        accessed on this platform by the normalized path.
2332
 
    :return: The NFC normalised version of name.
2333
 
    """
2334
 
    #------- This has been copied to bzrlib.dirstate.DirState.add, please
2335
 
    # keep them synchronised.
2336
 
    # we dont import normalized_filename directly because we want to be
2337
 
    # able to change the implementation at runtime for tests.
2338
 
    norm_name, can_access = osutils.normalized_filename(name)
2339
 
    if norm_name != name:
2340
 
        if can_access:
2341
 
            return norm_name
2342
 
        else:
2343
 
            # TODO: jam 20060701 This would probably be more useful
2344
 
            #       if the error was raised with the full path
2345
 
            raise errors.InvalidNormalization(name)
2346
 
    return name
 
1188
 
2347
1189
 
2348
1190
 
2349
1191
_NAME_RE = None
2350
1192
 
2351
1193
def is_valid_name(name):
2352
1194
    global _NAME_RE
2353
 
    if _NAME_RE is None:
 
1195
    if _NAME_RE == None:
2354
1196
        _NAME_RE = re.compile(r'^[^/\\]+$')
2355
 
 
 
1197
        
2356
1198
    return bool(_NAME_RE.match(name))
2357
 
 
2358
 
 
2359
 
def _check_delta_unique_ids(delta):
2360
 
    """Decorate a delta and check that the file ids in it are unique.
2361
 
 
2362
 
    :return: A generator over delta.
2363
 
    """
2364
 
    ids = set()
2365
 
    for item in delta:
2366
 
        length = len(ids) + 1
2367
 
        ids.add(item[2])
2368
 
        if len(ids) != length:
2369
 
            raise errors.InconsistentDelta(item[0] or item[1], item[2],
2370
 
                "repeated file_id")
2371
 
        yield item
2372
 
 
2373
 
 
2374
 
def _check_delta_unique_new_paths(delta):
2375
 
    """Decorate a delta and check that the new paths in it are unique.
2376
 
 
2377
 
    :return: A generator over delta.
2378
 
    """
2379
 
    paths = set()
2380
 
    for item in delta:
2381
 
        length = len(paths) + 1
2382
 
        path = item[1]
2383
 
        if path is not None:
2384
 
            paths.add(path)
2385
 
            if len(paths) != length:
2386
 
                raise errors.InconsistentDelta(path, item[2], "repeated path")
2387
 
        yield item
2388
 
 
2389
 
 
2390
 
def _check_delta_unique_old_paths(delta):
2391
 
    """Decorate a delta and check that the old paths in it are unique.
2392
 
 
2393
 
    :return: A generator over delta.
2394
 
    """
2395
 
    paths = set()
2396
 
    for item in delta:
2397
 
        length = len(paths) + 1
2398
 
        path = item[0]
2399
 
        if path is not None:
2400
 
            paths.add(path)
2401
 
            if len(paths) != length:
2402
 
                raise errors.InconsistentDelta(path, item[2], "repeated path")
2403
 
        yield item
2404
 
 
2405
 
 
2406
 
def _check_delta_ids_are_valid(delta):
2407
 
    """Decorate a delta and check that the ids in it are valid.
2408
 
 
2409
 
    :return: A generator over delta.
2410
 
    """
2411
 
    for item in delta:
2412
 
        entry = item[3]
2413
 
        if item[2] is None:
2414
 
            raise errors.InconsistentDelta(item[0] or item[1], item[2],
2415
 
                "entry with file_id None %r" % entry)
2416
 
        if type(item[2]) != str:
2417
 
            raise errors.InconsistentDelta(item[0] or item[1], item[2],
2418
 
                "entry with non bytes file_id %r" % entry)
2419
 
        yield item
2420
 
 
2421
 
 
2422
 
def _check_delta_ids_match_entry(delta):
2423
 
    """Decorate a delta and check that the ids in it match the entry.file_id.
2424
 
 
2425
 
    :return: A generator over delta.
2426
 
    """
2427
 
    for item in delta:
2428
 
        entry = item[3]
2429
 
        if entry is not None:
2430
 
            if entry.file_id != item[2]:
2431
 
                raise errors.InconsistentDelta(item[0] or item[1], item[2],
2432
 
                    "mismatched id with %r" % entry)
2433
 
        yield item
2434
 
 
2435
 
 
2436
 
def _check_delta_new_path_entry_both_or_None(delta):
2437
 
    """Decorate a delta and check that the new_path and entry are paired.
2438
 
 
2439
 
    :return: A generator over delta.
2440
 
    """
2441
 
    for item in delta:
2442
 
        new_path = item[1]
2443
 
        entry = item[3]
2444
 
        if new_path is None and entry is not None:
2445
 
            raise errors.InconsistentDelta(item[0], item[1],
2446
 
                "Entry with no new_path")
2447
 
        if new_path is not None and entry is None:
2448
 
            raise errors.InconsistentDelta(new_path, item[1],
2449
 
                "new_path with no entry")
2450
 
        yield item