← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/inventory.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-11-04 18:51:39 UTC
  • mfrom: (2961.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20071104185139-kaio3sneodg2kp71
Authentication ring implementation (read-only)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/inventory.py
50
50
    BzrCheckError,
51
51
    BzrError,
52
52
    )
53
 
from bzrlib.symbol_versioning import deprecated_in, deprecated_method
 
53
from bzrlib.symbol_versioning import deprecated_method, zero_ninetyone
54
54
from bzrlib.trace import mutter
55
55
 
56
56
 
112
112
    InventoryFile('2326', 'wibble.c', parent_id='2325', sha1=None, len=None)
113
113
    >>> for path, entry in i.iter_entries():
114
114
    ...     print path
 
115
    ...     assert i.path2id(path)
115
116
    ... 
116
117
    <BLANKLINE>
117
118
    src
141
142
        """
142
143
        return False, False
143
144
 
 
145
    def diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
 
146
             output_to, reverse=False):
 
147
        """Perform a diff from this to to_entry.
 
148
 
 
149
        text_diff will be used for textual difference calculation.
 
150
        This is a template method, override _diff in child classes.
 
151
        """
 
152
        self._read_tree_state(tree.id2path(self.file_id), tree)
 
153
        if to_entry:
 
154
            # cannot diff from one kind to another - you must do a removal
 
155
            # and an addif they do not match.
 
156
            assert self.kind == to_entry.kind
 
157
            to_entry._read_tree_state(to_tree.id2path(to_entry.file_id),
 
158
                                      to_tree)
 
159
        self._diff(text_diff, from_label, tree, to_label, to_entry, to_tree,
 
160
                   output_to, reverse)
 
161
 
144
162
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
145
163
             output_to, reverse=False):
146
164
        """Perform a diff between two entries of the same kind."""
160
178
        for inv in previous_inventories:
161
179
            if self.file_id in inv:
162
180
                ie = inv[self.file_id]
 
181
                assert ie.file_id == self.file_id
163
182
                if ie.revision in candidates:
164
183
                    # same revision value in two different inventories:
165
184
                    # correct possible inconsistencies:
171
190
                            ie.executable = False
172
191
                    except AttributeError:
173
192
                        pass
 
193
                    # must now be the same.
 
194
                    assert candidates[ie.revision] == ie
174
195
                else:
175
196
                    # add this revision as a candidate.
176
197
                    candidates[ie.revision] = ie
177
198
        return candidates
178
199
 
179
 
    @deprecated_method(deprecated_in((1, 6, 0)))
 
200
    @deprecated_method(zero_ninetyone)
 
201
    def find_previous_heads(self, previous_inventories,
 
202
                            versioned_file_store,
 
203
                            transaction,
 
204
                            entry_vf=None):
 
205
        """Return the revisions and entries that directly precede this.
 
206
 
 
207
        Returned as a map from revision to inventory entry.
 
208
 
 
209
        This is a map containing the file revisions in all parents
 
210
        for which the file exists, and its revision is not a parent of
 
211
        any other. If the file is new, the set will be empty.
 
212
 
 
213
        :param versioned_file_store: A store where ancestry data on this
 
214
                                     file id can be queried.
 
215
        :param transaction: The transaction that queries to the versioned 
 
216
                            file store should be completed under.
 
217
        :param entry_vf: The entry versioned file, if its already available.
 
218
        """
 
219
        candidates = self.parent_candidates(previous_inventories)
 
220
 
 
221
        # revision:ie mapping with one revision for each head.
 
222
        heads = {}
 
223
        # common case optimisation
 
224
        if len(candidates) == 1:
 
225
            # if there is only one candidate revision found
 
226
            # then we can avoid opening the versioned file to access ancestry:
 
227
            # there cannot be any ancestors to eliminate when there is 
 
228
            # only one revision available.
 
229
            return candidates
 
230
        
 
231
        # --- what follows is now encapsulated in repository.get_graph.heads(), 
 
232
        #     but that is not accessible from here as we have no repository
 
233
        #     pointer. Note that the repository.get_graph.heads() call can return
 
234
        #     different results *at the moment* because of the kind-changing check
 
235
        #     we have in parent_candidates().
 
236
 
 
237
        # eliminate ancestors amongst the available candidates:
 
238
        # heads are those that are not an ancestor of any other candidate
 
239
        # - this provides convergence at a per-file level.
 
240
        def get_ancestors(weave, entry):
 
241
            return set(weave.get_ancestry(entry.revision, topo_sorted=False))
 
242
        # revision: ancestor list for each head
 
243
        head_ancestors = {}
 
244
        for ie in candidates.values():
 
245
            # may be an ancestor of a known head:
 
246
            already_present = 0 != len(
 
247
                [head for head in heads 
 
248
                 if ie.revision in head_ancestors[head]])
 
249
            if already_present:
 
250
                # an ancestor of an analyzed candidate.
 
251
                continue
 
252
            # not an ancestor of a known head:
 
253
            # load the versioned file for this file id if needed
 
254
            if entry_vf is None:
 
255
                entry_vf = versioned_file_store.get_weave_or_empty(
 
256
                    self.file_id, transaction)
 
257
            ancestors = get_ancestors(entry_vf, ie)
 
258
            # may knock something else out:
 
259
            check_heads = list(heads.keys())
 
260
            for head in check_heads:
 
261
                if head in ancestors:
 
262
                    # this previously discovered 'head' is not
 
263
                    # really a head - its an ancestor of the newly 
 
264
                    # found head,
 
265
                    heads.pop(head)
 
266
            head_ancestors[ie.revision] = ancestors
 
267
            heads[ie.revision] = ie
 
268
        return heads
 
269
 
180
270
    def get_tar_item(self, root, dp, now, tree):
181
271
        """Get a tarfile item and a file stream for its content."""
182
272
        item = tarfile.TarInfo(osutils.pathjoin(root, dp).encode('utf8'))
212
302
        Traceback (most recent call last):
213
303
        InvalidEntryName: Invalid entry name: src/hello.c
214
304
        """
 
