← Back to branch summary

~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-06-12 01:12:14 UTC
  • mfrom: (1752.1.7 configobj)
  • Revision ID: pqm@pqm.ubuntu.com-20060612011214-3f50082086eb3ef6
Stop using shlex in run_bzr_subprocess

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
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
27
27
# created, but it's not for now.
28
28
ROOT_ID = "TREE_ROOT"
29
29
 
30
 
import os
 
30
 
 
31
import collections
 
32
import os.path
31
33
import re
32
34
import sys
33
 
 
34
 
from bzrlib.lazy_import import lazy_import
35
 
lazy_import(globals(), """
36
 
import collections
37
35
import tarfile
 
36
import types
38
37
 
39
38
import bzrlib
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
 
39
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
 
40
                            pathjoin, sha_strings)
 
41
from bzrlib.errors import (NotVersionedError, InvalidEntryName,
 
42
                           BzrError, BzrCheckError, BinaryFile)
54
43
from bzrlib.trace import mutter
55
44
 
56
45
 
88
77
    >>> i.path2id('')
89
78
    'TREE_ROOT'
90
79
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
91
 
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
 
80
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
92
81
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
93
 
    InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
94
 
    >>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}
 
82
    InventoryFile('2323', 'hello.c', parent_id='123')
 
83
    >>> shouldbe = {0: 'src', 1: pathjoin('src','hello.c')}
95
84
    >>> for ix, j in enumerate(i.iter_entries()):
96
85
    ...   print (j[0] == shouldbe[ix], j[1])
97
86
    ... 
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))
 
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}
101
93
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
102
 
    InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
 
94
    InventoryFile('2324', 'bye.c', parent_id='123')
103
95
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
104
 
    InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
 
96
    InventoryDirectory('2325', 'wibble', parent_id='123')
105
97
    >>> i.path2id('src/wibble')
106
98
    '2325'
107
99
    >>> '2325' in i
108
100
    True
109
101
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
110
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
102
    InventoryFile('2326', 'wibble.c', parent_id='2325')
111
103
    >>> i['2326']
112
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
104
    InventoryFile('2326', 'wibble.c', parent_id='2325')
113
105
    >>> for path, entry in i.iter_entries():
114
106
    ...     print path
 
107
    ...     assert i.path2id(path)
115
108
    ... 
116
 
    <BLANKLINE>
117
109
    src
118
110
    src/bye.c
119
111
    src/hello.c
131
123
    RENAMED = 'renamed'
132
124
    MODIFIED_AND_RENAMED = 'modified and renamed'
133
125
    
134
 
    __slots__ = []
 
126
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
127
                 'text_id', 'parent_id', 'children', 'executable', 
 
128
                 'revision']
135
129
 
136
130
    def detect_changes(self, old_entry):
137
131
        """Return a (text_modified, meta_modified) from this to old_entry.
141
135
        """
142
136
        return False, False
143
137
 
 
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
 
144
155
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
145
156
             output_to, reverse=False):
146
157
        """Perform a diff between two entries of the same kind."""
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.
 
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.
156
176
        """
 
177
        def get_ancestors(weave, entry):
 
178
            return set(weave.get_ancestry(entry.revision))
157
179
        # revision:ie mapping for each ie found in previous_inventories.
158
180
        candidates = {}
 
181
        # revision:ie mapping with one revision for each head.
 
182
        heads = {}
 
183
        # revision: ancestor list for each head
 
184
        head_ancestors = {}
159
185
        # identify candidate head revision ids.
160
186
        for inv in previous_inventories:
161
187
            if self.file_id in inv:
162
188
                ie = inv[self.file_id]
 
189
                assert ie.file_id == self.file_id
163
190
                if ie.revision in candidates:
164
191
                    # same revision value in two different inventories:
165
192
                    # correct possible inconsistencies:
171
198
                            ie.executable = False
172
199
                    except AttributeError:
173
200
                        pass
 
201
                    # must now be the same.
 
202
                    assert candidates[ie.revision] == ie
174
203
                else:
175
204
                    # add this revision as a candidate.
176
205
                    candidates[ie.revision] = ie
177
 
        return candidates
178
 
 
179
 
    @deprecated_method(deprecated_in((1, 6, 0)))
 
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
 
180
245
    def get_tar_item(self, root, dp, now, tree):
181
246
        """Get a tarfile item and a file stream for its content."""
182
 
        item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
 
247
        item = tarfile.TarInfo(pathjoin(root, dp))
183
248
        # TODO: would be cool to actually set it to the timestamp of the
184
249
        # revision it was last changed
185
250
        item.mtime = now
212
277
        Traceback (most recent call last):
213
278
        InvalidEntryName: Invalid entry name: src/hello.c
214
279
        """
 
280
        assert isinstance(name, basestring), name
215
281
        if '/' in name or '\\' in name:
216
 
            raise errors.InvalidEntryName(name=name)
 
282
            raise InvalidEntryName(name=name)
217
283
        self.executable = False
218
284
        self.revision = None
219
285
        self.text_sha1 = None
223
289
        self.text_id = text_id
224
290
        self.parent_id = parent_id
225
291
        self.symlink_target = None
226
 
        self.reference_revision = None
227
292
 
228
293
    def kind_character(self):
229
294
        """Return a short kind indicator useful for appending to names."""
230
295
        raise BzrError('unknown kind %r' % self.kind)
231
296
 
232
 
    known_kinds = ('file', 'directory', 'symlink')
 
297
    known_kinds = ('file', 'directory', 'symlink', 'root_directory')
233
298
 
234
299
    def _put_in_tar(self, item, tree):
235
300
        """populate item for stashing in a tar, and return the content stream.
239
304
        raise BzrError("don't know how to export {%s} of kind %r" %
240
305
                       (self.file_id, self.kind))
241
306
 
242
 
    @deprecated_method(deprecated_in((1, 6, 0)))
243
307
    def put_on_disk(self, dest, dp, tree):
244
308
        """Create a representation of self on disk in the prefix dest.
245
309
        
246
310
        This is a template method - implement _put_on_disk in subclasses.
247
311
        """
248
 
        fullpath = osutils.pathjoin(dest, dp)
 
312
        fullpath = pathjoin(dest, dp)
249
313
        self._put_on_disk(fullpath, tree)
250
 
        # mutter("  export {%s} kind %s to %s", self.file_id,
251
 
        #         self.kind, fullpath)
 
314
        mutter("  export {%s} kind %s to %s", self.file_id,
 
315
                self.kind, fullpath)
252
316
 
253
317
    def _put_on_disk(self, fullpath, tree):
254
318
        """Put this entry onto disk at fullpath, from tree tree."""
255
319
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
256
320
 
257
321
    def sorted_children(self):
258
 
        return sorted(self.children.items())
 
322
        l = self.children.items()
 
323
        l.sort()
 
324
        return l
259
325
 
260
326
    @staticmethod
261
327
    def versionable_kind(kind):
262
 
        return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
 
328
        return kind in ('file', 'directory', 'symlink')
263
329
 
264
330
    def check(self, checker, rev_id, inv, tree):
265
331
        """Check this inventory entry is intact.
275
341
        :param inv: Inventory from which the entry was loaded.
276
342
        :param tree: RevisionTree for this entry.
277
343
        """
278
 
        if self.parent_id is not None:
 
344
        if self.parent_id != None:
279
345
            if not inv.has_id(self.parent_id):
280
346
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
281
347
                        % (self.parent_id, rev_id))
