/brz/remove-bazaar

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

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

First attempt to merge .dev and resolve the conflicts (but tests are 
failing)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
27
27
# created, but it's not for now.
28
28
ROOT_ID = "TREE_ROOT"
29
29
 
30
 
 
31
 
import collections
32
 
import os.path
 
30
import os
33
31
import re
34
32
import sys
 
33
 
 
34
from bzrlib.lazy_import import lazy_import
 
35
lazy_import(globals(), """
 
36
import collections
35
37
import tarfile
36
 
import types
37
 
from warnings import warn
38
38
 
39
39
import bzrlib
40
 
from bzrlib import errors, osutils
41
 
from bzrlib.osutils import (pumpfile, quotefn, splitpath, joinpath,
42
 
                            pathjoin, sha_strings)
43
 
from bzrlib.errors import (NotVersionedError, InvalidEntryName,
44
 
                           BzrError, BzrCheckError, BinaryFile)
 
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
45
54
from bzrlib.trace import mutter
46
55
 
47
56
 
82
91
    InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None)
83
92
    >>> i.add(InventoryFile('2323', 'hello.c', parent_id='123'))
84
93
    InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None)
85
 
    >>> shouldbe = {0: '', 1: 'src', 2: pathjoin('src','hello.c')}
 
94
    >>> shouldbe = {0: '', 1: 'src', 2: 'src/hello.c'}
86
95
    >>> for ix, j in enumerate(i.iter_entries()):
87
96
    ...   print (j[0] == shouldbe[ix], j[1])
88
97
    ... 
89
 
    (True, InventoryDirectory('TREE_ROOT', '', parent_id=None, revision=None))
 
98
    (True, InventoryDirectory('TREE_ROOT', u'', parent_id=None, revision=None))
90
99
    (True, InventoryDirectory('123', 'src', parent_id='TREE_ROOT', revision=None))
91
100
    (True, InventoryFile('2323', 'hello.c', parent_id='123', sha1=None, len=None))
92
 
    >>> i.add(InventoryFile('2323', 'bye.c', '123'))
93
 
    Traceback (most recent call last):
94
 
    ...
95
 
    BzrError: inventory already contains entry with id {2323}
96
101
    >>> i.add(InventoryFile('2324', 'bye.c', '123'))
97
102
    InventoryFile('2324', 'bye.c', parent_id='123', sha1=None, len=None)
98
103
    >>> i.add(InventoryDirectory('2325', 'wibble', '123'))
107
112
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
108
113
    >>> for path, entry in i.iter_entries():
109
114
    ...     print path
110
 
    ...     assert i.path2id(path)
111
115
    ... 
112
116
    <BLANKLINE>
113
117
    src
137
141
        """
138
142
        return False, False
139
143
 
140
 
    def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
141
 
             output_to, reverse=False):
142
 
        """Perform a diff from this to to_entry.
143
 
 
144
 
        text_diff will be used for textual difference calculation.
145
 
        This is a template method, override _diff in child classes.
146
 
        """
147
 
        self._read_tree_state(tree.id2path(self.file_id), tree)
148
 
        if to_entry:
149
 
            # cannot diff from one kind to another - you must do a removal
150
 
            # and an addif they do not match.
151
 
            assert self.kind == to_entry.kind
152
 
            to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
153
 
                                      to_tree)
154
 
        self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
155
 
                   output_to, reverse)
156
 
 
157
144
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
158
145
             output_to, reverse=False):
159
146
        """Perform a diff between two entries of the same kind."""
160
 
 
161
 
    def find_previous_heads(self, previous_inventories,
162
 
                            versioned_file_store,
163
 
                            transaction,
164
 
                            entry_vf=None):
165
 
        """Return the revisions and entries that directly precede this.
166
 
 
167
 
        Returned as a map from revision to inventory entry.
168
 
 
169
 
        This is a map containing the file revisions in all parents
170
 
        for which the file exists, and its revision is not a parent of
171
 
        any other. If the file is new, the set will be empty.
172
 
 
173
 
        :param versioned_file_store: A store where ancestry data on this
174
 
                                     file id can be queried.
175
 
        :param transaction: The transaction that queries to the versioned 
176
 
                            file store should be completed under.
177
 
        :param entry_vf: The entry versioned file, if its already available.
 
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.
178
156
        """
179
 
        def get_ancestors(weave, entry):
180
 
            return set(weave.get_ancestry(entry.revision))
181
157
        # revision:ie mapping for each ie found in previous_inventories.