305
        assert isinstance(name, basestring), name
215
306
        if '/' in name or '\\' in name:
216
307
            raise errors.InvalidEntryName(name=name)
217
308
        self.executable = False
219
310
        self.text_sha1 = None
220
311
        self.text_size = None
221
312
        self.file_id = file_id
 
313
        assert isinstance(file_id, (str, None.__class__)), \
 
314
            'bad type %r for %r' % (type(file_id), file_id)
222
315
        self.name = name
223
316
        self.text_id = text_id
224
317
        self.parent_id = parent_id
239
332
        raise BzrError("don't know how to export {%s} of kind %r" %
240
333
                       (self.file_id, self.kind))
241
334
 
242
 
    @deprecated_method(deprecated_in((1, 6, 0)))
243
335
    def put_on_disk(self, dest, dp, tree):
244
336
        """Create a representation of self on disk in the prefix dest.
245
337
        
474
566
 
475
567
    def _check(self, checker, tree_revision_id, tree):
476
568
        """See InventoryEntry._check"""
477
 
        key = (self.file_id, self.revision)
478
 
        if key in checker.checked_texts:
479
 
            prev_sha = checker.checked_texts[key]
 
569
        t = (self.file_id, self.revision)
 
570
        if t in checker.checked_texts:
 
571
            prev_sha = checker.checked_texts[t]
480
572
            if prev_sha != self.text_sha1:
481
573
                raise BzrCheckError(
482
574
                    'mismatched sha1 on {%s} in {%s} (%s != %s) %r' %
486
578
                checker.repeated_text_cnt += 1
487
579
                return
488
580
 
 
581
        if self.file_id not in checker.checked_weaves:
 
582
            mutter('check weave {%s}', self.file_id)
 
583
            w = tree._get_weave(self.file_id)
 
584
            # Not passing a progress bar, because it creates a new
 
585
            # progress, which overwrites the current progress,
 
586
            # and doesn't look nice
 
587
            w.check()
 
588
            checker.checked_weaves[self.file_id] = True
 
589
        else:
 
590
            w = tree._get_weave(self.file_id)
 
591
 
489
592
        mutter('check version {%s} of {%s}', tree_revision_id, self.file_id)
490
593
        checker.checked_text_cnt += 1
491
594
        # We can't check the length, because Weave doesn't store that
492
595
        # information, and the whole point of looking at the weave's
493
596
        # sha1sum is that we don't have to extract the text.
494
 
        if (self.text_sha1 != tree._repository.texts.get_sha1s([key])[key]):
495
 
            raise BzrCheckError('text {%s} version {%s} wrong sha1' % key)
496
 
        checker.checked_texts[key] = self.text_sha1
 
597
        if self.text_sha1 != w.get_sha1(self.revision):
 
598
            raise BzrCheckError('text {%s} version {%s} wrong sha1' 
 
599
                                % (self.file_id, self.revision))
 
600
        checker.checked_texts[t] = self.text_sha1
497
601
 
498
602
    def copy(self):
499
603
        other = InventoryFile(self.file_id, self.name, self.parent_id)
506
610
 
507
611
    def detect_changes(self, old_entry):
508
612
        """See InventoryEntry.detect_changes."""
 
613
        assert self.text_sha1 is not None
 
614
        assert old_entry.text_sha1 is not None
509
615
        text_modified = (self.text_sha1 != old_entry.text_sha1)
510
616
        meta_modified = (self.executable != old_entry.executable)
511
617
        return text_modified, meta_modified
513
619
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
514
620
             output_to, reverse=False):
515
621
        """See InventoryEntry._diff."""
516
 
        from bzrlib.diff import DiffText
517
 
        from_file_id = self.file_id
518
 
        if to_entry:
519
 
            to_file_id = to_entry.file_id
520
 
        else:
521
 
            to_file_id = None
522
 
        if reverse:
523
 
            to_file_id, from_file_id = from_file_id, to_file_id
524
 
            tree, to_tree = to_tree, tree
525
 
            from_label, to_label = to_label, from_label
526
 
        differ = DiffText(tree, to_tree, output_to, 'utf-8', '', '',
527
 
                          text_diff)
528
 
        return differ.diff_text(from_file_id, to_file_id, from_label, to_label)
 
622
        try:
 
623
            from_text = tree.get_file(self.file_id).readlines()
 
624
            if to_entry:
 
625
                to_text = to_tree.get_file(to_entry.file_id).readlines()
 
626
            else:
 
627
                to_text = []
 
628
            if not reverse:
 
629
                text_diff(from_label, from_text,
 
630
                          to_label, to_text, output_to)
 
631
            else:
 
632
                text_diff(to_label, to_text,
 
633
                          from_label, from_text, output_to)
 
634
        except errors.BinaryFile:
 
635
            if reverse:
 
636
                label_pair = (to_label, from_label)
 
637
            else:
 
638
                label_pair = (from_label, to_label)
 
639
            output_to.write(
 
640
                  ("Binary files %s and %s differ\n" % label_pair).encode('utf8'))
529
641
 
530
642
    def has_text(self):
531
643
        """See InventoryEntry.has_text."""
623
735
    def _diff(self, text_diff, from_label, tree, to_label, to_entry, to_tree,
624
736
             output_to, reverse=False):
625
737
        """See InventoryEntry._diff."""
626
 
        from bzrlib.diff import DiffSymlink
627
 
        old_target = self.symlink_target
 
738
        from_text = self.symlink_target
628
739
        if to_entry is not None:
629
 
            new_target = to_entry.symlink_target
630
 
        else:
631
 
            new_target = None
632
 
        if not reverse:
633
 
            old_tree = tree
634
 
            new_tree = to_tree
635
 
        else:
636
 
            old_tree = to_tree
637
 
            new_tree = tree
638
 
            new_target, old_target = old_target, new_target
639
 
        differ = DiffSymlink(old_tree, new_tree, output_to)
640
 
        return differ.diff_symlink(old_target, new_target)
 
740
            to_text = to_entry.symlink_target
 
741
            if reverse:
 
742
                temp = from_text
 
743
                from_text = to_text
 
744
                to_text = temp
 
745
            output_to.write('=== target changed %r => %r\n' % (from_text, to_text))
 
746
        else:
 
747
            if not reverse:
 
748
                output_to.write('=== target was %r\n' % self.symlink_target)
 
749
            else:
 
750
                output_to.write('=== target is %r\n' % self.symlink_target)
641
751
 
642
752
    def __init__(self, file_id, name, parent_id):
643
753
        super(InventoryLink, self).__init__(file_id, name, parent_id)
761
871
        an id of None.
762
872
        """