310
376
            return 'added'
311
377
        elif new_entry is None:
312
378
            return 'removed'
313
 
        if old_entry.kind != new_entry.kind:
314
 
            return 'modified'
315
379
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
316
380
        if text_modified or meta_modified:
317
381
            modified = True
333
397
        return 'unchanged'
334
398
 
335
399
    def __repr__(self):
336
 
        return ("%s(%r, %r, parent_id=%r, revision=%r)"
 
400
        return ("%s(%r, %r, parent_id=%r)"
337
401
                % (self.__class__.__name__,
338
402
                   self.file_id,
339
403
                   self.name,
340
 
                   self.parent_id,
341
 
                   self.revision))
 
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)
342
448
 
343
449
    def __eq__(self, other):
344
450
        if not isinstance(other, InventoryEntry):
354
460
                and (self.kind == other.kind)
355
461
                and (self.revision == other.revision)
356
462
                and (self.executable == other.executable)
357
 
                and (self.reference_revision == other.reference_revision)
358
463
                )
359
464
 
360
465
    def __ne__(self, other):
366
471
    def _unchanged(self, previous_ie):
367
472
        """Has this entry changed relative to previous_ie.
368
473
 
369
 
        This method should be overridden in child classes.
 
474
        This method should be overriden in child classes.
370
475
        """
