← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Martin Pool
  • Date: 2006-03-21 12:26:54 UTC
  • mto: This revision was merged to the branch mainline in revision 1621.
  • Revision ID: mbp@sourcefrog.net-20060321122654-514047ed65795a17
New developer commands 'weave-list' and 'weave-join'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
 
1
# (C) 2005 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 os.path
31
32
import re
32
33
import sys
33
 
 
34
 
from bzrlib.lazy_import import lazy_import
35
 
lazy_import(globals(), """
36
 
import collections
37
34
import tarfile
 
35
import types
38
36
 
39
37
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
 
    )
 
38
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
 
39
                            pathjoin, sha_strings)
53
40
from bzrlib.trace import mutter
 
41
from bzrlib.errors import (NotVersionedError, InvalidEntryName,
 
42
                           BzrError, BzrCheckError)
54
43
 
55
44
 
56
45
class InventoryEntry(object):
87
76
    >>> i.path2id('')
88
77
    'TREE_ROOT'
89
78
    >>> i.add(InventoryDirectory('123', 'src', ROOT_ID))
90
 
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
 
79
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT')
91
80
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
92
 
    InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
93
 
    >>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}
 
81
    InventoryFile('2323', 'hello.c', parent_id='123')
 
82
    >>> shouldbe = {0: 'src', 1: pathjoin('src','hello.c')}
94
83
    >>> for ix, j in enumerate(i.iter_entries()):
95
84
    ...   print (j[0] == shouldbe[ix], j[1])
96
85
    ... 
97
 
    (True, InventoryDirectory('TREE_ROOT', u'', parent_id=None, revision=None))
98
 
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
99
 
    (True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None))
 
86
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT'))
 
87
    (True, InventoryFile('2323', 'hello.c', parent_id='123'))
 
88
    >>> i.add(InventoryFile('2323', 'bye.c', '123'))
 
89
    Traceback (most recent call last):
 
90
    ...
 
91
    BzrError: inventory already contains entry with id {2323}
100
92
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
101
 
    InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
 
93
    InventoryFile('2324', 'bye.c', parent_id='123')
102
94
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
103
 
    InventoryDirectory('2325', 'wibble', parent_id='123', revision=None)
 
95
    InventoryDirectory('2325', 'wibble', parent_id='123')
104
96
    >>> i.path2id('src/wibble')
105
97
    '2325'
106
98
    >>> '2325' in i
107
99
    True
108
100
    >>> i.add(InventoryFile('2326', 'wibble.c', '2325'))
109
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
101
    InventoryFile('2326', 'wibble.c', parent_id='2325')
110
102
    >>> i['2326']
111
 
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
 
103
    InventoryFile('2326', 'wibble.c', parent_id='2325')
112
104
    >>> for path, entry in i.iter_entries():
113
105
    ...     print path
114
106
    ...     assert i.path2id(path)
115
107
    ... 
116
 
    <BLANKLINE>
117
108
    src
118
109
    src/bye.c
119
110
    src/hello.c
122
113
    >>> i.id2path('2326')
123
114
    'src/wibble/wibble.c'
124
115
    """
125
 
 
126
 
    # Constants returned by describe_change()
127
 
    #
128
 
    # TODO: These should probably move to some kind of FileChangeDescription 
129
 
    # class; that's like what's inside a TreeDelta but we want to be able to 
130
 
    # generate them just for one file at a time.
131
 
    RENAMED = 'renamed'
132
 
    MODIFIED_AND_RENAMED = 'modified and renamed'
133
116
    
134
 
    __slots__ = []
 
117
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
 
118
                 'text_id', 'parent_id', 'children', 'executable', 
 
119
                 'revision']
 
120
 
 
121
    def _add_text_to_weave(self, new_lines, parents, weave_store, transaction):
 
122
        versionedfile = weave_store.get_weave_or_empty(self.file_id,
 
123
                                                       transaction)
 
124
        versionedfile.add_lines(self.revision, parents, new_lines)
135
125
 
136
126
    def detect_changes(self, old_entry):
137
127
        """Return a (text_modified, meta_modified) from this to old_entry.
166
156
                            versioned_file_store,
167
157
                            transaction,
168
158
                            entry_vf=None):
169
 
        """Return the revisions and entries that directly precede this.
 
159
        """Return the revisions and entries that directly preceed this.
170
160
 
171
161
        Returned as a map from revision to inventory entry.
172
162
 
181
171
        :param entry_vf: The entry versioned file, if its already available.
182
172
        """
183
173
        def get_ancestors(weave, entry):
184
 
            return set(weave.get_ancestry(entry.revision, topo_sorted=False))
 
174
            return set(weave.get_ancestry(entry.revision))
185
175
        # revision:ie mapping for each ie found in previous_inventories.
186
176
        candidates = {}
187
177
        # revision:ie mapping with one revision for each head.
193
183
            if self.file_id in inv:
194
184
                ie = inv[self.file_id]
195
185
                assert ie.file_id == self.file_id
196
 
                if ie.kind != self.kind:
197
 
                    # Can't be a candidate if the kind has changed.
198
 
                    continue
199
186
                if ie.revision in candidates:
200
187
                    # same revision value in two different inventories:
201
188
                    # correct possible inconsistencies:
253
240
 
254
241
    def get_tar_item(self, root, dp, now, tree):
255
242
        """Get a tarfile item and a file stream for its content."""
256
 
        item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
 
243
        item = tarfile.TarInfo(pathjoin(root, dp))
257
244
        # TODO: would be cool to actually set it to the timestamp of the
258
245
        # revision it was last changed
259
246
        item.mtime = now