182
158
        candidates = {}
183
 
        # revision:ie mapping with one revision for each head.
184
 
        heads = {}
185
 
        # revision: ancestor list for each head
186
 
        head_ancestors = {}
187
159
        # identify candidate head revision ids.
188
160
        for inv in previous_inventories:
189
161
            if self.file_id in inv:
190
162
                ie = inv[self.file_id]
191
 
                assert ie.file_id == self.file_id
192
163
                if ie.revision in candidates:
193
164
                    # same revision value in two different inventories:
194
165
                    # correct possible inconsistencies:
200
171
                            ie.executable = False
201
172
                    except AttributeError:
202
173
                        pass
203
 
                    # must now be the same.
204
 
                    assert candidates[ie.revision] == ie
205
174
                else:
206
175
                    # add this revision as a candidate.
207
176
                    candidates[ie.revision] = ie
208
 
 
209
 
        # common case optimisation
210
 
        if len(candidates) == 1:
211
 
            # if there is only one candidate revision found
212
 
            # then we can opening the versioned file to access ancestry:
213
 
            # there cannot be any ancestors to eliminate when there is 
214
 
            # only one revision available.
215
 
            heads[ie.revision] = ie
216
 
            return heads
217
 
 
218
 
        # eliminate ancestors amongst the available candidates:
219
 
        # heads are those that are not an ancestor of any other candidate
220
 
        # - this provides convergence at a per-file level.
221
 
        for ie in candidates.values():
222
 
            # may be an ancestor of a known head:
223
 
            already_present = 0 != len(
224
 
                [head for head in heads 
225
 
                 if ie.revision in head_ancestors[head]])
226
 
            if already_present:
227
 
                # an ancestor of an analyzed candidate.
228
 
                continue
229
 
            # not an ancestor of a known head:
230
 
            # load the versioned file for this file id if needed
231
 
            if entry_vf is None:
232
 
                entry_vf = versioned_file_store.get_weave_or_empty(
233
 
                    self.file_id, transaction)
234
 
            ancestors = get_ancestors(entry_vf, ie)
235
 
            # may knock something else out:
236
 
            check_heads = list(heads.keys())
237
 
            for head in check_heads:
238
 
                if head in ancestors:
239
 
                    # this previously discovered 'head' is not
240
 
                    # really a head - its an ancestor of the newly 
241
 
                    # found head,
242
 
                    heads.pop(head)
243
 
            head_ancestors[ie.revision] = ancestors
244
 
            heads[ie.revision] = ie
245
 
        return heads
246
 
 
 
177
        return candidates
 
178
 
 
179
    @deprecated_method(deprecated_in((1, 6, 0)))
247
180
    def get_tar_item(self, root, dp, now, tree):
248
181
        """Get a tarfile item and a file stream for its content."""
249
 
        item = tarfile.TarInfo(pathjoin(root, dp))
 
182
        item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
250
183
        # TODO: would be cool to actually set it to the timestamp of the
251
184
        # revision it was last changed
252
185
        item.mtime = now
279
212
        Traceback (most recent call last):
280
213
        InvalidEntryName: Invalid entry name: src/hello.c
281
214
        """
282
 
        assert isinstance(name, basestring), name
283
215
        if '/' in name or '\\' in name:
284
 
            raise InvalidEntryName(name=name)
 
216
            raise errors.InvalidEntryName(name=name)
285
217
        self.executable = False
286
218
        self.revision = None
287
219
        self.text_sha1 = None
291
223
        self.text_id = text_id
292
224
        self.parent_id = parent_id
293
225
        self.symlink_target = None
 
226
        self.reference_revision = None
294
227
 
295
228
    def kind_character(self):
296
229
        """Return a short kind indicator useful for appending to names."""
306
239
        raise BzrError("don't know how to export {%s} of kind %r" %
307
240
                       (self.file_id, self.kind))
308
241
 
 
242
    @deprecated_method(deprecated_in((1, 6, 0)))
309
243
    def put_on_disk(self, dest, dp, tree):
310
244
        """Create a representation of self on disk in the prefix dest.
311
245
        
312
246
        This is a template method - implement _put_on_disk in subclasses.