371
476
        compatible = True
372
477
        # different inv parent
375
480
        # renamed
376
481
        elif previous_ie.name != self.name:
377
482
            compatible = False
378
 
        elif previous_ie.kind != self.kind:
379
 
            compatible = False
380
483
        return compatible
381
484
 
382
485
    def _read_tree_state(self, path, work_tree):
396
499
 
397
500
class RootEntry(InventoryEntry):
398
501
 
399
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
400
 
                 'text_id', 'parent_id', 'children', 'executable',
401
 
                 'revision', 'symlink_target', 'reference_revision']
402
 
 
403
502
    def _check(self, checker, rev_id, tree):
404
503
        """See InventoryEntry._check"""
405
504
 
406
505
    def __init__(self, file_id):
407
506
        self.file_id = file_id
408
507
        self.children = {}
409
 
        self.kind = 'directory'
 
508
        self.kind = 'root_directory'
410
509
        self.parent_id = None
411
510
        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)
416
511
 
417
512
    def __eq__(self, other):
418
513
        if not isinstance(other, RootEntry):
425
520
class InventoryDirectory(InventoryEntry):
426
521
    """A directory in an inventory."""
427
522
 
428
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
429
 
                 'text_id', 'parent_id', 'children', 'executable',
430
 
                 'revision', 'symlink_target', 'reference_revision']
431
 
 
432
523
    def _check(self, checker, rev_id, tree):
433
524
        """See InventoryEntry._check"""
434
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
525
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
435
526
            raise BzrCheckError('directory {%s} has text in revision {%s}'
436
527
                                % (self.file_id, rev_id))
437
528
 
464
555
        """See InventoryEntry._put_on_disk."""
465
556
        os.mkdir(fullpath)
466
557
 
 
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
 
467
562
 
468
563
class InventoryFile(InventoryEntry):
469
564
    """A file in an inventory."""
470
565
 
471
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
472
 
                 'text_id', 'parent_id', 'children', 'executable',
473
 
                 'revision', 'symlink_target', 'reference_revision']
474
 
 
475
566
    def _check(self, checker, tree_revision_id, tree):
476
567
        """See InventoryEntry._check"""
477
 
        key = (self.file_id, self.revision)
478
 
        if key in checker.checked_texts:
479
 
            prev_sha = checker.checked_texts[key]
 
568
        t = (self.file_id, self.revision)
 
569
        if t in checker.checked_texts:
 
570
            prev_sha = checker.checked_texts[t]
480
571
            if prev_sha != self.text_sha1:
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))
 
572
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
 
573
                                    (self.file_id, tree_revision_id))
485
574
            else:
486
575
                checker.repeated_text_cnt += 1
487
576
                return
488
577
 
 
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
 
489
589
        mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
490
590
        checker.checked_text_cnt += 1
491
591
        # We can't check the length, because Weave doesn't store that
492
592
        # information, and the whole point of looking at the weave's
493
593
        # sha1sum is that we don't have to extract the text.
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
 
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
497
598
 
498
599
    def copy(self):
499
600
        other = InventoryFile(self.file_id, self.name, self.parent_id)
506
607
 
507
608
    def detect_changes(self, old_entry):
508
609
        """See InventoryEntry.detect_changes."""
 
610
        assert self.text_sha1 != None
 
611
        assert old_entry.text_sha1 != None
509
612
        text_modified = (self.text_sha1 != old_entry.text_sha1)
510
613
        meta_modified = (self.executable != old_entry.executable)
511
614
        return text_modified, meta_modified
513
616
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
514
617
             output_to, reverse=False):
515
618
        """See InventoryEntry._diff."""
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)
 
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
529
637
 
530
638
    def has_text(self):
531
639
        """See InventoryEntry.has_text."""
552
660
 
553
661
    def _put_on_disk(self, fullpath, tree):