288
275
        """
289
276
        assert isinstance(name, basestring), name
290
277
        if '/' in name or '\\' in name:
291
 
            raise errors.InvalidEntryName(name=name)
 
278
            raise InvalidEntryName(name=name)
292
279
        self.executable = False
293
280
        self.revision = None
294
281
        self.text_sha1 = None
295
282
        self.text_size = None
296
283
        self.file_id = file_id
297
 
        assert isinstance(file_id, (str, None.__class__)), \
298
 
            'bad type %r for %r' % (type(file_id), file_id)
299
284
        self.name = name
300
285
        self.text_id = text_id
301
286
        self.parent_id = parent_id
302
287
        self.symlink_target = None
303
 
        self.reference_revision = None
304
288
 
305
289
    def kind_character(self):
306
290
        """Return a short kind indicator useful for appending to names."""
307
291
        raise BzrError('unknown kind %r' % self.kind)
308
292
 
309
 
    known_kinds = ('file', 'directory', 'symlink')
 
293
    known_kinds = ('file', 'directory', 'symlink', 'root_directory')
310
294
 
311
295
    def _put_in_tar(self, item, tree):
312
296
        """populate item for stashing in a tar, and return the content stream.
321
305
        
322
306
        This is a template method - implement _put_on_disk in subclasses.
323
307
        """
324
 
        fullpath = osutils.pathjoin(dest, dp)
 
308
        fullpath = pathjoin(dest, dp)
325
309
        self._put_on_disk(fullpath, tree)
326
 
        # mutter("  export {%s} kind %s to %s", self.file_id,
327
 
        #         self.kind, fullpath)
 
310
        mutter("  export {%s} kind %s to %s", self.file_id,
 
311
                self.kind, fullpath)
328
312
 
329
313
    def _put_on_disk(self, fullpath, tree):
330
314
        """Put this entry onto disk at fullpath, from tree tree."""
331
315
        raise BzrError("don't know how to export {%s} of kind %r" % (self.file_id, self.kind))
332
316
 
333
317
    def sorted_children(self):
334
 
        return sorted(self.children.items())
 
318
        l = self.children.items()
 
319
        l.sort()
 
320
        return l
335
321
 
336
322
    @staticmethod
337
323
    def versionable_kind(kind):
338
 
        return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
 
324
        return kind in ('file', 'directory', 'symlink')
339
325
 
340
326
    def check(self, checker, rev_id, inv, tree):
341
327
        """Check this inventory entry is intact.
351
337
        :param inv: Inventory from which the entry was loaded.
352
338
        :param tree: RevisionTree for this entry.
353
339
        """
354
 
        if self.parent_id is not None:
 
340
        if self.parent_id != None:
355
341
            if not inv.has_id(self.parent_id):
356
342
                raise BzrCheckError('missing parent {%s} in inventory for revision {%s}'
357
343
                        % (self.parent_id, rev_id))
362
348
        raise BzrCheckError('unknown entry kind %r in revision {%s}' % 
363
349
                            (self.kind, rev_id))
364
350
 
 
351
 
365
352
    def copy(self):
366
353
        """Clone this inventory entry."""
367
354
        raise NotImplementedError
368
355
 
369
 
    @staticmethod
370
 
    def describe_change(old_entry, new_entry):
371
 
        """Describe the change between old_entry and this.
372
 
        
373
 
        This smells of being an InterInventoryEntry situation, but as its
374
 
        the first one, we're making it a static method for now.
375
 
 
376
 
        An entry with a different parent, or different name is considered 
377
 
        to be renamed. Reparenting is an internal detail.
378
 
        Note that renaming the parent does not trigger a rename for the
379
 
        child entry itself.
380
 
        """
381
 
        # TODO: Perhaps return an object rather than just a string
382
 
        if old_entry is new_entry:
383
 
            # also the case of both being None
384
 
            return 'unchanged'
385
 
        elif old_entry is None:
 
356
    def _get_snapshot_change(self, previous_entries):
 
357
        if len(previous_entries) > 1:
 
358
            return 'merged'
 
359
        elif len(previous_entries) == 0:
386
360
            return 'added'
387
 
        elif new_entry is None:
388
 
            return 'removed'
389
 
        if old_entry.kind != new_entry.kind:
390
 
            return 'modified'
391
 
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
392
 
        if text_modified or meta_modified:
393
 
            modified = True
394
 
        else:
395
 
            modified = False
396
 
        # TODO 20060511 (mbp, rbc) factor out 'detect_rename' here.
397
 
        if old_entry.parent_id != new_entry.parent_id:
398
 
            renamed = True
399
 
        elif old_entry.name != new_entry.name:
400
 
            renamed = True
401
 
        else:
402
 
            renamed = False
403
 
        if renamed and not modified:
404
 
            return InventoryEntry.RENAMED
405
 
        if modified and not renamed:
406
 
            return 'modified'
407
 
        if modified and renamed:
408
 
            return InventoryEntry.MODIFIED_AND_RENAMED
409
 
        return 'unchanged'
 
361
        else:
 
362
            return 'modified/renamed/reparented'
410
363
 
411
364
    def __repr__(self):
412
 
        return ("%s(%r, %r, parent_id=%r, revision=%r)"
 
365
        return ("%s(%r, %r, parent_id=%r)"
413
366
                % (self.__class__.__name__,
414
367
                   self.file_id,
415
368
                   self.name,
416
 
                   self.parent_id,
417
 
                   self.revision))
 
369
                   self.parent_id))
418
370
 
419
371
    def snapshot(self, revision, path, previous_entries,
420
 
                 work_tree, commit_builder):
 
372
                 work_tree, weave_store, transaction):
421
373
        """Make a snapshot of this entry which may or may not have changed.
422
374
        
423
375
        This means that all its fields are populated, that it has its
424
376
        text stored in the text store or weave.
425
377
        """
426
 
        # mutter('new parents of %s are %r', path, previous_entries)
 
378
        mutter('new parents of %s are %r', path, previous_entries)
427
379
        self._read_tree_state(path, work_tree)
428
 
        # TODO: Where should we determine whether to reuse a
429
 
        # previous revision id or create a new revision? 20060606
430
380
        if len(previous_entries) == 1:
431
381
            # cannot be unchanged unless there is only one parent file rev.
432
382
            parent_ie = previous_entries.values()[0]
433
383
            if self._unchanged(parent_ie):
434
 
                # mutter("found unchanged entry")
 
384
                mutter("found unchanged entry")
435
385
                self.revision = parent_ie.revision
436
386
                return "unchanged"
437
 
        return self._snapshot_into_revision(revision, previous_entries, 
438
 
                                            work_tree, commit_builder)
439
 
 
440
 
    def _snapshot_into_revision(self, revision, previous_entries, work_tree,
441
 
                                commit_builder):
442
 
        """Record this revision unconditionally into a store.
