/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Robert Collins
  • Date: 2008-08-20 02:07:36 UTC
  • mfrom: (3640 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3682.
  • Revision ID: robertc@robertcollins.net-20080820020736-g2xe4921zzxtymle
Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 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
27
27
# created, but it's not for now.
28
28
ROOT_ID = "TREE_ROOT"
29
29
 
30
 
 
31
 
import collections
32
 
import os.path
 
30
import os
33
31
import re
34
32
import sys
 
33
 
 
34
from bzrlib.lazy_import import lazy_import
 
35
lazy_import(globals(), """
 
36
import collections
35
37
import tarfile
36
 
import types
37
38
 
38
39
import bzrlib
39
 
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
40
 
                            pathjoin, sha_strings)
41
 
from bzrlib.errors import (NotVersionedError, InvalidEntryName,
42
 
                           BzrError, BzrCheckError, BinaryFile)
 
40
from bzrlib import (
 
41
    errors,
 
42
    generate_ids,
 
43
    osutils,
 
44
    symbol_versioning,
 
45
    workingtree,
 
46
    )
 
47
""")
 
48
 
 
49
from bzrlib.errors import (
 
50
    BzrCheckError,
 
51
    BzrError,
 
52
    )
 
53
from bzrlib.symbol_versioning import deprecated_in, deprecated_method
43
54
from bzrlib.trace import mutter
44
55
 
45
56
 
77
88
    >>> i.path2id('')
78
89
    'TREE_ROOT'
79
90
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
80
 
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
 
91
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
81
92
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
82
 
    InventoryFile('2323', 'hello.c', parent_id='123')
83
 
    >>> shouldbe = {0: 'src', 1: pathjoin('src','hello.c')}
 
93
    InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
 
94
    >>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}
84
95
    >>> for ix, j in enumerate(i.iter_entries()):
85
96
    ...   print (j[0] == shouldbe[ix], j[1])
86
97
    ... 
87
 
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT'))
88
 
    (True, InventoryFile('2323', 'hello.c', parent_id='123'))
89
 
    >>> i.add(InventoryFile('2323', 'bye.c', '123'))
90
 
    Traceback (most recent call last):
91
 
    ...
92
 
    BzrError: inventory already contains entry with id {2323}
 
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))
93
101
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
94
 
    InventoryFile('2324', 'bye.c', parent_id='123')
 
102
    InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
95
103
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
96
 
    InventoryDirectory('2325', 'wibble', parent_id='123')
 
104
    InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
97
105
    >>> i.path2id('src/wibble')
98
106
    '2325'
99
107
    >>> '2325' in i
100
108
    True
101
109
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
102
 
    InventoryFile('2326', 'wibble.c', parent_id='2325')
 
110
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
103
111
    >>> i['2326']
104
 
    InventoryFile('2326', 'wibble.c', parent_id='2325')
 
112
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
105
113
    >>> for path, entry in i.iter_entries():
106
114
    ...     print path
107
 
    ...     assert i.path2id(path)
108
115
    ... 
 
116
    <BLANKLINE>
109
117
    src
110
118
    src/bye.c
111
119
    src/hello.c
123
131
    RENAMED = 'renamed'
124
132
    MODIFIED_AND_RENAMED = 'modified and renamed'
125
133
    
126
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
127
 
                 'text_id', 'parent_id', 'children', 'executable', 
128
 
                 'revision']
 
134
    __slots__ = []
129
135
 
130
136
    def detect_changes(self, old_entry):
131
137
        """Return a (text_modified, meta_modified) from this to old_entry.
135
141
        """
136
142
        return False, False
137
143
 
138
 
    def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
139
 
             output_to, reverse=False):
140
 
        """Perform a diff from this to to_entry.
141
 
 
142
 
        text_diff will be used for textual difference calculation.
143
 
        This is a template method, override _diff in child classes.
144
 
        """
145
 
        self._read_tree_state(tree.id2path(self.file_id), tree)
146
 
        if to_entry:
147
 
            # cannot diff from one kind to another - you must do a removal
148
 
            # and an addif they do not match.
149
 
            assert self.kind == to_entry.kind
150
 
            to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
151
 
                                      to_tree)
152
 
        self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
153
 
                   output_to, reverse)
154
 
 
155
144
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
156
145
             output_to, reverse=False):
157
146
        """Perform a diff between two entries of the same kind."""
158
 
 
159
 
    def find_previous_heads(self, previous_inventories,
160
 
                            versioned_file_store,
161
 
                            transaction,
162
 
                            entry_vf=None):
163
 
        """Return the revisions and entries that directly preceed this.
164
 
 
165
 
        Returned as a map from revision to inventory entry.
166
 
 
167
 
        This is a map containing the file revisions in all parents
168
 
        for which the file exists, and its revision is not a parent of
169
 
        any other. If the file is new, the set will be empty.
170
 
 
171
 
        :param versioned_file_store: A store where ancestry data on this
172
 
                                     file id can be queried.
173
 
        :param transaction: The transaction that queries to the versioned 
174
 
                            file store should be completed under.
175
 
        :param entry_vf: The entry versioned file, if its already available.
 
147
    
 
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.
176
156
        """
177
 
        def get_ancestors(weave, entry):
178
 
            return set(weave.get_ancestry(entry.revision))
179
157
        # revision:ie mapping for each ie found in previous_inventories.
180
158
        candidates = {}
181
 
        # revision:ie mapping with one revision for each head.
182
 
        heads = {}
183
 
        # revision: ancestor list for each head
184
 
        head_ancestors = {}
185
159
        # identify candidate head revision ids.
186
160
        for inv in previous_inventories:
187
161
            if self.file_id in inv:
188
162
                ie = inv[self.file_id]
189
 
                assert ie.file_id == self.file_id
190
163
                if ie.revision in candidates:
191
164
                    # same revision value in two different inventories:
192
165
                    # correct possible inconsistencies:
198
171
                            ie.executable = False
199
172
                    except AttributeError:
200
173
                        pass
201
 
                    # must now be the same.
202
 
                    assert candidates[ie.revision] == ie