554
662
        """See InventoryEntry._put_on_disk."""
555
 
        osutils.pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
 
663
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
556
664
        if tree.is_executable(self.file_id):
557
665
            os.chmod(fullpath, 0755)
558
666
 
563
671
        # in _read_tree_state
564
672
        self.executable = work_tree.is_executable(self.file_id, path=path)
565
673
 
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
 
 
575
674
    def _forget_tree_state(self):
576
675
        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)
577
684
 
578
685
    def _unchanged(self, previous_ie):
579
686
        """See InventoryEntry._unchanged."""
592
699
class InventoryLink(InventoryEntry):
593
700
    """A file in an inventory."""
594
701
 
595
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
596
 
                 'text_id', 'parent_id', 'children', 'executable',
597
 
                 'revision', 'symlink_target', 'reference_revision']
 
702
    __slots__ = ['symlink_target']
598
703
 
599
704
    def _check(self, checker, rev_id, tree):
600
705
        """See InventoryEntry._check"""
601
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
706
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
602
707
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
603
708
                    % (self.file_id, rev_id))
604
709
        if self.symlink_target is None:
623
728
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
624
729
             output_to, reverse=False):
625
730
        """See InventoryEntry._diff."""
626
 
        from bzrlib.diff import DiffSymlink
627
 
        old_target = self.symlink_target
 
731
        from_text = self.symlink_target
628
732
        if to_entry is not None:
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)
 
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
641
744
 
642
745
    def __init__(self, file_id, name, parent_id):
643
746
        super(InventoryLink, self).__init__(file_id, name, parent_id)
677
780
            compatible = False
678
781
        return compatible
679
782
 
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
 
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)
710
787
 
711
788
 
712
789
class Inventory(object):
728
805
 
729
806
    >>> inv = Inventory()
730
807
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
731
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
808
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
732
809
    >>> inv['123-123'].name
733
810
    'hello.c'
734
811
 
742
819
    May also look up by name:
743
820
 
744
821
    >>> [x[0] for x in inv.iter_entries()]
745
 
    ['', u'hello.c']
 
822
    [u'hello.c']
746
823
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
747
824
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
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)
 
825
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
752
826
    """
753
827
    def __init__(self, root_id=ROOT_ID, revision_id=None):
754
828
        """Create or read an inventory.
760
834
        The inventory is created with a default root directory, with
761
835
        an id of None.
762
836
        """
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 = {}
 
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)
768
842
        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
845
843
        self._byid = {self.root.file_id: self.root}
846
844
 
847
845
    def copy(self):
848
846
        # TODO: jam 20051218 Should copy also copy the revision_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
 
847
        other = Inventory(self.root.file_id)
854
848
        # copy recursively so we know directories will be added before
855
849
        # their children.  There are more efficient ways than this...
856
 
        for path, entry in entries:
 
850
        for path, entry in self.iter_entries():
 
851
            if entry == self.root:
 
852
                continue
857
853
            other.add(entry.copy())
858
854
        return other
859
855
 
867
863
    def iter_entries(self, from_dir=None):
868
864
        """Return (path, entry) pairs, in order by name."""
869
865
        if from_dir is None:
870
 
            if self.root is None:
871
 
                return
 
866
            assert self.root
872
867
            from_dir = self.root
873
 
            yield '', self.root
874
868
        elif isinstance(from_dir, basestring):
875
869
            from_dir = self._byid[from_dir]
876
870
            
908
902
                # if we finished all children, pop it off the stack
909
903
                stack.pop()
910
904
 
911
 
    def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None,
912
 
        yield_parents=False):
 
905
    def iter_entries_by_dir(self, from_dir=None):
913
906
        """Iterate over the entries in a directory first order.
914
907
 
915
908
        This returns all entries for a directory before returning
917
910
        lexicographically sorted order, and is a hybrid between
918
911
        depth-first and breadth-first.
919
912
 
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.
923
913
        :return: This yields (path, entry) pairs