443
 
 
444
 
        The entry's last-changed revision property (`revision`) is updated to 
445
 
        that of the new revision.
446
 
        
447
 
        :param revision: id of the new revision that is being recorded.
448
 
 
449
 
        :returns: String description of the commit (e.g. "merged", "modified"), etc.
450
 
        """
451
 
        # mutter('new revision {%s} for {%s}', revision, self.file_id)
 
387
        return self.snapshot_revision(revision, previous_entries, 
 
388
                                      work_tree, weave_store, transaction)
 
389
 
 
390
    def snapshot_revision(self, revision, previous_entries, work_tree,
 
391
                          weave_store, transaction):
 
392
        """Record this revision unconditionally."""
 
393
        mutter('new revision for {%s}', self.file_id)
452
394
        self.revision = revision
453
 
        self._snapshot_text(previous_entries, work_tree, commit_builder)
 
395
        change = self._get_snapshot_change(previous_entries)
 
396
        self._snapshot_text(previous_entries, work_tree, weave_store,
 
397
                            transaction)
 
398
        return change
454
399
 
455
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder): 
 
400
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction): 
456
401
        """Record the 'text' of this entry, whatever form that takes.
457
402
        
458
403
        This default implementation simply adds an empty text.
459
404
        """
460
 
        raise NotImplementedError(self._snapshot_text)
 
405
        mutter('storing file {%s} in revision {%s}',
 
406
               self.file_id, self.revision)
 
407
        self._add_text_to_weave([], file_parents.keys(), weave_store, transaction)
461
408
 
462
409
    def __eq__(self, other):
463
410
        if not isinstance(other, InventoryEntry):
473
420
                and (self.kind == other.kind)
474
421
                and (self.revision == other.revision)
475
422
                and (self.executable == other.executable)
476
 
                and (self.reference_revision == other.reference_revision)
477
423
                )
478
424
 
479
425
    def __ne__(self, other):
485
431
    def _unchanged(self, previous_ie):
486
432
        """Has this entry changed relative to previous_ie.
487
433
 
488
 
        This method should be overridden in child classes.
 
434
        This method should be overriden in child classes.