313
247
        """
314
 
        fullpath = pathjoin(dest, dp)
 
248
        fullpath = osutils.pathjoin(dest, dp)
315
249
        self._put_on_disk(fullpath, tree)
316
250
        # mutter("  export {%s} kind %s to %s", self.file_id,
317
251
        #         self.kind, fullpath)
325
259
 
326
260
    @staticmethod
327
261
    def versionable_kind(kind):
328
 
        return (kind in ('file', 'directory', 'symlink'))
 
262
        return (kind in ('file', 'directory', 'symlink', 'tree-reference'))
329
263
 
330
264
    def check(self, checker, rev_id, inv, tree):
331
265
        """Check this inventory entry is intact.
376
310
            return 'added'
377
311
        elif new_entry is None:
378
312
            return 'removed'
 
313
        if old_entry.kind != new_entry.kind:
 
314
            return 'modified'
379
315
        text_modified, meta_modified = new_entry.detect_changes(old_entry)
380
316
        if text_modified or meta_modified:
381
317
            modified = True
404
340
                   self.parent_id,
405
341
                   self.revision))
406
342
 
407
 
    def snapshot(self, revision, path, previous_entries,
408
 
                 work_tree, commit_builder):
409
 
        """Make a snapshot of this entry which may or may not have changed.
410
 
        
411
 
        This means that all its fields are populated, that it has its
412
 
        text stored in the text store or weave.
413
 
        """
414
 
        # mutter('new parents of %s are %r', path, previous_entries)
415
 
        self._read_tree_state(path, work_tree)
416
 
        # TODO: Where should we determine whether to reuse a
417
 
        # previous revision id or create a new revision? 20060606
418
 
        if len(previous_entries) == 1:
419
 
            # cannot be unchanged unless there is only one parent file rev.
420
 
            parent_ie = previous_entries.values()[0]
421
 
            if self._unchanged(parent_ie):
422
 
                # mutter("found unchanged entry")
423
 
                self.revision = parent_ie.revision
424
 
                return "unchanged"
425
 
        return self._snapshot_into_revision(revision, previous_entries, 
426
 
                                            work_tree, commit_builder)
427
 
 
428
 
    def _snapshot_into_revision(self, revision, previous_entries, work_tree,
429
 
                                commit_builder):
430
 
        """Record this revision unconditionally into a store.
431
 
 
432
 
        The entry's last-changed revision property (`revision`) is updated to 
433
 
        that of the new revision.
434
 
        
435
 
        :param revision: id of the new revision that is being recorded.
436
 
 
437
 
        :returns: String description of the commit (e.g. "merged", "modified"), etc.
438
 
        """
439
 
        # mutter('new revision {%s} for {%s}', revision, self.file_id)
440
 
        self.revision = revision
441
 
        self._snapshot_text(previous_entries, work_tree, commit_builder)
442
 
 
443
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder): 
444
 
        """Record the 'text' of this entry, whatever form that takes.
445
 
        
446
 
        This default implementation simply adds an empty text.
447
 
        """
448
 
        raise NotImplementedError(self._snapshot_text)
449
 
 
450
343
    def __eq__(self, other):
451
344
        if not isinstance(other, InventoryEntry):
452
345
            return NotImplemented
461
354
                and (self.kind == other.kind)
462
355
                and (self.revision == other.revision)
463
356
                and (self.executable == other.executable)
 
357
                and (self.reference_revision == other.reference_revision)
464
358
                )
465
359
 
466
360
    def __ne__(self, other):
481
375
        # renamed
482
376
        elif previous_ie.name != self.name:
483
377
            compatible = False
 
378
        elif previous_ie.kind != self.kind:
 
379
            compatible = False
484
380
        return compatible
485
381
 
486
382
    def _read_tree_state(self, path, work_tree):
501
397
class RootEntry(InventoryEntry):
502
398
 
503
399
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
504
 
                 'text_id', 'parent_id', 'children', 'executable', 
505
 
                 'revision', 'symlink_target']
 
400
                 'text_id', 'parent_id', 'children', 'executable',
 
401
                 'revision', 'symlink_target', 'reference_revision']
506
402
 
507
403
    def _check(self, checker, rev_id, tree):
508
404
        """See InventoryEntry._check"""
514
410
        self.parent_id = None
515
411
        self.name = u''
516
412
        self.revision = None
517
 
        warn('RootEntry is deprecated as of bzr 0.10.  Please use '
518
 
             'InventoryDirectory instead.',
519
 
            DeprecationWarning, stacklevel=2)
 
413
        symbol_versioning.warn('RootEntry is deprecated as of bzr 0.10.'
 
414
                               '  Please use InventoryDirectory instead.',
 
415
                               DeprecationWarning, stacklevel=2)
520
416
 