203
174
                else:
204
175
                    # add this revision as a candidate.
205
176
                    candidates[ie.revision] = ie
206
 
 
207
 
        # common case optimisation
208
 
        if len(candidates) == 1:
209
 
            # if there is only one candidate revision found
210
 
            # then we can opening the versioned file to access ancestry:
211
 
            # there cannot be any ancestors to eliminate when there is 
212
 
            # only one revision available.
213
 
            heads[ie.revision] = ie
214
 
            return heads
215
 
 
216
 
        # eliminate ancestors amongst the available candidates:
217
 
        # heads are those that are not an ancestor of any other candidate
218
 
        # - this provides convergence at a per-file level.
219
 
        for ie in candidates.values():
220
 
            # may be an ancestor of a known head:
221
 
            already_present = 0 != len(
222
 
                [head for head in heads 
223
 
                 if ie.revision in head_ancestors[head]])
224
 
            if already_present:
225
 
                # an ancestor of an analyzed candidate.
226
 
                continue
227
 
            # not an ancestor of a known head:
228
 
            # load the versioned file for this file id if needed
229
 
            if entry_vf is None:
230
 
                entry_vf = versioned_file_store.get_weave_or_empty(
231
 
                    self.file_id, transaction)
232
 
            ancestors = get_ancestors(entry_vf, ie)
233
 
            # may knock something else out:
234
 
            check_heads = list(heads.keys())
235
 
            for head in check_heads:
236
 
                if head in ancestors:
237
 
                    # this previously discovered 'head' is not
238
 
                    # really a head - its an ancestor of the newly 
239
 
                    # found head,
240
 
                    heads.pop(head)
241
 
            head_ancestors[ie.revision] = ancestors
242
 
            heads[ie.revision] = ie
243
 
        return heads
244
 
 
 
177
        return candidates
 
178
 
 
179
    @deprecated_method(deprecated_in((1, 6, 0)))
245
180
    def get_tar_item(self, root, dp, now, tree):
246
181
        """Get a tarfile item and a file stream for its content."""
247
 
        item = tarfile.TarInfo(pathjoin(root, dp))
 
182
        item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
248
183
        # TODO: would be cool to actually set it to the timestamp of the
249
184
        # revision it was last changed
250
185
        item.mtime = now
277
212
        Traceback (most recent call last):
278
213
        InvalidEntryName: Invalid entry name: src/hello.c
279
214
        """
280
 
        assert isinstance(name, basestring), name
281
215
        if '/' in name or '\\' in name:
282
 
            raise InvalidEntryName(name=name)
 
216
            raise errors.InvalidEntryName(name=name)
283
217
        self.executable = False
284
218
        self.revision = None
285
219
        self.text_sha1 = None
289
223
        self.text_id = text_id
290
224
        self.parent_id = parent_id
291
225
        self.symlink_target = None
 
226
        self.reference_revision = None
292
227
 
293
228
    def kind_character(self):
294
229
        """Return a short kind indicator useful for appending to names."""
295
230
        raise BzrError('unknown kind %r' % self.kind)
296
231
 
297
 
    known_kinds = ('file', 'directory', 'symlink', 'root_directory')
 
232
    known_kinds = ('file', 'directory', 'symlink')
298
233
 
299
234
    def _put_in_tar(self, item, tree):
300
235
        """populate item for stashing in a tar, and return the content stream.
304
239
        raise BzrError("don't know how to export {%s} of kind %r" %
305
240
                       (self.file_id, self.kind))
306
241
 
 
242
    @deprecated_method(deprecated_in((1, 6, 0)))
307
243
    def put_on_disk(self, dest, dp, tree):
308
244
        """Create a representation of self on disk in the prefix dest.
309
245
        
310
246
        This is a template method - implement _put_on_disk in subclasses.
311
247
        """
312
 
        fullpath = pathjoin(dest, dp)
 
248
        fullpath = osutils.pathjoin(dest, dp)
313
249
        self._put_on_disk(fullpath, tree)
314
 
        mutter("  export {%s} kind %s to %s", self.file_id,
315
 
                self.kind, fullpath)
 
250
        # mutter("  export {%s} kind %s to %s", self.file_id,
 
251
        #         self.kind, fullpath)
316
252
 
317
253
    def _put_on_disk(self, fullpath, tree):
318
254
        """Put this entry onto disk at fullpath, from tree tree."""
319
255
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
320
256
 
321
257
    def sorted_children(self):
322
 
        l = self.children.items()
323
 
        l.sort()
324
 
        return l
 
258
        return sorted(self.children.items())
325
259
 
326
260
    @staticmethod
327
261
    def versionable_kind(kind):
328
 
        return kind in ('file', 'directory', 'symlink')
 
262
        return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
329
263
 
330
264
    def check(self, checker, rev_id, inv, tree):
331
265
        """Check this inventory entry is intact.
341
275
        :param inv: Inventory from which the entry was loaded.
342
276
        :param tree: RevisionTree for this entry.
343
277
        """
344
 
        if self.parent_id != None:
 
278
        if self.parent_id is not None:
345
279
            if not inv.has_id(self.parent_id):
346
280
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
347
281
                        % (self.parent_id, rev_id))
376
310
            return 'added'
377
311
        elif new_entry is None:
378
312
            return 'removed'
 
313
        if old_entry.kind != new_entry.kind:
 
314
            return 'modified'
379
315
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
380
316
        if text_modified or meta_modified:
381
317
            modified = True
397
333
        return 'unchanged'
398
334
 
399
335
    def __repr__(self):