924
914
        """
925
 
        if specific_file_ids and not isinstance(specific_file_ids, set):
926
 
            specific_file_ids = set(specific_file_ids)
927
915
        # TODO? Perhaps this should return the from_dir so that the root is
928
916
        # yielded? or maybe an option?
929
917
        if from_dir is None:
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 
 
918
            assert self.root
939
919
            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
943
920
        elif isinstance(from_dir, basestring):
944
921
            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
964
922
            
965
923
        stack = [(u'', from_dir)]
966
924
        while stack:
971
929
 
972
930
                child_relpath = cur_relpath + child_name
973
931
 
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
 
932
                yield child_relpath, child_ie
978
933
 
979
934
                if child_ie.kind == 'directory':
980
 
                    if parents is None or child_ie.file_id in parents:
981
 
                        child_dirs.append((child_relpath+'/', child_ie))
 
935
                    child_dirs.append((child_relpath+'/', child_ie))
982
936
            stack.extend(reversed(child_dirs))
983
937
 
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
 
 
988
938
    def entries(self):
989
939
        """Return list of (path, ie) for all entries except the root.
990
940
 
995
945
            kids = dir_ie.children.items()
996
946
            kids.sort()
997
947
            for name, ie in kids:
998
 
                child_path = osutils.pathjoin(dir_path, name)
 
948
                child_path = pathjoin(dir_path, name)
999
949
                accum.append((child_path, ie))
1000
950
                if ie.kind == 'directory':
1001
951
                    descend(ie, child_path)
1014
964
            kids.sort()
1015
965
 
1016
966
            for name, child_ie in kids:
1017
 
                child_path = osutils.pathjoin(parent_path, name)
 
967
                child_path = pathjoin(parent_path, name)
1018
968
                descend(child_ie, child_path)
1019
969
        descend(self.root, u'')
1020
970
        return accum
1024
974
 
1025
975
        >>> inv = Inventory()
1026
976
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1027
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
977
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1028
978
        >>> '123' in inv
1029
979
        True
1030
980
        >>> '456' in inv
1031
981
        False
1032
982
        """
1033
 
        return (file_id in self._byid)
 
983
        return file_id in self._byid
1034
984
 
1035
985
    def __getitem__(self, file_id):
1036
986
        """Return the entry for given file_id.
1037
987
 
1038
988
        >>> inv = Inventory()
1039
989
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
1040
 
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
990
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
1041
991
        >>> inv['123123'].name
1042
992
        'hello.c'
1043
993
        """
1044
994
        try:
1045
995
            return self._byid[file_id]
1046
996
        except KeyError:
1047
 
            # really we're passing an inventory, not a tree...
1048
 
            raise errors.NoSuchId(self, file_id)
 
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)
1049
1001
 
1050
1002
    def get_file_kind(self, file_id):
1051
1003
        return self._byid[file_id].kind
1053
1005
    def get_child(self, parent_id, filename):
1054
1006
        return self[parent_id].children.get(filename)
1055
1007
 
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
 
 
1066
1008
    def add(self, entry):
1067
1009
        """Add entry to inventory.
1068
1010
 
1072
1014
        Returns the new entry object.
1073
1015
        """
1074
1016
        if entry.file_id in self._byid:
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)
 
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
1093
1034
 
1094
1035
    def add_path(self, relpath, kind, file_id=None, parent_id=None):
1095
1036
        """Add entry from a path.
1098
1039
 
1099
1040
        Returns the new entry object."""
1100
1041
        
1101
 
        parts = osutils.splitpath(relpath)
 
1042
        parts = bzrlib.osutils.splitpath(relpath)
1102
1043
 
1103
1044
        if len(parts) == 0:
1104
1045
            if file_id is None:
1105
 
                file_id = generate_ids.gen_root_id()
1106
 
            self.root = InventoryDirectory(file_id, '', None)
 
1046
                file_id = bzrlib.workingtree.gen_root_id()
 
1047
            self.root = RootEntry(file_id)
1107
1048
            self._byid = {self.root.file_id: self.root}
1108
 
            return self.root
 
1049
            return
1109
1050
        else:
1110
1051
            parent_path = parts[:-1]
1111
1052
            parent_id = self.path2id(parent_path)
1112
1053
            if parent_id is None:
1113
 
                raise errors.NotVersionedError(path=parent_path)
 
1054
                raise NotVersionedError(path=parent_path)
1114
1055
        ie = make_entry(kind, parts[-1], parent_id, file_id)
1115
1056
        return self.add(ie)
1116
1057
 
1119
1060
 
1120
1061
        >>> inv = Inventory()
1121
1062
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1122
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
1063
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1123
1064
        >>> '123' in inv
1124
1065
        True
1125
1066
        >>> del inv['123']
1127
1068
        False
1128
1069
        """