489
435
        """
490
436
        compatible = True
491
437
        # different inv parent
494
440
        # renamed
495
441
        elif previous_ie.name != self.name:
496
442
            compatible = False
497
 
        elif previous_ie.kind != self.kind:
498
 
            compatible = False
499
443
        return compatible
500
444
 
501
445
    def _read_tree_state(self, path, work_tree):
515
459
 
516
460
class RootEntry(InventoryEntry):
517
461
 
518
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
519
 
                 'text_id', 'parent_id', 'children', 'executable',
520
 
                 'revision', 'symlink_target', 'reference_revision']
521
 
 
522
462
    def _check(self, checker, rev_id, tree):
523
463
        """See InventoryEntry._check"""
524
464
 
525
465
    def __init__(self, file_id):
526
466
        self.file_id = file_id
527
467
        self.children = {}
528
 
        self.kind = 'directory'
 
468
        self.kind = 'root_directory'
529
469
        self.parent_id = None
530
470
        self.name = u''
531
 
        self.revision = None
532
 
        symbol_versioning.warn('RootEntry is deprecated as of bzr 0.10.'
533
 
                               '  Please use InventoryDirectory instead.',
534
 
                               DeprecationWarning, stacklevel=2)
535
471
 
536
472
    def __eq__(self, other):
537
473
        if not isinstance(other, RootEntry):
544
480
class InventoryDirectory(InventoryEntry):
545
481
    """A directory in an inventory."""
546
482
 
547
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
548
 
                 'text_id', 'parent_id', 'children', 'executable',
549
 
                 'revision', 'symlink_target', 'reference_revision']
550
 
 
551
483
    def _check(self, checker, rev_id, tree):
552
484
        """See InventoryEntry._check"""
553
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
485
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
554
486
            raise BzrCheckError('directory {%s} has text in revision {%s}'
555
487
                                % (self.file_id, rev_id))
556
488
 
583
515
        """See InventoryEntry._put_on_disk."""
584
516
        os.mkdir(fullpath)
585
517
 
586
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
587
 
        """See InventoryEntry._snapshot_text."""
588
 
        commit_builder.modified_directory(self.file_id, file_parents)
589
 
 
590
518
 
591
519
class InventoryFile(InventoryEntry):
592
520
    """A file in an inventory."""
593
521
 
594
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
595
 
                 'text_id', 'parent_id', 'children', 'executable',
596
 
                 'revision', 'symlink_target', 'reference_revision']
597
 
 
598
522
    def _check(self, checker, tree_revision_id, tree):
599
523
        """See InventoryEntry._check"""
600
524
        t = (self.file_id, self.revision)
639
563
 
640
564
    def detect_changes(self, old_entry):
641
565
        """See InventoryEntry.detect_changes."""
642
 
        assert self.text_sha1 is not None
643
 
        assert old_entry.text_sha1 is not None
 
566
        assert self.text_sha1 != None
 
567
        assert old_entry.text_sha1 != None
644
568
        text_modified = (self.text_sha1 != old_entry.text_sha1)
645
569
        meta_modified = (self.executable != old_entry.executable)
646
570
        return text_modified, meta_modified
648
572
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
649
573
             output_to, reverse=False):
650
574
        """See InventoryEntry._diff."""
651
 
        try:
652
 
            from_text = tree.get_file(self.file_id).readlines()
653
 
            if to_entry:
654
 
                to_text = to_tree.get_file(to_entry.file_id).readlines()
655
 
            else:
656
 
                to_text = []
657
 
            if not reverse:
658
 
                text_diff(from_label, from_text,
659
 
                          to_label, to_text, output_to)
660
 
            else:
661
 
                text_diff(to_label, to_text,
662
 
                          from_label, from_text, output_to)
663
 
        except errors.BinaryFile:
664
 
            if reverse:
665
 
                label_pair = (to_label, from_label)
666
 
            else:
667
 
                label_pair = (from_label, to_label)
668
 
            print >> output_to, "Binary files %s and %s differ" % label_pair
 
575
        from_text = tree.get_file(self.file_id).readlines()
 
576
        if to_entry:
 
577
            to_text = to_tree.get_file(to_entry.file_id).readlines()
 
578
        else:
 
579
            to_text = []
 
580
        if not reverse:
 
581
            text_diff(from_label, from_text,
 
582
                      to_label, to_text, output_to)
 
583
        else:
 
584
            text_diff(to_label, to_text,
 
585
                      from_label, from_text, output_to)
669
586
 
670
587
    def has_text(self):
671
588
        """See InventoryEntry.has_text."""
692
609
 
693
610
    def _put_on_disk(self, fullpath, tree):
694
611
        """See InventoryEntry._put_on_disk."""
695
 
        osutils.pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
 
612
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
696
613
        if tree.is_executable(self.file_id):
697
614
            os.chmod(fullpath, 0755)
698
615
 
699
616
    def _read_tree_state(self, path, work_tree):
700
617
        """See InventoryEntry._read_tree_state."""
701
 
        self.text_sha1 = work_tree.get_file_sha1(self.file_id, path=path)
702
 
        # FIXME: 20050930 probe for the text size when getting sha1
703
 
        # in _read_tree_state
704
 
        self.executable = work_tree.is_executable(self.file_id, path=path)
705
 
 
706
 
    def __repr__(self):
707
 
        return ("%s(%r, %r, parent_id=%r, sha1=%r, len=%s)"
708
 
                % (self.__class__.__name__,
709
 
                   self.file_id,
710
 
                   self.name,
711
 
                   self.parent_id,
712
 
                   self.text_sha1,
713
 
                   self.text_size))
 
618
        self.text_sha1 = work_tree.get_file_sha1(self.file_id)
 
619
        self.executable = work_tree.is_executable(self.file_id)
714
620
 
715
621
    def _forget_tree_state(self):
716
622
        self.text_sha1 = None
 
623
        self.executable = None
717
624
 
718
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
 
625
    def _snapshot_text(self, file_parents, work_tree, weave_store, transaction):
719
626
        """See InventoryEntry._snapshot_text."""
720
 
        def get_content_byte_lines():
721
 
            return work_tree.get_file(self.file_id).readlines()
722
 
        self.text_sha1, self.text_size = commit_builder.modified_file_text(
723
 
            self.file_id, file_parents, get_content_byte_lines, self.text_sha1, self.text_size)
 
627
        mutter('storing file {%s} in revision {%s}',
 
628
               self.file_id, self.revision)
 
629
        # special case to avoid diffing on renames or 
 
630
        # reparenting
 
631
        if (len(file_parents) == 1
 
632
            and self.text_sha1 == file_parents.values()[0].text_sha1
 
633
            and self.text_size == file_parents.values()[0].text_size):
 
634
            previous_ie = file_parents.values()[0]
 
635
            versionedfile = weave_store.get_weave(self.file_id, transaction)
 
636
            versionedfile.clone_text(self.revision, previous_ie.revision, file_parents.keys())
 
637
        else:
 
638
            new_lines = work_tree.get_file(self.file_id).readlines()
 
639
            self._add_text_to_weave(new_lines, file_parents.keys(), weave_store,
 
640
                                    transaction)
 
641
            self.text_sha1 = sha_strings(new_lines)
 
642
            self.text_size = sum(map(len, new_lines))
 
643
 
724
644
 
725
645
    def _unchanged(self, previous_ie):
726
646
        """See InventoryEntry._unchanged."""
739
659
class InventoryLink(InventoryEntry):
740
660
    """A file in an inventory."""
741
661
 
742
 
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
743
 
                 'text_id', 'parent_id', 'children', 'executable',
744
 
                 'revision', 'symlink_target', 'reference_revision']
 
662
    __slots__ = ['symlink_target']
745
663
 
746
664
    def _check(self, checker, rev_id, tree):
747
665
        """See InventoryEntry._check"""
748
 
        if self.text_sha1 is not None or self.text_size is not None or self.text_id is not None:
 
666
        if self.text_sha1 != None or self.text_size != None or self.text_id != None:
749
667
            raise BzrCheckError('symlink {%s} has text in revision {%s}'
750
668
                    % (self.file_id, rev_id))
751
 
        if self.symlink_target is None:
 
669
        if self.symlink_target == None:
752
670
            raise BzrCheckError('symlink {%s} has no target in revision {%s}'
753
671
                    % (self.file_id, rev_id))
754
672
 
822
740
            compatible = False
823
741
        return compatible
824
742
 
825
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
826
 
        """See InventoryEntry._snapshot_text."""
827
 
        commit_builder.modified_link(
828
 
            self.file_id, file_parents, self.symlink_target)
829
 
 
830
 
 
831
 
class TreeReference(InventoryEntry):
832
 
    
833
 
    kind = 'tree-reference'
834
 
    
835
 
    def __init__(self, file_id, name, parent_id, revision=None,
836
 
                 reference_revision=None):
837
 
        InventoryEntry.__init__(self, file_id, name, parent_id)
838
 
        self.revision = revision
839
 
        self.reference_revision = reference_revision
840
 
 
841
 
    def copy(self):
842
 
        return TreeReference(self.file_id, self.name, self.parent_id,
843
 
                             self.revision, self.reference_revision)
844
 
 
845
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
846
 
        commit_builder.modified_reference(self.file_id, file_parents)
847
 
 
848
 
    def _read_tree_state(self, path, work_tree):
849
 
        """Populate fields in the inventory entry from the given tree.
850
 
        """
851
 
        self.reference_revision = work_tree.get_reference_revision(
852
 
            self.file_id, path)
853
 
 
854
 
    def _forget_tree_state(self):
855
 
        self.reference_revision = None 
856
 
 
857
743
 
858
744
class Inventory(object):
859
745
    """Inventory of versioned files in a tree.