400
 
        return ("%s(%r, %r, parent_id=%r)"
 
336
        return ("%s(%r, %r, parent_id=%r, revision=%r)"
401
337
                % (self.__class__.__name__,
402
338
                   self.file_id,
403
339
                   self.name,
404
 
                   self.parent_id))
405
 
 
406
 
    def snapshot(self, revision, path, previous_entries,
407
 
                 work_tree, commit_builder):
408
 
        """Make a snapshot of this entry which may or may not have changed.
409
 
        
410
 
        This means that all its fields are populated, that it has its
411
 
        text stored in the text store or weave.
412
 
        """
413
 
        mutter('new parents of %s are %r', path, previous_entries)
414
 
        self._read_tree_state(path, work_tree)
415
 
        # TODO: Where should we determine whether to reuse a
416
 
        # previous revision id or create a new revision? 20060606
417
 
        if len(previous_entries) == 1:
418
 
            # cannot be unchanged unless there is only one parent file rev.
419
 
            parent_ie = previous_entries.values()[0]
420
 
            if self._unchanged(parent_ie):
421
 
                mutter("found unchanged entry")
422
 
                self.revision = parent_ie.revision
423
 
                return "unchanged"
424
 
        return self._snapshot_into_revision(revision, previous_entries, 
425
 
                                            work_tree, commit_builder)
426
 
 
427
 
    def _snapshot_into_revision(self, revision, previous_entries, work_tree,
428
 
                                commit_builder):
429
 
        """Record this revision unconditionally into a store.
430
 
 
431
 
        The entry's last-changed revision property (`revision`) is updated to 
432
 
        that of the new revision.
433
 
        
434
 
        :param revision: id of the new revision that is being recorded.
435
 
 
436
 
        :returns: String description of the commit (e.g. "merged", "modified"), etc.
437
 
        """
438
 
        mutter('new revision {%s} for {%s}', revision, self.file_id)
439
 
        self.revision = revision
440
 
        self._snapshot_text(previous_entries, work_tree, commit_builder)
441
 
 
442
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder): 
443
 
        """Record the 'text' of this entry, whatever form that takes.
444
 
        
445
 
        This default implementation simply adds an empty text.
446
 
        """
447
 
        raise NotImplementedError(self._snapshot_text)
 
340
                   self.parent_id,
 
341
                   self.revision))
448
342
 
449
343
    def __eq__(self, other):
450
344
        if not isinstance(other, InventoryEntry):
460
354
                and (self.kind == other.kind)
461
355
                and (self.revision == other.revision)
462
356
                and (self.executable == other.executable)
 
357
                and (self.reference_revision == other.reference_revision)
463
358
                )
464
359
 
465
360
    def __ne__(self, other):
471
366
    def _unchanged(self, previous_ie):
472
367
        """Has this entry changed relative to previous_ie.
473
368
 
474
 
        This method should be overriden in child classes.
 
369
        This method should be overridden in child classes.
475
370
        """
476
371
        compatible = True
477
372
        # different inv parent
480
375
        # renamed
481
376
        elif previous_ie.name != self.name:
482
377
            compatible = False
 
378
        elif previous_ie.kind != self.kind:
 
379
            compatible = False
483
380
        return compatible
484
381
 
485
382
    def _read_tree_state(self, path, work_tree):
499
396
 
500
397
class RootEntry(InventoryEntry):
501
398
 
 
399
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
400
                 'text_id', 'parent_id', 'children', 'executable',
 
401
                 'revision', 'symlink_target', 'reference_revision']
 
402
 
502
403
    def _check(self, checker, rev_id, tree):
503
404
        """See InventoryEntry._check"""
504
405
 
505
406
    def __init__(self, file_id):
506
407
        self.file_id = file_id
507
408
        self.children = {}
508
 
        self.kind = 'root_directory'
 
409
        self.kind = 'directory'
509
410
        self.parent_id = None
510
411
        self.name = u''
 
412
        self.revision = None
 
413
        symbol_versioning.warn('RootEntry is deprecated as of bzr 0.10.'
 
414
                               '  Please use InventoryDirectory instead.',
 
415
                               DeprecationWarning, stacklevel=2)
511
416
 
512
417
    def __eq__(self, other):
513
418
        if not isinstance(other, RootEntry):
520
425
class InventoryDirectory(InventoryEntry):
521
426
    """A directory in an inventory."""
522
427
 
 
428
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
429
                 'text_id', 'parent_id', 'children', 'executable',
 
430
                 'revision', 'symlink_target', 'reference_revision']
 
431
 
523
432
    def _check(self, checker, rev_id, tree):
524
433
        """See InventoryEntry._check"""
525
 
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
434
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
526
435
            raise BzrCheckError('directory {%s} has text in revision {%s}'
527
436
                                % (self.file_id, rev_id))
528
437
 
555
464
        """See InventoryEntry._put_on_disk."""
556
465
        os.mkdir(fullpath)
557
466
 
558
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
559
 
        """See InventoryEntry._snapshot_text."""
560
 
        commit_builder.modified_directory(self.file_id, file_parents)
561
 
 
562
467
 
563
468
class InventoryFile(InventoryEntry):
564
469
    """A file in an inventory."""
565
470
 
 
471
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
472
                 'text_id', 'parent_id', 'children', 'executable',
 
473
                 'revision', 'symlink_target', 'reference_revision']
 
474
 
566
475
    def _check(self, checker, tree_revision_id, tree):
567
476
        """See InventoryEntry._check"""
568
 
        t = (self.file_id, self.revision)
569
 
        if t in checker.checked_texts:
570
 
            prev_sha = checker.checked_texts[t]
 
477
        key = (self.file_id, self.revision)
 
478
        if key in checker.checked_texts:
 
479
            prev_sha = checker.checked_texts[key]
571
480
            if prev_sha != self.text_sha1:
572
 
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
573
 
                                    (self.file_id, tree_revision_id))
 
481
                raise BzrCheckError(
 
482
                    'mismatched sha1 on {%s} in {%s} (%s != %s) %r' %
 
483
                    (self.file_id, tree_revision_id, prev_sha, self.text_sha1,
 
484
                     t))
574
485
            else:
575
486
                checker.repeated_text_cnt += 1
576
487
                return
577
488
 
578
 
        if self.file_id not in checker.checked_weaves:
579
 
            mutter('check weave {%s}', self.file_id)
580
 
            w = tree.get_weave(self.file_id)
581
 
            # Not passing a progress bar, because it creates a new
582
 
            # progress, which overwrites the current progress,
583
 
            # and doesn't look nice