521
417
    def __eq__(self, other):
522
418
        if not isinstance(other, RootEntry):
530
426
    """A directory in an inventory."""
531
427
 
532
428
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
533
 
                 'text_id', 'parent_id', 'children', 'executable', 
534
 
                 'revision', 'symlink_target']
 
429
                 'text_id', 'parent_id', 'children', 'executable',
 
430
                 'revision', 'symlink_target', 'reference_revision']
535
431
 
536
432
    def _check(self, checker, rev_id, tree):
537
433
        """See InventoryEntry._check"""
568
464
        """See InventoryEntry._put_on_disk."""
569
465
        os.mkdir(fullpath)
570
466
 
571
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
572
 
        """See InventoryEntry._snapshot_text."""
573
 
        commit_builder.modified_directory(self.file_id, file_parents)
574
 
 
575
467
 
576
468
class InventoryFile(InventoryEntry):
577
469
    """A file in an inventory."""
578
470
 
579
471
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
580
 
                 'text_id', 'parent_id', 'children', 'executable', 
581
 
                 'revision', 'symlink_target']
 
472
                 'text_id', 'parent_id', 'children', 'executable',
 
473
                 'revision', 'symlink_target', 'reference_revision']
582
474
 
583
475
    def _check(self, checker, tree_revision_id, tree):
584
476
        """See InventoryEntry._check"""
585
 
        t = (self.file_id, self.revision)
586
 
        if t in checker.checked_texts:
587
 
            prev_sha = checker.checked_texts[t]
 
477
        key = (self.file_id, self.revision)
 
478
        if key in checker.checked_texts:
 
479
            prev_sha = checker.checked_texts[key]
588
480
            if prev_sha != self.text_sha1:
589
 
                raise BzrCheckError('mismatched sha1 on {%s} in {%s}' %
590
 
                                    (self.file_id, tree_revision_id))
 
481
                raise BzrCheckError(
 
482
                    'mismatched sha1 on {%s} in {%s} (%s != %s) %r' %
 
483
                    (self.file_id, tree_revision_id, prev_sha, self.text_sha1,
 
484
                     t))
591
485
            else:
592
486
                checker.repeated_text_cnt += 1
593
487
                return
594
488
 
595
 
        if self.file_id not in checker.checked_weaves:
596
 
            mutter('check weave {%s}', self.file_id)
597
 
            w = tree.get_weave(self.file_id)
598
 
            # Not passing a progress bar, because it creates a new
599
 
            # progress, which overwrites the current progress,
600
 
            # and doesn't look nice
601
 
            w.check()
602
 
            checker.checked_weaves[self.file_id] = True
603
 
        else:
604
 
            w = tree.get_weave(self.file_id)
605
 
 
606
489
        mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
607
490
        checker.checked_text_cnt += 1
608
491
        # We can't check the length, because Weave doesn't store that
609
492
        # information, and the whole point of looking at the weave's
610
493
        # sha1sum is that we don't have to extract the text.
611
 
        if self.text_sha1 != w.get_sha1(self.revision):
612
 
            raise BzrCheckError('text {%s} version {%s} wrong sha1' 
613
 
                                % (self.file_id, self.revision))
614
 
        checker.checked_texts[t] = self.text_sha1
 
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
615
497
 
616
498
    def copy(self):
617
499
        other = InventoryFile(self.file_id, self.name, self.parent_id)
624
506
 
625
507
    def detect_changes(self, old_entry):
626
508
        """See InventoryEntry.detect_changes."""
627
 
        assert self.text_sha1 is not None
628
 
        assert old_entry.text_sha1 is not None
629
509
        text_modified = (self.text_sha1 != old_entry.text_sha1)
630
510
        meta_modified = (self.executable != old_entry.executable)
631
511
        return text_modified, meta_modified
633
513
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
634
514
             output_to, reverse=False):
635
515
        """See InventoryEntry._diff."""
636
 
        try:
637
 
            from_text = tree.get_file(self.file_id).readlines()
638
 
            if to_entry:
639
 
                to_text = to_tree.get_file(to_entry.file_id).readlines()
640
 
            else:
641
 
                to_text = []
642
 
            if not reverse:
643
 
                text_diff(from_label, from_text,
644
 
                          to_label, to_text, output_to)
645
 
            else:
646
 
                text_diff(to_label, to_text,
647
 
                          from_label, from_text, output_to)
648
 
        except BinaryFile:
649
 
            if reverse:
650
 
                label_pair = (to_label, from_label)
651
 
            else:
652
 
                label_pair = (from_label, to_label)
653
 
            print >> output_to, "Binary files %s and %s differ" % label_pair
 
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)
654
529
 
655
530
    def has_text(self):
656
531
        """See InventoryEntry.has_text."""
677
552
 
678
553
    def _put_on_disk(self, fullpath, tree):
679
554
        """See InventoryEntry._put_on_disk."""
680
 
        pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
 
555
        osutils.pumpfile(tree.get_file(self.file_id), file(fullpath, 'wb'))
681
556
        if tree.is_executable(self.file_id):
682
557
            os.chmod(fullpath, 0755)
683
558
 
700
575
    def _forget_tree_state(self):
701
576
        self.text_sha1 = None
702
577
 
703
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
704
 
        """See InventoryEntry._snapshot_text."""
705
 
        def get_content_byte_lines():
706
 
            return work_tree.get_file(self.file_id).readlines()
707
 
        self.text_sha1, self.text_size = commit_builder.modified_file_text(
708
 
            self.file_id, file_parents, get_content_byte_lines, self.text_sha1, self.text_size)
709
 
 
710
578
    def _unchanged(self, previous_ie):
711
579
        """See InventoryEntry._unchanged."""
712
580
        compatible = super(InventoryFile, self)._unchanged(previous_ie)
725
593
    """A file in an inventory."""
726
594
 
727
595
    __slots__ = ['text_sha1', 'text_size', 'file_id', 'name', 'kind',
728
 
                 'text_id', 'parent_id', 'children', 'executable', 
729
 
                 'revision', 'symlink_target']
 
596
                 'text_id', 'parent_id', 'children', 'executable',
 
597
                 'revision', 'symlink_target', 'reference_revision']
730
598
 
731
599
    def _check(self, checker, rev_id, tree):
732
600
        """See InventoryEntry._check"""
755
623
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
756
624
             output_to, reverse=False):
757
625
        """See InventoryEntry._diff."""
758
 
        from_text = self.symlink_target
 
626
        from bzrlib.diff import DiffSymlink
 
627
        old_target = self.symlink_target
759
628
        if to_entry is not None:
760
 
            to_text = to_entry.symlink_target
761
 
            if reverse:
762
 
                temp = from_text
763
 
                from_text = to_text
764
 
                to_text = temp
765
 
            print >>output_to, '=== target changed %r => %r' % (from_text, to_text)
766
 
        else:
767
 
            if not reverse:
768
 
                print >>output_to, '=== target was %r' % self.symlink_target
769
 
            else:
770
 
                print >>output_to, '=== target is %r' % self.symlink_target
 
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)
771
641
 
772
642
    def __init__(self, file_id, name, parent_id):
773
643
        super(InventoryLink, self).__init__(file_id, name, parent_id)
807
677
            compatible = False
808
678
        return compatible
809
679
 
810
 
    def _snapshot_text(self, file_parents, work_tree, commit_builder):
811
 
        """See InventoryEntry._snapshot_text."""
812
 
        commit_builder.modified_link(
813
 
            self.file_id, file_parents, self.symlink_target)
 
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
814
710
 
815
711
 
816
712
class Inventory(object):
849
745
    ['', u'hello.c']
850
746
    >>> inv = Inventory('TREE_ROOT-12345678-12345678')
851
747
    >>> 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'))
852
751
    InventoryFile('123-123', 'hello.c', parent_id='TREE_ROOT-12345678-12345678', sha1=None, len=None)
853
752
    """
854
753
    def __init__(self, root_id=ROOT_ID, revision_id=None):
861
760
        The inventory is created with a default root directory, with
862
761
        an id of None.
863
762
        """
864
 
        # We are letting Branch.create() create a unique inventory
865
 
        # root id. Rather than generating a random one here.
866
 
        #if root_id is None:
867
 
        #    root_id = bzrlib.branch.gen_file_id('TREE_ROOT')
868
763
        if root_id is not None:
869
 
            self._set_root(InventoryDirectory(root_id, '', None))
 
764
            self._set_root(InventoryDirectory(root_id, u'', None))
870
765
        else:
871
766
            self.root = None
872
767
            self._byid = {}
873
 
        # FIXME: this isn't ever used, changing it to self.revision may break
874
 
        # things. TODO make everything use self.revision_id
875
768
        self.revision_id = revision_id
876
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
 
877
843
    def _set_root(self, ie):
878
844
        self.root = ie