1129
1070
        ie = self[file_id]
 
1071
 
 
1072
        assert ie.parent_id is None or \
 
1073
            self[ie.parent_id].children[ie.name] == ie
 
1074
        
1130
1075
        del self._byid[file_id]
1131
1076
        if ie.parent_id is not None:
1132
1077
            del self[ie.parent_id].children[ie.name]
1139
1084
        >>> i1 == i2
1140
1085
        True
1141
1086
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
1142
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
1087
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1143
1088
        >>> i1 == i2
1144
1089
        False
1145
1090
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
1146
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
1091
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1147
1092
        >>> i1 == i2
1148
1093
        True
1149
1094
        """
1150
1095
        if not isinstance(other, Inventory):
1151
1096
            return NotImplemented
1152
1097
 
 
1098
        if len(self._byid) != len(other._byid):
 
1099
            # shortcut: obviously not the same
 
1100
            return False
 
1101
 
1153
1102
        return self._byid == other._byid
1154
1103
 
1155
1104
    def __ne__(self, other):
1160
1109
 
1161
1110
    def _iter_file_id_parents(self, file_id):
1162
1111
        """Yield the parents of file_id up to the root."""
1163
 
        while file_id is not None:
 
1112
        while file_id != None:
1164
1113
            try:
1165
1114
                ie = self._byid[file_id]
1166
1115
            except KeyError:
1167
 
                raise errors.NoSuchId(tree=None, file_id=file_id)
 
1116
                raise BzrError("file_id {%s} not found in inventory" % file_id)
1168
1117
            yield ie
1169
1118
            file_id = ie.parent_id
1170
1119
 
1206
1155
 
1207
1156
        Returns None IFF the path is not found.
1208
1157
        """
1209
 
        if isinstance(name, basestring):
1210
 
            name = osutils.splitpath(name)
 
1158
        if isinstance(name, types.StringTypes):
 
1159
            name = splitpath(name)
1211
1160
 
1212
1161
        # mutter("lookup path %r" % name)
1213
1162
 
1214
1163
        parent = self.root
1215
 
        if parent is None:
1216
 
            return None
1217
1164
        for f in name:
1218
1165
            try:
1219
 
                children = getattr(parent, 'children', None)
1220
 
                if children is None:
1221
 
                    return None
1222
 
                cie = children[f]
 
1166
                cie = parent.children[f]
 
1167
                assert cie.name == f
 
1168
                assert cie.parent_id == parent.file_id
1223
1169
                parent = cie
1224
1170
            except KeyError:
1225
1171
                # or raise an error?
1231
1177
        return bool(self.path2id(names))
1232
1178
 
1233
1179
    def has_id(self, 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
 
1180
        return self._byid.has_key(file_id)
1255
1181
 
1256
1182
    def rename(self, file_id, new_parent_id, new_name):
1257
1183
        """Move a file within the inventory.
1258
1184
 
1259
1185
        This can change either the name, or the parent, or both.
1260
1186
 
1261
 
        This does not move the working file.
1262
 
        """
1263
 
        new_name = ensure_normalized_name(new_name)
 
1187
        This does not move the working file."""
1264
1188
        if not is_valid_name(new_name):
1265
1189
            raise BzrError("not an acceptable filename: %r" % new_name)
1266
1190
 
1284
1208
        file_ie.name = new_name
1285
1209
        file_ie.parent_id = new_parent_id
1286
1210
 
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
 
}
1297
1211
 
1298
1212
def make_entry(kind, name, parent_id, file_id=None):
1299
1213
    """Create an inventory entry.
1304
1218
    :param file_id: the file_id to use. if None, one will be created.
1305
1219
    """
1306
1220
    if file_id is None:
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:
 
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:
1312
1229
        raise BzrError("unknown kind %r" % kind)
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
 
1230
 
1336
1231
 
1337
1232
 
1338
1233
_NAME_RE = None