584
 
            w.check()
585
 
            checker.checked_weaves[self.file_id] = True
586
 
        else:
587
 
            w = tree.get_weave(self.file_id)
588
 
 
589
489
        mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
590
490
        checker.checked_text_cnt += 1
591
491
        # We can't check the length, because Weave doesn't store that
592
492
        # information, and the whole point of looking at the weave's
593
493
        # sha1sum is that we don't have to extract the text.
594
 
        if self.text_sha1 != w.get_sha1(self.revision):
595
 
            raise BzrCheckError('text {%s} version {%s} wrong sha1' 
596
 
                                % (self.file_id, self.revision))
597
 
        checker.checked_texts[t] = self.text_sha1
 
494
        if (self.text_sha1 != tree._repository.texts.get_sha1s([key])[key]):
 
495
            raise BzrCheckError('text {%s} version {%s} wrong sha1' % key)
 
496
        checker.checked_texts[key] = self.text_sha1
598
497
 
599
498
    def copy(self):
600
499
        other = InventoryFile(self.file_id, self.name, self.parent_id)
607
506
 
608
507
    def detect_changes(self, old_entry):
609
508
        """See InventoryEntry.detect_changes."""
610
 
        assert self.text_sha1 != None
611
 
        assert old_entry.text_sha1 != None
612
509
        text_modified = (self.text_sha1 != old_entry.text_sha1)
613
510
        meta_modified = (self.executable != old_entry.executable)
614
511
        return text_modified, meta_modified
616
513
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
617
514
             output_to, reverse=False):
618
515
        """See InventoryEntry._diff."""
619
 
        try:
620
 
            from_text = tree.get_file(self.file_id).readlines()
621
 
            if to_entry:
622
 
                to_text = to_tree.get_file(to_entry.file_id).readlines()
623
 
            else:
624
 
                to_text = []
625
 
            if not reverse:
626
 
                text_diff(from_label, from_text,
627
 
                          to_label, to_text, output_to)
628
 
            else:
629
 
                text_diff(to_label, to_text,
630
 
                          from_label, from_text, output_to)
631
 
        except BinaryFile:
632
 
            if reverse:
633
 
                label_pair = (to_label, from_label)
634
 
            else:
635
 
                label_pair = (from_label, to_label)
636
 
            print >> output_to, "Binary files %s and %s differ" % label_pair
 
516
        from bzrlib.diff import DiffText
 
517
        from_file_id = self.file_id
 
518
        if to_entry:
 
519
            to_file_id = to_entry.file_id
 
520
        else:
 
521
            to_file_id = None
 
522
        if reverse:
 
523
            to_file_id, from_file_id = from_file_id, to_file_id
 
524
            tree, to_tree = to_tree, tree
 
525
            from_label, to_label = to_label, from_label
 
526
        differ = DiffText(tree, to_tree, output_to, 'utf-8', '', '',
 
527
                          text_diff)
 
528
        return differ.diff_text(from_file_id, to_file_id, from_label, to_label)
637
529
 
638
530
    def has_text(self):
639
531
        """See InventoryEntry.has_text."""
660
552
 
661
553
    def _put_on_disk(self, fullpath, tree):
662
554
        """See InventoryEntry._put_on_disk."""
663
 
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
 
555
        osutils.pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
664
556
        if tree.is_executable(self.file_id):
665
557
            os.chmod(fullpath, 0755)
666
558
 
671
563
        # in _read_tree_state
672
564
        self.executable = work_tree.is_executable(self.file_id, path=path)
673
565
 
 
566
    def __repr__(self):
 
567
        return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s)"
 
568
                % (self.__class__.__name__,
 
569
                   self.file_id,
 
570
                   self.name,
 
571
                   self.parent_id,
 
572
                   self.text_sha1,
 
573
                   self.text_size))
 
574
 
674
575
    def _forget_tree_state(self):
675
576
        self.text_sha1 = None
676
 
        self.executable = None
677
 
 
678
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
679
 
        """See InventoryEntry._snapshot_text."""
680
 
        def get_content_byte_lines():
681
 
            return work_tree.get_file(self.file_id).readlines()
682
 
        self.text_sha1, self.text_size = commit_builder.modified_file_text(
683
 
            self.file_id, file_parents, get_content_byte_lines, self.text_sha1, self.text_size)
684
577
 
685
578
    def _unchanged(self, previous_ie):
686
579
        """See InventoryEntry._unchanged."""
699
592
class InventoryLink(InventoryEntry):
700
593
    """A file in an inventory."""
701
594
 
702
 
    __slots__ = ['symlink_target']
 
595
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
596
                 'text_id', 'parent_id', 'children', 'executable',
 
597
                 'revision', 'symlink_target', 'reference_revision']
703
598
 
704
599
    def _check(self, checker, rev_id, tree):
705
600
        """See InventoryEntry._check"""
706
 
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
 
601
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
707
602
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
708
603
                    % (self.file_id, rev_id))
709
604
        if self.symlink_target is None:
728
623
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
729
624
             output_to, reverse=False):
730
625
        """See InventoryEntry._diff."""
731
 
        from_text = self.symlink_target
 
626
        from bzrlib.diff import DiffSymlink
 
627
        old_target = self.symlink_target
732
628
        if to_entry is not None:
733
 
            to_text = to_entry.symlink_target
734
 
            if reverse:
735
 
                temp = from_text
736
 
                from_text = to_text
737
 
                to_text = temp
738
 
            print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
739
 
        else:
740
 
            if not reverse:
741
 
                print >>output_to, '=== target was %r' % self.symlink_target
742
 
            else:
743
 
                print >>output_to, '=== target is %r' % self.symlink_target
 
629
            new_target = to_entry.symlink_target
 
630
        else:
 
631
            new_target = None
 
632
        if not reverse:
 
633
            old_tree = tree
 
634
            new_tree = to_tree
 
635
        else:
 
636
            old_tree = to_tree
 
637
            new_tree = tree
 
638
            new_target, old_target = old_target, new_target
 
639
        differ = DiffSymlink(old_tree, new_tree, output_to)
 