874
760
 
875
761
    >>> inv = Inventory()
876
762
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
877
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
763
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT')
878
764
    >>> inv['123-123'].name
879
765
    'hello.c'
880
766
 
888
774
    May also look up by name:
889
775
 
890
776
    >>> [x[0] for x in inv.iter_entries()]
891
 
    ['', u'hello.c']
 
777
    ['hello.c']
892
778
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
893
779
    >>> inv.add(InventoryFile('123-123', 'hello.c', ROOT_ID))
894
 
    Traceback (most recent call last):
895
 
    BzrError: parent_id {TREE_ROOT} not in inventory
896
 
    >>> inv.add(InventoryFile('123-123', 'hello.c', 'TREE_ROOT-12345678-12345678'))
897
 
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678', sha1=None, len=None)
 
780
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678')
898
781
    """
899
 
    def __init__(self, root_id=ROOT_ID, revision_id=None):
 
782
    def __init__(self, root_id=ROOT_ID):
900
783
        """Create or read an inventory.
901
784
 
902
785
        If a working directory is specified, the inventory is read
906
789
        The inventory is created with a default root directory, with
907
790
        an id of None.
908
791
        """
909
 
        if root_id is not None:
910
 
            assert root_id.__class__ == str
911
 
            self._set_root(InventoryDirectory(root_id, u'', None))
912
 
        else:
913
 
            self.root = None
914
 
            self._byid = {}
915
 
        self.revision_id = revision_id
916
 
 
917
 
    def _set_root(self, ie):
918
 
        self.root = ie
 
792
        # We are letting Branch.create() create a unique inventory
 
793
        # root id. Rather than generating a random one here.
 
794
        #if root_id is None:
 
795
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
 
796
        self.root = RootEntry(root_id)
919
797
        self._byid = {self.root.file_id: self.root}
920
798
 
 
799
 
921
800
    def copy(self):
922
 
        # TODO: jam 20051218 Should copy also copy the revision_id?
923
 
        entries = self.iter_entries()
924
 
        other = Inventory(entries.next()[1].file_id)
 
801
        other = Inventory(self.root.file_id)
925
802
        # copy recursively so we know directories will be added before
926
803
        # their children.  There are more efficient ways than this...
927
 
        for path, entry in entries():
 
804
        for path, entry in self.iter_entries():
 
805
            if entry == self.root:
 
806
                continue
928
807
            other.add(entry.copy())
929
808
        return other
930
809
 
 
810
 
931
811
    def __iter__(self):
932
812
        return iter(self._byid)
933
813
 
 
814
 
934
815
    def __len__(self):
935
816
        """Returns number of entries."""
936
817
        return len(self._byid)
937
818
 
 
819
 
938
820
    def iter_entries(self, from_dir=None):
939
821
        """Return (path, entry) pairs, in order by name."""
940
 
        if from_dir is None:
941
 
            if self.root is None:
942
 
                return
943
 
            from_dir = self.root
944
 
            yield '', self.root
945
 
        elif isinstance(from_dir, basestring):
946
 
            from_dir = self._byid[from_dir]
947
 
            
948
 
        # unrolling the recursive called changed the time from
949
 
        # 440ms/663ms (inline/total) to 116ms/116ms
950
 
        children = from_dir.children.items()
951
 
        children.sort()
952
 
        children = collections.deque(children)
953
 
        stack = [(u'', children)]
954
 
        while stack:
955
 
            from_dir_relpath, children = stack[-1]
956
 
 
957
 
            while children:
958
 
                name, ie = children.popleft()
959
 
 
960
 
                # we know that from_dir_relpath never ends in a slash
961
 
                # and 'f' doesn't begin with one, we can do a string op, rather
962
 
                # than the checks of pathjoin(), though this means that all paths
963
 
                # start with a slash
964
 
                path = from_dir_relpath + '/' + name
965
 
 
966
 
                yield path[1:], ie
967
 
 
968
 
                if ie.kind != 'directory':
969
 
                    continue
970
 
 
971
 
                # But do this child first
972
 
                new_children = ie.children.items()
973
 
                new_children.sort()
974
 
                new_children = collections.deque(new_children)
975
 
                stack.append((path, new_children))
976
 
                # Break out of inner loop, so that we start outer loop with child
977
 
                break
978
 
            else:
979
 
                # if we finished all children, pop it off the stack
980
 
                stack.pop()
981
 
 
982
 
    def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None):
983
 
        """Iterate over the entries in a directory first order.
984
 
 
985
 
        This returns all entries for a directory before returning
986
 
        the entries for children of a directory. This is not
987
 
        lexicographically sorted order, and is a hybrid between
988
 
        depth-first and breadth-first.
989
 
 
990
 
        :return: This yields (path, entry) pairs