879
845
        self._byid = {self.root.file_id: self.root}
881
847
    def copy(self):
882
848
        # TODO: jam 20051218 Should copy also copy the revision_id?
883
849
        entries = self.iter_entries()
 
850
        if self.root is None:
 
851
            return Inventory(root_id=None)
884
852
        other = Inventory(entries.next()[1].file_id)
 
853
        other.root.revision = self.root.revision
885
854
        # copy recursively so we know directories will be added before
886
855
        # their children.  There are more efficient ways than this...
887
 
        for path, entry in entries():
 
856
        for path, entry in entries:
888
857
            other.add(entry.copy())
889
858
        return other
890
859
 
898
867
    def iter_entries(self, from_dir=None):
899
868
        """Return (path, entry) pairs, in order by name."""
900
869
        if from_dir is None:
901
 
            assert self.root
 
870
            if self.root is None:
 
871
                return
902
872
            from_dir = self.root
903
873
            yield '', self.root
904
874
        elif isinstance(from_dir, basestring):
938
908
                # if we finished all children, pop it off the stack
939
909
                stack.pop()
940
910
 
941
 
    def iter_entries_by_dir(self, from_dir=None):
 
911
    def iter_entries_by_dir(self, from_dir=None, specific_file_ids=None,
 
912
        yield_parents=False):
942
913
        """Iterate over the entries in a directory first order.
943
914
 
944
915
        This returns all entries for a directory before returning
946
917
        lexicographically sorted order, and is a hybrid between
947
918
        depth-first and breadth-first.
948
919
 
 
920
        :param yield_parents: If True, yield the parents from the root leading
 
921
            down to specific_file_ids that have been requested. This has no
 
922
            impact if specific_file_ids is None.
949
923
        :return: This yields (path, entry) pairs
950
924
        """
 
925
        if specific_file_ids and not isinstance(specific_file_ids, set):
 
926
            specific_file_ids = set(specific_file_ids)
951
927
        # TODO? Perhaps this should return the from_dir so that the root is
952
928
        # yielded? or maybe an option?
953
929
        if from_dir is None:
954
 
            assert self.root
 
930
            if self.root is None:
 
931
                return
 
932
            # Optimize a common case
 
933
            if (not yield_parents and specific_file_ids is not None and
 
934
                len(specific_file_ids) == 1):
 
935
                file_id = list(specific_file_ids)[0]
 
936
                if file_id in self:
 
937
                    yield self.id2path(file_id), self[file_id]
 
938
                return 
955
939
            from_dir = self.root
956
 
            yield '', 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
957
943
        elif isinstance(from_dir, basestring):
958
944
            from_dir = self._byid[from_dir]
 
945
 
 
946
        if specific_file_ids is not None:
 
947
            # TODO: jam 20070302 This could really be done as a loop rather
 
948
            #       than a bunch of recursive calls.
 
949
            parents = set()
 
950
            byid = self._byid
 
951
            def add_ancestors(file_id):
 
952
                if file_id not in byid:
 
953
                    return
 
954
                parent_id = byid[file_id].parent_id
 
955
                if parent_id is None:
 
956
                    return
 
957
                if parent_id not in parents:
 
958
                    parents.add(parent_id)
 
959
                    add_ancestors(parent_id)
 
960
            for file_id in specific_file_ids:
 
961
                add_ancestors(file_id)
 
962
        else:
 
963
            parents = None
959
964
            
960
965
        stack = [(u'', from_dir)]
961
966
        while stack:
966
971
 
967
972
                child_relpath = cur_relpath + child_name
968
973
 
969
 
                yield child_relpath, child_ie
 
974
                if (specific_file_ids is None or 
 
975
                    child_ie.file_id in specific_file_ids or
 
976
                    (yield_parents and child_ie.file_id in parents)):
 
977
                    yield child_relpath, child_ie
970
978
 
971
979
                if child_ie.kind == 'directory':
972
 
                    child_dirs.append((child_relpath+'/', child_ie))
 
980
                    if parents is None or child_ie.file_id in parents:
 
981
                        child_dirs.append((child_relpath+'/', child_ie))
973
982
            stack.extend(reversed(child_dirs))
974
983
 
 
984
    def make_entry(self, kind, name, parent_id, file_id=None):
 
985
        """Simple thunk to bzrlib.inventory.make_entry."""
 
986
        return make_entry(kind, name, parent_id, file_id)
 
987
 
975
988
    def entries(self):