640
        return differ.diff_symlink(old_target, new_target)
744
641
 
745
642
    def __init__(self, file_id, name, parent_id):
746
643
        super(InventoryLink, self).__init__(file_id, name, parent_id)
780
677
            compatible = False
781
678
        return compatible
782
679
 
783
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
784
 
        """See InventoryEntry._snapshot_text."""
785
 
        commit_builder.modified_link(
786
 
            self.file_id, file_parents, self.symlink_target)
 
680
 
 
681
class TreeReference(InventoryEntry):
 
682
    
 
683
    kind = 'tree-reference'
 
684
    
 
685
    def __init__(self, file_id, name, parent_id, revision=None,
 
686
                 reference_revision=None):
 
687
        InventoryEntry.__init__(self, file_id, name, parent_id)
 
688
        self.revision = revision
 
689
        self.reference_revision = reference_revision
 
690
 
 
691
    def copy(self):
 
692
        return TreeReference(self.file_id, self.name, self.parent_id,
 
693
                             self.revision, self.reference_revision)
 
694
 
 
695
    def _read_tree_state(self, path, work_tree):
 
696
        """Populate fields in the inventory entry from the given tree.
 
697
        """
 
698
        self.reference_revision = work_tree.get_reference_revision(
 
699
            self.file_id, path)
 
700
 
 
701
    def _forget_tree_state(self):
 
702
        self.reference_revision = None 
 
703
 
 
704
    def _unchanged(self, previous_ie):
 
705
        """See InventoryEntry._unchanged."""
 
706
        compatible = super(TreeReference, self)._unchanged(previous_ie)
 
707
        if self.reference_revision != previous_ie.reference_revision:
 
708
            compatible = False
 
709
        return compatible
787
710
 
788
711
 
789
712
class Inventory(object):
805
728
 
806
729
    >>> inv = Inventory()
807
730
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
808
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
 
731
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
809
732
    >>> inv['123-123'].name
810
733
    'hello.c'
811
734
 
819
742
    May also look up by name:
820
743
 
821
744
    >>> [x[0] for x in inv.iter_entries()]
822
 
    [u'hello.c']
 
745
    ['', u'hello.c']
823
746
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
824
747
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
825
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
 
748
    Traceback (most recent call last):
 
749
    BzrError: parent_id {TREE_ROOT} not in inventory
 
750
    >>> inv.add(InventoryFile('123-123', 'hello.c', 'TREE_ROOT-12345678-12345678'))
 
751
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678', sha1=None, len=None)
826
752
    """
827
753
    def __init__(self, root_id=ROOT_ID, revision_id=None):
828
754
        """Create or read an inventory.
834
760
        The inventory is created with a default root directory, with
835
761
        an id of None.
836
762
        """
837
 
        # We are letting Branch.create() create a unique inventory
838
 
        # root id. Rather than generating a random one here.
839
 
        #if root_id is None:
840
 
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
841
 
        self.root = RootEntry(root_id)
 
763
        if root_id is not None:
 
764
            self._set_root(InventoryDirectory(root_id, u'', None))
 
765
        else:
 
766
            self.root = None
 
767
            self._byid = {}
842
768
        self.revision_id = revision_id
 
769
 
 
770
    def __repr__(self):
 
771
        return "<Inventory object at %x, contents=%r>" % (id(self), self._byid)
 
772
 
 
773
    def apply_delta(self, delta):
 
774
        """Apply a delta to this inventory.
 
775
 
 
776
        :param delta: A list of changes to apply. After all the changes are
 
777
            applied the final inventory must be internally consistent, but it
 
778
            is ok to supply changes which, if only half-applied would have an
 
779
            invalid result - such as supplying two changes which rename two
 
780
            files, 'A' and 'B' with each other : [('A', 'B', 'A-id', a_entry),
 
781
            ('B', 'A', 'B-id', b_entry)].
 
782
 
 
783
            Each change is a tuple, of the form (old_path, new_path, file_id,
 
784
            new_entry).
 
785
            
 
786
            When new_path is None, the change indicates the removal of an entry
 
787
            from the inventory and new_entry will be ignored (using None is
 
788
            appropriate). If new_path is not None, then new_entry must be an
 
789
            InventoryEntry instance, which will be incorporated into the
 
790
            inventory (and replace any existing entry with the same file id).
 
791
            
 
792
            When old_path is None, the change indicates the addition of
 
793
            a new entry to the inventory.
 
794
            
 
795
            When neither new_path nor old_path are None, the change is a
 
796
            modification to an entry, such as a rename, reparent, kind change
 
797
            etc. 
 
798
 
 
799
            The children attribute of new_entry is ignored. This is because
 
800
            this method preserves children automatically across alterations to
 
801
            the parent of the children, and cases where the parent id of a
 
802
            child is changing require the child to be passed in as a separate
 
803
            change regardless. E.g. in the recursive deletion of a directory -
 
804
            the directory's children must be included in the delta, or the
 
805
            final inventory will be invalid.
 