991
 
        """
992
 
        if specific_file_ids:
993
 
            safe = osutils.safe_file_id
994
 
            specific_file_ids = set(safe(fid) for fid in specific_file_ids)
995
 
        # TODO? Perhaps this should return the from_dir so that the root is
996
 
        # yielded? or maybe an option?
997
 
        if from_dir is None:
998
 
            if self.root is None:
999
 
                return
1000
 
            # Optimize a common case
1001
 
            if specific_file_ids is not None and len(specific_file_ids) == 1:
1002
 
                file_id = list(specific_file_ids)[0]
1003
 
                if file_id in self:
1004
 
                    yield self.id2path(file_id), self[file_id]
1005
 
                return 
1006
 
            from_dir = self.root
1007
 
            if (specific_file_ids is None or 
1008
 
                self.root.file_id in specific_file_ids):
1009
 
                yield u'', self.root
1010
 
        elif isinstance(from_dir, basestring):
1011
 
            from_dir = self._byid[from_dir]
1012
 
 
1013
 
        if specific_file_ids is not None:
1014
 
            # TODO: jam 20070302 This could really be done as a loop rather
1015
 
            #       than a bunch of recursive calls.
1016
 
            parents = set()
1017
 
            byid = self._byid
1018
 
            def add_ancestors(file_id):
1019
 
                if file_id not in byid:
1020
 
                    return
1021
 
                parent_id = byid[file_id].parent_id
1022
 
                if parent_id is None:
1023
 
                    return
1024
 
                if parent_id not in parents:
1025
 
                    parents.add(parent_id)
1026
 
                    add_ancestors(parent_id)
1027
 
            for file_id in specific_file_ids:
1028
 
                add_ancestors(file_id)
1029
 
        else:
1030
 
            parents = None
1031
 
            
1032
 
        stack = [(u'', from_dir)]
1033
 
        while stack:
1034
 
            cur_relpath, cur_dir = stack.pop()
1035
 
 
1036
 
            child_dirs = []
1037
 
            for child_name, child_ie in sorted(cur_dir.children.iteritems()):
1038
 
 
1039
 
                child_relpath = cur_relpath + child_name
1040
 
 
1041
 
                if (specific_file_ids is None or 
1042
 
                    child_ie.file_id in specific_file_ids):
1043
 
                    yield child_relpath, child_ie
1044
 
 
1045
 
                if child_ie.kind == 'directory':
1046
 
                    if parents is None or child_ie.file_id in parents:
1047
 
                        child_dirs.append((child_relpath+'/', child_ie))
1048
 
            stack.extend(reversed(child_dirs))
1049
 
 
1050
 
    def make_entry(self, kind, name, parent_id, file_id=None):
1051
 
        """Simple thunk to bzrlib.inventory.make_entry."""
1052
 
        return make_entry(kind, name, parent_id, file_id)
 
822
        if from_dir == None:
 
823
            assert self.root
 
824
            from_dir = self.root
 
825
        elif isinstance(from_dir, basestring):
 
826
            from_dir = self._byid[from_dir]
 
827
            
 
828
        kids = from_dir.children.items()
 
829
        kids.sort()
 
830
        for name, ie in kids:
 
831
            yield name, ie
 
832
            if ie.kind == 'directory':
 
833
                for cn, cie in self.iter_entries(from_dir=ie.file_id):
 
834
                    yield pathjoin(name, cn), cie
 
835
 
1053
836
 
1054
837
    def entries(self):
1055
838
        """Return list of (path, ie) for all entries except the root.
1061
844
            kids = dir_ie.children.items()
1062
845
            kids.sort()
1063
846
            for name, ie in kids:
1064
 
                child_path = osutils.pathjoin(dir_path, name)
 
847
                child_path = pathjoin(dir_path, name)
1065
848
                accum.append((child_path, ie))
1066
849
                if ie.kind == 'directory':
1067
850
                    descend(ie, child_path)
1069
852
        descend(self.root, u'')
1070
853
        return accum
1071
854
 
 
855
 
1072
856
    def directories(self):
1073
857
        """Return (path, entry) pairs for all directories, including the root.
1074
858
        """
1080
864
            kids.sort()
1081
865
 
1082
866
            for name, child_ie in kids:
1083
 
                child_path = osutils.pathjoin(parent_path, name)
 
867
                child_path = pathjoin(parent_path, name)
1084
868
                descend(child_ie, child_path)
1085
869
        descend(self.root, u'')
1086
870
        return accum
1087
871
        
 
872
 
 
873
 
1088
874
    def __contains__(self, file_id):
1089
875
        """True if this entry contains a file with given id.
1090
876
 
1091
877
        >>> inv = Inventory()
1092
878
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1093
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
879
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1094
880
        >>> '123' in inv
1095
881
        True
1096
882
        >>> '456' in inv
1097
883
        False
1098
884
        """
1099
 
        file_id = osutils.safe_file_id(file_id)
1100
 
        return (file_id in self._byid)
 
885
        return file_id in self._byid
 
886
 
1101
887
 
1102
888
    def __getitem__(self, file_id):
1103
889
        """Return the entry for given file_id.
1104
890
 
1105
891
        >>> inv = Inventory()
1106
892
        >>> inv.add(InventoryFile('123123', 'hello.c', ROOT_ID))
1107
 
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
893
        InventoryFile('123123', 'hello.c', parent_id='TREE_ROOT')
1108
894
        >>> inv['123123'].name
1109
895
        'hello.c'
1110
896
        """
1111
 
        file_id = osutils.safe_file_id(file_id)
1112
897
        try:
1113
898
            return self._byid[file_id]
1114
899
        except KeyError:
1115
 
            # really we're passing an inventory, not a tree...
1116
 
            raise errors.NoSuchId(self, file_id)
 
900
            if file_id == None:
 
901
                raise BzrError("can't look up file_id None")
 
902
            else:
 
903
                raise BzrError("file_id {%s} not in inventory" % file_id)
 
904
 
1117
905
 
1118
906
    def get_file_kind(self, file_id):
1119
 
        file_id = osutils.safe_file_id(file_id)
1120
907
        return self._byid[file_id].kind
1121
908
 
1122
909
    def get_child(self, parent_id, filename):
1123
 
        parent_id = osutils.safe_file_id(parent_id)
1124
910
        return self[parent_id].children.get(filename)
1125
911
 
1126
 
    def _add_child(self, entry):
1127
 
        """Add an entry to the inventory, without adding it to its parent"""
1128
 
        if entry.file_id in self._byid:
1129
 
            raise BzrError("inventory already contains entry with id {%s}" %
1130
 
                           entry.file_id)
1131
 
        self._byid[entry.file_id] = entry
1132
 
        for child in getattr(entry, 'children', {}).itervalues():
1133
 
            self._add_child(child)
1134
 
        return entry
1135
912
 
1136
913
    def add(self, entry):
1137
914
        """Add entry to inventory.
1142
919
        Returns the new entry object.
1143
920
        """
1144
921
        if entry.file_id in self._byid:
1145
 
            raise errors.DuplicateFileId(entry.file_id,
1146
 
                                         self._byid[entry.file_id])
1147
 
 
1148
 
        if entry.parent_id is None:
1149
 
            assert self.root is None and len(self._byid) == 0
1150
 
            self.root = entry
1151
 
        else:
1152
 
            try:
1153
 
                parent = self._byid[entry.parent_id]