976
989
        """Return list of (path, ie) for all entries except the root.
977
990
 
982
995
            kids = dir_ie.children.items()
983
996
            kids.sort()
984
997
            for name, ie in kids:
985
 
                child_path = pathjoin(dir_path, name)
 
998
                child_path = osutils.pathjoin(dir_path, name)
986
999
                accum.append((child_path, ie))
987
1000
                if ie.kind == 'directory':
988
1001
                    descend(ie, child_path)
1001
1014
            kids.sort()
1002
1015
 
1003
1016
            for name, child_ie in kids:
1004
 
                child_path = pathjoin(parent_path, name)
 
1017
                child_path = osutils.pathjoin(parent_path, name)
1005
1018
                descend(child_ie, child_path)
1006
1019
        descend(self.root, u'')
1007
1020
        return accum
1031
1044
        try:
1032
1045
            return self._byid[file_id]
1033
1046
        except KeyError:
1034
 
            if file_id is None:
1035
 
                raise BzrError("can't look up file_id None")
1036
 
            else:
1037
 
                raise BzrError("file_id {%s} not in inventory" % file_id)
 
1047
            # really we're passing an inventory, not a tree...
 
1048
            raise errors.NoSuchId(self, file_id)
1038
1049
 
1039
1050
    def get_file_kind(self, file_id):
1040
1051
        return self._byid[file_id].kind
1042
1053
    def get_child(self, parent_id, filename):
1043
1054
        return self[parent_id].children.get(filename)
1044
1055
 
 
1056
    def _add_child(self, entry):
 
1057
        """Add an entry to the inventory, without adding it to its parent"""
 
1058
        if entry.file_id in self._byid:
 
1059
            raise BzrError("inventory already contains entry with id {%s}" %
 
1060
                           entry.file_id)
 
1061
        self._byid[entry.file_id] = entry
 
1062
        for child in getattr(entry, 'children', {}).itervalues():
 
1063
            self._add_child(child)
 
1064
        return entry
 
1065
 
1045
1066
    def add(self, entry):
1046
1067
        """Add entry to inventory.
1047
1068
 
1051
1072
        Returns the new entry object.
1052
1073
        """
1053
1074
        if entry.file_id in self._byid:
1054
 
            raise BzrError("inventory already contains entry with id {%s}" % entry.file_id)
 
1075
            raise errors.DuplicateFileId(entry.file_id,
 
1076
                                         self._byid[entry.file_id])
1055
1077
 
1056
1078
        if entry.parent_id is None:
1057
 
            assert self.root is None and len(self._byid) == 0
1058
 
            self._set_root(entry)
1059
 
            return entry
1060
 
        if entry.parent_id == ROOT_ID:
1061
 
            assert self.root is not None, self
1062
 
            entry.parent_id = self.root.file_id
1063
 
 
1064
 
        try:
1065
 
            parent = self._byid[entry.parent_id]
1066
 
        except KeyError:
1067
 
            raise BzrError("parent_id {%s} not in inventory" % entry.parent_id)
1068
 
 
1069
 
        if entry.name in parent.children:
1070
 
            raise BzrError("%s is already versioned" %
1071
 
                    pathjoin(self.id2path(parent.file_id), entry.name))
1072
 
 
1073
 
        self._byid[entry.file_id] = entry
1074
 
        parent.children[entry.name] = entry
1075
 
        return entry
 
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)
1076
1093
 
1077
1094
    def add_path(self, relpath, kind, file_id=None, parent_id=None):
1078
1095
        """Add entry from a path.
1085
1102
 
1086
1103
        if len(parts) == 0:
1087
1104
            if file_id is None:
1088
 
                file_id = bzrlib.workingtree.gen_root_id()
 
1105
                file_id = generate_ids.gen_root_id()
1089
1106
            self.root = InventoryDirectory(file_id, '', None)
1090
1107
            self._byid = {self.root.file_id: self.root}
1091
 
            return
 
1108
            return self.root
1092
1109
        else:
1093
1110
            parent_path = parts[:-1]
1094
1111
            parent_id = self.path2id(parent_path)
1095
1112
            if parent_id is None:
1096
 
                raise NotVersionedError(path=parent_path)
 
1113
                raise errors.NotVersionedError(path=parent_path)
1097
1114
        ie = make_entry(kind, parts[-1], parent_id, file_id)
1098
1115
        return self.add(ie)
1099
1116
 
1110
1127
        False