806
        """
 
807
        children = {}
 
808
        # Remove all affected items which were in the original inventory,
 
809
        # starting with the longest paths, thus ensuring parents are examined
 
810
        # after their children, which means that everything we examine has no
 
811
        # modified children remaining by the time we examine it.
 
812
        for old_path, file_id in sorted(((op, f) for op, np, f, e in delta
 
813
                                        if op is not None), reverse=True):
 
814
            if file_id not in self:
 
815
                # adds come later
 
816
                continue
 
817
            # Preserve unaltered children of file_id for later reinsertion.
 
818
            file_id_children = getattr(self[file_id], 'children', {})
 
819
            if len(file_id_children):
 
820
                children[file_id] = file_id_children
 
821
            # Remove file_id and the unaltered children. If file_id is not
 
822
            # being deleted it will be reinserted back later.
 
823
            self.remove_recursive_id(file_id)
 
824
        # Insert all affected which should be in the new inventory, reattaching
 
825
        # their children if they had any. This is done from shortest path to
 
826
        # longest, ensuring that items which were modified and whose parents in
 
827
        # the resulting inventory were also modified, are inserted after their
 
828
        # parents.
 
829
        for new_path, new_entry in sorted((np, e) for op, np, f, e in
 
830
                                          delta if np is not None):
 
831
            if new_entry.kind == 'directory':
 
832
                # Pop the child which to allow detection of children whose
 
833
                # parents were deleted and which were not reattached to a new
 
834
                # parent.
 
835
                new_entry.children = children.pop(new_entry.file_id, {})
 
836
            self.add(new_entry)
 
837
        if len(children):
 
838
            # Get the parent id that was deleted
 
839
            parent_id, children = children.popitem()
 
840
            raise errors.InconsistentDelta("<deleted>", parent_id,
 
841
                "The file id was deleted but its children were not deleted.")
 
842
 
 
843
    def _set_root(self, ie):
 
844
        self.root = ie
843
845
        self._byid = {self.root.file_id: self.root}
844
846
 
845
847
    def copy(self):
846
848
        # TODO: jam 20051218 Should copy also copy the revision_id?
847
 
        other = Inventory(self.root.file_id)
 
849
        entries = self.iter_entries()
 
850
        if self.root is None:
 
851
            return Inventory(root_id=None)
 
852
        other = Inventory(entries.next()[1].file_id)
 
853
        other.root.revision = self.root.revision
848
854
        # copy recursively so we know directories will be added before
849
855
        # their children.  There are more efficient ways than this...
850
 
        for path, entry in self.iter_entries():
851
 
            if entry == self.root:
852
 
                continue
 
856
        for path, entry in entries:
853
857
            other.add(entry.copy())
854
858
        return other
855
859
 
863
867
    def iter_entries(self, from_dir=None):
864
868
        """Return (path, entry) pairs, in order by name."""
865
869
        if from_dir is None:
866
 
            assert self.root
 
870
            if self.root is None:
 
871
                return
867
872
            from_dir = self.root
 
873
            yield '', self.root
868
874
        elif isinstance(from_dir, basestring):
869
875
            from_dir = self._byid[from_dir]
870
876
            
902
908
                # if we finished all children, pop it off the stack
903
909
                stack.pop()
904
910
 
905
 
    def iter_entries_by_dir(self, from_dir=None):
 
911
    def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None,
 
912
        yield_parents=False):
906
913
        """Iterate over the entries in a directory first order.
907
914
 
908
915
        This returns all entries for a directory before returning
910
917
        lexicographically sorted order, and is a hybrid between
911
918
        depth-first and breadth-first.
912
919
 
 
920
        :param yield_parents: If True, yield the parents from the root leading
 
921
            down to specific_file_ids that have been requested. This has no
 
922
            impact if specific_file_ids is None.
913
923
        :return: This yields (path, entry) pairs
914
924
        """
 
925
        if specific_file_ids and not isinstance(specific_file_ids, set):
 
926
            specific_file_ids = set(specific_file_ids)
915
927
        # TODO? Perhaps this should return the from_dir so that the root is
916
928
        # yielded? or maybe an option?
917
929
        if from_dir is None:
918
 
            assert self.root
 
930
            if self.root is None:
 
931
                return
 
932
            # Optimize a common case
 
933
            if (not yield_parents and specific_file_ids is not None and
 
934
                len(specific_file_ids) == 1):
 
935
                file_id = list(specific_file_ids)[0]
 
936
                if file_id in self:
 
937
                    yield self.id2path(file_id), self[file_id]
 
938
                return 
919
939
            from_dir = self.root
 
940
            if (specific_file_ids is None or yield_parents or
 
941
                self.root.file_id in specific_file_ids):
 
942
                yield u'', self.root
920
943
        elif isinstance(from_dir, basestring):
921
944
            from_dir = self._byid[from_dir]
 
945
 
 
946
        if specific_file_ids is not None:
 
947
            # TODO: jam 20070302 This could really be done as a loop rather
 
948
            #       than a bunch of recursive calls.
 
949
            parents = set()
 
950
            byid = self._byid
 
951
            def add_ancestors(file_id):
 
952
                if file_id not in byid:
 
953
                    return
 
954
                parent_id = byid[file_id].parent_id
 
955
                if parent_id is None:
 
956
                    return
 
957
                if parent_id not in parents:
 
958
                    parents.add(parent_id)
 
959
                    add_ancestors(parent_id)
 
960
            for file_id in specific_file_ids:
 
961
                add_ancestors(file_id)
 
962
        else:
 
963
            parents = None
922
964
            
923
965
        stack = [(u'', from_dir)]
924
966
        while stack:
929
971
 
930
972
                child_relpath = cur_relpath + child_name
931
973
 
932
 
                yield child_relpath, child_ie
 
974
                if (specific_file_ids is None or 
 
975
                    child_ie.file_id in specific_file_ids or
 
976
                    (yield_parents and child_ie.file_id in parents)):
 
977
                    yield child_relpath, child_ie
933
978
 
934
979
                if child_ie.kind == 'directory':
935
 
                    child_dirs.append((child_relpath+'/', child_ie))
 
980
                    if parents is None or child_ie.file_id in parents:
 
981
                        child_dirs.append((child_relpath+'/', child_ie))
936
982
            stack.extend(reversed(child_dirs))
937
983
 
 
984
    def make_entry(self, kind, name, parent_id, file_id=None):
 
985
        """Simple thunk to bzrlib.inventory.make_entry."""
 
986
        return make_entry(kind, name, parent_id, file_id)
 
987
 
938
988
    def entries(self):
939
989
        """Return list of (path, ie) for all entries except the root.
940
990
 
945
995
            kids = dir_ie.children.items()
946
996
            kids.sort()
947
997
            for name, ie in kids:
948
 
                child_path = pathjoin(dir_path, name)
 
998
                child_path = osutils.pathjoin(dir_path, name)
949
999
                accum.append((child_path, ie))
950
1000
                if ie.kind == 'directory':
951
1001
                    descend(ie, child_path)
964
1014
            kids.sort()
965
1015
 
966
1016
            for name, child_ie in kids:
967
 
                child_path = pathjoin(parent_path, name)
 
1017
                child_path = osutils.pathjoin(parent_path, name)
968
1018
                descend(child_ie, child_path)
969
1019
        descend(self.root, u'')
970
1020
        return accum
974
1024
 
975
1025
        >>> inv = Inventory()
976
1026
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
977
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
 
1027
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
978
1028
        >>> '123' in inv
979
1029
        True
980
1030
        >>> '456' in inv
981
1031
        False
982
1032
        """
983
 
        return file_id in self._byid
 
1033
        return (file_id in self._byid)
984
1034
 
985
1035
    def __getitem__(self, file_id):
986
1036
        """Return the entry for given file_id.
987
1037
 
988
1038
        >>> inv = Inventory()
989
1039
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
990
 
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
 
1040
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
991
1041
        >>> inv['123123'].name
992
1042
        'hello.c'
993
1043
        """
994
1044
        try:
995
1045
            return self._byid[file_id]
996
1046
        except KeyError:
997
 
            if file_id is None:
998
 
                raise BzrError("can't look up file_id None")
999
 
            else:
1000
 
                raise BzrError("file_id {%s} not in inventory" % file_id)
 
1047
            # really we're passing an inventory, not a tree...
 
1048
            raise errors.NoSuchId(self, file_id)
1001
1049
 
1002
1050
    def get_file_kind(self, file_id):
1003
1051
        return self._byid[file_id].kind
1005
1053
    def get_child(self, parent_id, filename):
1006
1054
        return self[parent_id].children.get(filename)
1007
1055
 
 
1056
    def _add_child(self, entry):
 
1057
        """Add an entry to the inventory, without adding it to its parent"""
 
1058
        if entry.file_id in self._byid:
 
1059
            raise BzrError("inventory already contains entry with id {%s}" %
 
1060
                           entry.file_id)
 
1061
        self._byid[entry.file_id] = entry
 
1062
        for child in getattr(entry, 'children', {}).itervalues():
 
1063
            self._add_child(child)
 
1064
        return entry
 
1065
 
1008
1066
    def add(self, entry):
1009
1067
        """Add entry to inventory.
1010
1068
 
1014
1072
        Returns the new entry object.
1015
1073
        """
1016
1074
        if entry.file_id in self._byid:
1017
 
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
1018
 
 
1019
 
        if entry.parent_id == ROOT_ID or entry.parent_id is None:
1020
 
            entry.parent_id = self.root.file_id
1021
 
 
1022
 
        try:
1023
 
            parent = self._byid[entry.parent_id]
1024
 
        except KeyError:
1025
 
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
1026
 
 
1027
 
        if parent.children.has_key(entry.name):
1028
 
            raise BzrError("%s is already versioned" %
1029
 
                    pathjoin(self.id2path(parent.file_id), entry.name))
1030
 
 
1031
 
        self._byid[entry.file_id] = entry
1032
 
        parent.children[entry.name] = entry
1033
 
        return entry
 
1075
            raise errors.DuplicateFileId(entry.file_id,
 
1076
                                         self._byid[entry.file_id])
 
1077
 
 
1078
        if entry.parent_id is None:
 
1079
            self.root = entry
 
1080
        else:
 
1081
            try:
 
1082
                parent = self._byid[entry.parent_id]
 
1083
            except KeyError:
 
1084
                raise BzrError("parent_id {%s} not in inventory" %
 
1085
                               entry.parent_id)
 
1086
 
 
1087
            if entry.name in parent.children:
 
1088
                raise BzrError("%s is already versioned" %
 
1089
                        osutils.pathjoin(self.id2path(parent.file_id),
 
1090
                        entry.name).encode('utf-8'))
 
1091
            parent.children[entry.name] = entry
 
1092
        return self._add_child(entry)
1034
1093
 
1035
1094
    def add_path(self, relpath, kind, file_id=None, parent_id=None):
1036
1095
        """Add entry from a path.
1039
1098
 
1040
1099
        Returns the new entry object."""
1041
1100
        
1042
 
        parts = bzrlib.osutils.splitpath(relpath)
 
1101
        parts = osutils.splitpath(relpath)
1043
1102
 
1044
1103
        if len(parts) == 0:
1045
1104
            if file_id is None:
1046
 
                file_id = bzrlib.workingtree.gen_root_id()
1047
 
            self.root = RootEntry(file_id)
 
1105
                file_id = generate_ids.gen_root_id()
 
1106
            self.root = InventoryDirectory(file_id, '', None)
1048
1107
            self._byid = {self.root.file_id: self.root}
1049
 
            return
 
1108
            return self.root
1050
1109
        else:
1051
1110
            parent_path = parts[:-1]
1052
1111
            parent_id = self.path2id(parent_path)
1053
1112
            if parent_id is None:
1054
 
                raise NotVersionedError(path=parent_path)
 
1113
                raise errors.NotVersionedError(path=parent_path)
1055
1114
        ie = make_entry(kind, parts[-1], parent_id, file_id)
1056
1115
        return self.add(ie)
1057
1116
 
1060
1119
 
1061
1120
        >>> inv = Inventory()
1062
1121
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1063
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
 
1122
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
1064
1123
        >>> '123' in inv
1065
1124
        True
1066
1125
        >>> del inv['123']
1068
1127
        False
1069
1128
        """
1070
1129
        ie = self[file_id]
1071
 
 
1072
 
        assert ie.parent_id is None or \
1073
 
            self[ie.parent_id].children[ie.name] == ie
1074
 
        
1075
1130
        del self._byid[file_id]
1076
1131
        if ie.parent_id is not None:
1077
1132
            del self[ie.parent_id].children[ie.name]
1084
1139
        >>> i1 == i2
1085
1140
        True
1086
1141
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
1087
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
 
1142
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
1088
1143
        >>> i1 == i2
1089
1144
        False
1090
1145
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
1091
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
 
1146
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
1092
1147
        >>> i1 == i2
1093
1148
        True