1154
 
            except KeyError:
1155
 
                raise BzrError("parent_id {%s} not in inventory" %
1156
 
                               entry.parent_id)
1157
 
 
1158
 
            if entry.name in parent.children:
1159
 
                raise BzrError("%s is already versioned" %
1160
 
                        osutils.pathjoin(self.id2path(parent.file_id),
1161
 
                        entry.name).encode('utf-8'))
1162
 
            parent.children[entry.name] = entry
1163
 
        return self._add_child(entry)
1164
 
 
1165
 
    def add_path(self, relpath, kind, file_id=None, parent_id=None):
 
922
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
 
923
 
 
924
        if entry.parent_id == ROOT_ID or entry.parent_id is None:
 
925
            entry.parent_id = self.root.file_id
 
926
 
 
927
        try:
 
928
            parent = self._byid[entry.parent_id]
 
929
        except KeyError:
 
930
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
 
931
 
 
932
        if parent.children.has_key(entry.name):
 
933
            raise BzrError("%s is already versioned" %
 
934
                    pathjoin(self.id2path(parent.file_id), entry.name))
 
935
 
 
936
        self._byid[entry.file_id] = entry
 
937
        parent.children[entry.name] = entry
 
938
        return entry
 
939
 
 
940
 
 
941
    def add_path(self, relpath, kind, file_id=None):
1166
942
        """Add entry from a path.
1167
943
 
1168
944
        The immediate parent must already be versioned.
1169
945
 
1170
946
        Returns the new entry object."""
 
947
        from bzrlib.workingtree import gen_file_id
1171
948
        
1172
 
        parts = osutils.splitpath(relpath)
 
949
        parts = bzrlib.osutils.splitpath(relpath)
 
950
 
 
951
        if file_id == None:
 
952
            file_id = gen_file_id(relpath)
1173
953
 
1174
954
        if len(parts) == 0:
1175
 
            if file_id is None:
1176
 
                file_id = generate_ids.gen_root_id()
1177
 
            else:
1178
 
                file_id = osutils.safe_file_id(file_id)
1179
 
            self.root = InventoryDirectory(file_id, '', None)
 
955
            self.root = RootEntry(file_id)
1180
956
            self._byid = {self.root.file_id: self.root}
1181
 
            return self.root
 
957
            return
1182
958
        else:
1183
959
            parent_path = parts[:-1]
1184
960
            parent_id = self.path2id(parent_path)
1185
 
            if parent_id is None:
1186
 
                raise errors.NotVersionedError(path=parent_path)
1187
 
        ie = make_entry(kind, parts[-1], parent_id, file_id)
 
961
            if parent_id == None:
 
962
                raise NotVersionedError(path=parent_path)
 
963
        if kind == 'directory':
 
964
            ie = InventoryDirectory(file_id, parts[-1], parent_id)
 
965
        elif kind == 'file':
 
966
            ie = InventoryFile(file_id, parts[-1], parent_id)
 
967
        elif kind == 'symlink':
 
968
            ie = InventoryLink(file_id, parts[-1], parent_id)
 
969
        else:
 
970
            raise BzrError("unknown kind %r" % kind)
1188
971
        return self.add(ie)
1189
972
 
 
973
 
1190
974
    def __delitem__(self, file_id):
1191
975
        """Remove entry by id.
1192
976
 
1193
977
        >>> inv = Inventory()
1194
978
        >>> inv.add(InventoryFile('123', 'foo.c', ROOT_ID))
1195
 
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT', sha1=None, len=None)
 
979
        InventoryFile('123', 'foo.c', parent_id='TREE_ROOT')
1196
980
        >>> '123' in inv
1197
981
        True
1198
982
        >>> del inv['123']
1199
983
        >>> '123' in inv
1200
984
        False
1201
985
        """
1202
 
        file_id = osutils.safe_file_id(file_id)
1203
986
        ie = self[file_id]
1204
987
 
1205
988
        assert ie.parent_id is None or \
1209
992
        if ie.parent_id is not None:
1210
993
            del self[ie.parent_id].children[ie.name]
1211
994
 
 
995
 
1212
996
    def __eq__(self, other):
1213
997
        """Compare two sets by comparing their contents.
1214
998
 
1217
1001
        >>> i1 == i2
1218
1002
        True
1219
1003
        >>> i1.add(InventoryFile('123', 'foo', ROOT_ID))
1220
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
1004
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1221
1005
        >>> i1 == i2
1222
1006
        False
1223
1007
        >>> i2.add(InventoryFile('123', 'foo', ROOT_ID))
1224
 
        InventoryFile('123', 'foo', parent_id='TREE_ROOT', sha1=None, len=None)
 
1008
        InventoryFile('123', 'foo', parent_id='TREE_ROOT')
1225
1009
        >>> i1 == i2
1226
1010
        True
1227
1011
        """
1228
1012
        if not isinstance(other, Inventory):
1229
1013
            return NotImplemented
1230
1014
 
 
1015
        if len(self._byid) != len(other._byid):
 
1016
            # shortcut: obviously not the same
 
1017
            return False
 
1018
 
1231
1019
        return self._byid == other._byid
1232
1020
 
 
1021
 
1233
1022
    def __ne__(self, other):
1234
1023
        return not self.__eq__(other)
1235
1024
 
 
1025
 
1236
1026
    def __hash__(self):
1237
1027
        raise ValueError('not hashable')
1238
1028
 
1239
1029
    def _iter_file_id_parents(self, file_id):
1240
1030
        """Yield the parents of file_id up to the root."""
1241
 
        file_id = osutils.safe_file_id(file_id)
1242
 
        while file_id is not None:
 
1031
        while file_id != None:
1243
1032
            try:
1244
1033
                ie = self._byid[file_id]
1245
1034
            except KeyError:
1246
 
                raise errors.NoSuchId(tree=None, file_id=file_id)
 
1035
                raise BzrError("file_id {%s} not found in inventory" % file_id)
1247
1036
            yield ie
1248
1037
            file_id = ie.parent_id
1249
1038
 
1255
1044
        is equal to the depth of the file in the tree, counting the