763
873
        if root_id is not None:
 
874
            assert root_id.__class__ == str
764
875
            self._set_root(InventoryDirectory(root_id, u'', None))
765
876
        else:
766
877
            self.root = None
815
926
                # adds come later
816
927
                continue
817
928
            # 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
 
929
            children[file_id] = getattr(self[file_id], 'children', {})
821
930
            # Remove file_id and the unaltered children. If file_id is not
822
931
            # being deleted it will be reinserted back later.
823
932
            self.remove_recursive_id(file_id)
829
938
        for new_path, new_entry in sorted((np, e) for op, np, f, e in
830
939
                                          delta if np is not None):
831
940
            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, {})
 
941
                new_entry.children = children.get(new_entry.file_id, {})
836
942
            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
943
 
843
944
    def _set_root(self, ie):
844
945
        self.root = ie
850
951
        if self.root is None:
851
952
            return Inventory(root_id=None)
852
953
        other = Inventory(entries.next()[1].file_id)
853
 
        other.root.revision = self.root.revision
854
954
        # copy recursively so we know directories will be added before
855
955
        # their children.  There are more efficient ways than this...
856
956
        for path, entry in entries:
1076
1176
                                         self._byid[entry.file_id])
1077
1177
 
1078
1178
        if entry.parent_id is None:
 
1179
            assert self.root is None and len(self._byid) == 0
1079
1180
            self.root = entry
1080
1181
        else:
1081
1182
            try:
1127
1228
        False
1128
1229
        """
1129
1230
        ie = self[file_id]
 
1231
 
 
1232
        assert ie.parent_id is None or \
 
1233
            self[ie.parent_id].children[ie.name] == ie
 
1234
        
1130
1235
        del self._byid[file_id]
1131
1236
        if ie.parent_id is not None:
1132
1237
            del self[ie.parent_id].children[ie.name]
1220
1325
                if children is None:
1221
1326
                    return None
1222
1327
                cie = children[f]
 
1328
                assert cie.name == f
 
1329
                assert cie.parent_id == parent.file_id
1223
1330
                parent = cie
1224
1331
            except KeyError:
1225
1332
                # or raise an error?
1318
1425
 
1319
1426
    :raises InvalidNormalization: When name is not normalized, and cannot be
1320
1427
        accessed on this platform by the normalized path.
1321
 
    :return: The NFC normalised version of name.
 
1428
    :return: The NFC/NFKC normalised version of name.
1322
1429
    """
1323
1430
    #------- This has been copied to bzrlib.dirstate.DirState.add, please
1324
1431
    # keep them synchronised.