1111
1128
        """
1112
1129
        ie = self[file_id]
1113
 
 
1114
 
        assert ie.parent_id is None or \
1115
 
            self[ie.parent_id].children[ie.name] == ie
1116
 
        
1117
1130
        del self._byid[file_id]
1118
1131
        if ie.parent_id is not None:
1119
1132
            del self[ie.parent_id].children[ie.name]
1151
1164
            try:
1152
1165
                ie = self._byid[file_id]
1153
1166
            except KeyError:
1154
 
                raise BzrError("file_id {%s} not found in inventory" % file_id)
 
1167
                raise errors.NoSuchId(tree=None, file_id=file_id)
1155
1168
            yield ie
1156
1169
            file_id = ie.parent_id
1157
1170
 
1193
1206
 
1194
1207
        Returns None IFF the path is not found.
1195
1208
        """
1196
 
        if isinstance(name, types.StringTypes):
1197
 
            name = splitpath(name)
 
1209
        if isinstance(name, basestring):
 
1210
            name = osutils.splitpath(name)
1198
1211
 
1199
1212
        # mutter("lookup path %r" % name)
1200
1213
 
1201
1214
        parent = self.root
 
1215
        if parent is None:
 
1216
            return None
1202
1217
        for f in name:
1203
1218
            try:
1204
 
                cie = parent.children[f]
1205
 
                assert cie.name == f
1206
 
                assert cie.parent_id == parent.file_id
 
1219
                children = getattr(parent, 'children', None)
 
1220
                if children is None:
 
1221
                    return None
 
1222
                cie = children[f]
1207
1223
                parent = cie
1208
1224
            except KeyError:
1209
1225
                # or raise an error?
1232
1248
        for file_id in reversed(to_delete):
1233
1249
            ie = self[file_id]
1234
1250
            del self._byid[file_id]
1235
 
            if ie.parent_id is not None:
1236
 
                del self[ie.parent_id].children[ie.name]
 
1251
        if ie.parent_id is not None:
 
1252
            del self[ie.parent_id].children[ie.name]
 
1253
        else:
 
1254
            self.root = None
1237
1255
 
1238
1256
    def rename(self, file_id, new_parent_id, new_name):
1239
1257
        """Move a file within the inventory.
1240
1258
 
1241
1259
        This can change either the name, or the parent, or both.
1242
1260
 
1243
 
        This does not move the working file."""
 
1261
        This does not move the working file.
 
1262
        """
 
1263
        new_name = ensure_normalized_name(new_name)
1244
1264
        if not is_valid_name(new_name):
1245
1265
            raise BzrError("not an acceptable filename: %r" % new_name)
1246
1266
 
1264
1284
        file_ie.name = new_name
1265
1285
        file_ie.parent_id = new_parent_id
1266
1286
 
 
1287
    def is_root(self, file_id):
 
1288
        return self.root is not None and file_id == self.root.file_id
 
1289
 
 
1290
 
 
1291
entry_factory = {
 
1292
    'directory': InventoryDirectory,
 
1293
    'file': InventoryFile,
 
1294
    'symlink': InventoryLink,
 
1295
    'tree-reference': TreeReference
 
1296
}
1267
1297
 
1268
1298
def make_entry(kind, name, parent_id, file_id=None):
1269
1299
    """Create an inventory entry.
1274
1304
    :param file_id: the file_id to use. if None, one will be created.
1275
1305
    """
1276
1306
    if file_id is None:
1277
 
        file_id = bzrlib.workingtree.gen_file_id(name)
1278
 
 
 
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:
 
1312
        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.
1279
1327
    norm_name, can_access = osutils.normalized_filename(name)
1280
1328
    if norm_name != name:
1281
1329
        if can_access:
1282
 
            name = norm_name
 
1330
            return norm_name
1283
1331
        else:
1284
1332
            # TODO: jam 20060701 This would probably be more useful
1285
1333
            #       if the error was raised with the full path
1286
1334
            raise errors.InvalidNormalization(name)
1287
 
 
1288
 
    if kind == 'directory':
1289
 
        return InventoryDirectory(file_id, name, parent_id)
1290
 
    elif kind == 'file':
1291
 
        return InventoryFile(file_id, name, parent_id)
1292
 
    elif kind == 'symlink':
1293
 
        return InventoryLink(file_id, name, parent_id)
1294
 
    else:
1295
 
        raise BzrError("unknown kind %r" % kind)
 
1335
    return name
1296
1336
 
1297
1337
 
1298
1338
_NAME_RE = None