1256
1045
        root directory as depth 1.
1257
1046
        """
1258
 
        file_id = osutils.safe_file_id(file_id)
1259
1047
        p = []
1260
1048
        for parent in self._iter_file_id_parents(file_id):
1261
1049
            p.insert(0, parent.file_id)
1270
1058
        >>> print i.id2path('foo-id')
1271
1059
        src/foo.c
1272
1060
        """
1273
 
        file_id = osutils.safe_file_id(file_id)
1274
1061
        # get all names, skipping root
1275
1062
        return '/'.join(reversed(
1276
1063
            [parent.name for parent in 
1285
1072
        This returns the entry of the last component in the path,
1286
1073
        which may be either a file or a directory.
1287
1074
 
1288
 
        Returns None IFF the path is not found.
 
1075
        Returns None iff the path is not found.
1289
1076
        """
1290
 
        if isinstance(name, basestring):
1291
 
            name = osutils.splitpath(name)
 
1077
        if isinstance(name, types.StringTypes):
 
1078
            name = splitpath(name)
1292
1079
 
1293
 
        # mutter("lookup path %r" % name)
 
1080
        mutter("lookup path %r" % name)
1294
1081
 
1295
1082
        parent = self.root
1296
 
        if parent is None:
1297
 
            return None
1298
1083
        for f in name:
1299
1084
            try:
1300
 
                children = getattr(parent, 'children', None)
1301
 
                if children is None:
1302
 
                    return None
1303
 
                cie = children[f]
 
1085
                cie = parent.children[f]
1304
1086
                assert cie.name == f
1305
1087
                assert cie.parent_id == parent.file_id
1306
1088
                parent = cie
1310
1092
 
1311
1093
        return parent.file_id
1312
1094
 
 
1095
 
1313
1096
    def has_filename(self, names):
1314
1097
        return bool(self.path2id(names))
1315
1098
 
 
1099
 
1316
1100
    def has_id(self, file_id):
1317
 
        file_id = osutils.safe_file_id(file_id)
1318
 
        return (file_id in self._byid)
 
1101
        return self._byid.has_key(file_id)
1319
1102
 
1320
 
    def remove_recursive_id(self, file_id):
1321
 
        """Remove file_id, and children, from the inventory.
1322
 
        
1323
 
        :param file_id: A file_id to remove.
1324
 
        """
1325
 
        file_id = osutils.safe_file_id(file_id)
1326
 
        to_find_delete = [self._byid[file_id]]
1327
 
        to_delete = []
1328
 
        while to_find_delete:
1329
 
            ie = to_find_delete.pop()
1330
 
            to_delete.append(ie.file_id)
1331
 
            if ie.kind == 'directory':
1332
 
                to_find_delete.extend(ie.children.values())
1333
 
        for file_id in reversed(to_delete):
1334
 
            ie = self[file_id]
1335
 
            del self._byid[file_id]
1336
 
        if ie.parent_id is not None:
1337
 
            del self[ie.parent_id].children[ie.name]
1338
 
        else:
1339
 
            self.root = None
1340
1103
 
1341
1104
    def rename(self, file_id, new_parent_id, new_name):
1342
1105
        """Move a file within the inventory.
1343
1106
 
1344
1107
        This can change either the name, or the parent, or both.
1345
1108
 
1346
 
        This does not move the working file.
1347
 
        """
1348
 
        file_id = osutils.safe_file_id(file_id)
 
1109
        This does not move the working file."""
1349
1110
        if not is_valid_name(new_name):
1350
1111
            raise BzrError("not an acceptable filename: %r" % new_name)
1351
1112
 
1369
1130
        file_ie.name = new_name
1370
1131
        file_ie.parent_id = new_parent_id
1371
1132
 
1372
 
    def is_root(self, file_id):
1373
 
        file_id = osutils.safe_file_id(file_id)
1374
 
        return self.root is not None and file_id == self.root.file_id
1375
 
 
1376
 
 
1377
 
entry_factory = {
1378
 
    'directory': InventoryDirectory,
1379
 
    'file': InventoryFile,
1380
 
    'symlink': InventoryLink,
1381
 
    'tree-reference': TreeReference
1382
 
}
1383
 
 
1384
 
def make_entry(kind, name, parent_id, file_id=None):
1385
 
    """Create an inventory entry.
1386
 
 
1387
 
    :param kind: the type of inventory entry to create.
1388
 
    :param name: the basename of the entry.
1389
 
    :param parent_id: the parent_id of the entry.
1390
 
    :param file_id: the file_id to use. if None, one will be created.
1391
 
    """
1392
 
    if file_id is None:
1393
 
        file_id = generate_ids.gen_file_id(name)
1394
 
    else:
1395
 
        file_id = osutils.safe_file_id(file_id)
1396
 
 
1397
 
    #------- This has been copied to bzrlib.dirstate.DirState.add, please
1398
 
    # keep them synchronised.
1399
 
    # we dont import normalized_filename directly because we want to be
1400
 
    # able to change the implementation at runtime for tests.
1401
 
    norm_name, can_access = osutils.normalized_filename(name)
1402
 
    if norm_name != name:
1403
 
        if can_access:
1404
 
            name = norm_name
1405
 
        else:
1406
 
            # TODO: jam 20060701 This would probably be more useful
1407
 
            #       if the error was raised with the full path
1408
 
            raise errors.InvalidNormalization(name)
1409
 
 
1410
 
    try:
1411
 
        factory = entry_factory[kind]
1412
 
    except KeyError:
1413
 
        raise BzrError("unknown kind %r" % kind)
1414
 
    return factory(file_id, name, parent_id)
 
1133
 
1415
1134
 
1416
1135
 
1417
1136
_NAME_RE = None
1418
1137
 
1419
1138
def is_valid_name(name):
1420
1139
    global _NAME_RE
1421
 
    if _NAME_RE is None:
 
1140
    if _NAME_RE == None:
1422
1141
        _NAME_RE = re.compile(r'^[^/\\]+$')
1423
1142
        
1424
1143
    return bool(_NAME_RE.match(name))