1094
1149
        """
1095
1150
        if not isinstance(other, Inventory):
1096
1151
            return NotImplemented
1097
1152
 
1098
 
        if len(self._byid) != len(other._byid):
1099
 
            # shortcut: obviously not the same
1100
 
            return False
1101
 
 
1102
1153
        return self._byid == other._byid
1103
1154
 
1104
1155
    def __ne__(self, other):
1109
1160
 
1110
1161
    def _iter_file_id_parents(self, file_id):
1111
1162
        """Yield the parents of file_id up to the root."""
1112
 
        while file_id != None:
 
1163
        while file_id is not None:
1113
1164
            try:
1114
1165
                ie = self._byid[file_id]
1115
1166
            except KeyError:
1116
 
                raise BzrError("file_id {%s} not found in inventory" % file_id)
 
1167
                raise errors.NoSuchId(tree=None, file_id=file_id)
1117
1168
            yield ie
1118
1169
            file_id = ie.parent_id
1119
1170
 
1155
1206
 
1156
1207
        Returns None IFF the path is not found.
1157
1208
        """
1158
 
        if isinstance(name, types.StringTypes):
1159
 
            name = splitpath(name)
 
1209
        if isinstance(name, basestring):
 
1210
            name = osutils.splitpath(name)
1160
1211
 
1161
1212
        # mutter("lookup path %r" % name)
1162
1213
 
1163
1214
        parent = self.root
 
1215
        if parent is None:
 
1216
            return None
1164
1217
        for f in name:
1165
1218
            try:
1166
 
                cie = parent.children[f]
1167
 
                assert cie.name == f
1168
 
                assert cie.parent_id == parent.file_id
 
1219
                children = getattr(parent, 'children', None)
 
1220
                if children is None:
 
1221
                    return None
 
1222
                cie = children[f]
1169
1223
                parent = cie
1170
1224
            except KeyError:
1171
1225
                # or raise an error?
1177
1231
        return bool(self.path2id(names))
1178
1232
 
1179
1233
    def has_id(self, file_id):
1180
 
        return self._byid.has_key(file_id)
 
1234
        return (file_id in self._byid)
 
1235
 
 
1236
    def remove_recursive_id(self, file_id):
 
1237
        """Remove file_id, and children, from the inventory.
 
1238
        
 
1239
        :param file_id: A file_id to remove.
 
1240
        """
 
1241
        to_find_delete = [self._byid[file_id]]
 
1242
        to_delete = []
 
1243
        while to_find_delete:
 
1244
            ie = to_find_delete.pop()
 
1245
            to_delete.append(ie.file_id)
 
1246
            if ie.kind == 'directory':
 
1247
                to_find_delete.extend(ie.children.values())
 
1248
        for file_id in reversed(to_delete):
 
1249
            ie = self[file_id]
 
1250
            del self._byid[file_id]
 
1251
        if ie.parent_id is not None:
 
1252
            del self[ie.parent_id].children[ie.name]
 
1253
        else:
 
1254
            self.root = None
1181
1255
 
1182
1256
    def rename(self, file_id, new_parent_id, new_name):
1183
1257
        """Move a file within the inventory.
1184
1258
 
1185
1259
        This can change either the name, or the parent, or both.
1186
1260
 
1187
 
        This does not move the working file."""
 
1261
        This does not move the working file.
 
1262
        """
 
1263
        new_name = ensure_normalized_name(new_name)
1188
1264
        if not is_valid_name(new_name):
1189
1265
            raise BzrError("not an acceptable filename: %r" % new_name)
1190
1266
 
1208
1284
        file_ie.name = new_name
1209
1285
        file_ie.parent_id = new_parent_id
1210
1286
 
 
1287
    def is_root(self, file_id):
 
1288
        return self.root is not None and file_id == self.root.file_id
 
1289
 
 
1290
 
 
1291
entry_factory = {
 
1292
    'directory': InventoryDirectory,
 
1293
    'file': InventoryFile,
 
1294
    'symlink': InventoryLink,
 
1295
    'tree-reference': TreeReference
 
1296
}
1211
1297
 
1212
1298
def make_entry(kind, name, parent_id, file_id=None):
1213
1299
    """Create an inventory entry.
1218
1304
    :param file_id: the file_id to use. if None, one will be created.
1219
1305
    """
1220
1306
    if file_id is None:
1221
 
        file_id = bzrlib.workingtree.gen_file_id(name)
1222
 
    if kind == 'directory':
1223
 
        return InventoryDirectory(file_id, name, parent_id)
1224
 
    elif kind == 'file':
1225
 
        return InventoryFile(file_id, name, parent_id)
1226
 
    elif kind == 'symlink':
1227
 
        return InventoryLink(file_id, name, parent_id)
1228
 
    else:
 
1307
        file_id = generate_ids.gen_file_id(name)
 
1308
    name = ensure_normalized_name(name)
 
1309
    try:
 
1310
        factory = entry_factory[kind]
 
1311
    except KeyError:
1229
1312
        raise BzrError("unknown kind %r" % kind)
1230
 
 
 
1313
    return factory(file_id, name, parent_id)
 
1314
 
 
1315
 
 
1316
def ensure_normalized_name(name):
 
1317
    """Normalize name.
 
1318
 
 
1319
    :raises InvalidNormalization: When name is not normalized, and cannot be
 
1320
        accessed on this platform by the normalized path.
 
1321
    :return: The NFC normalised version of name.
 
1322
    """
 
1323
    #------- This has been copied to bzrlib.dirstate.DirState.add, please
 
1324
    # keep them synchronised.
 
1325
    # we dont import normalized_filename directly because we want to be
 
1326
    # able to change the implementation at runtime for tests.
 
1327
    norm_name, can_access = osutils.normalized_filename(name)
 
1328
    if norm_name != name:
 
1329
        if can_access:
 
1330
            return norm_name
 
1331
        else:
 
1332
            # TODO: jam 20060701 This would probably be more useful
 
1333
            #       if the error was raised with the full path
 
1334
            raise errors.InvalidNormalization(name)
 
1335
    return name
1231
1336
 
1232
1337
 
1233
1338
_NAME_RE = None