/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/tree.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-04-11 18:31:46 UTC
  • mfrom: (5777.3.6 inventorytree)
  • Revision ID: pqm@pqm.ubuntu.com-20110411183146-s7r7m89gnp0dl3sr
(jelmer) Split inventory-specific functionality out of Tree into
 InventoryTree. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tree.py
50
50
 
51
51
    * `RevisionTree` is a tree as recorded at some point in the past.
52
52
 
53
 
    Trees contain an `Inventory` object, and also know how to retrieve
54
 
    file texts mentioned in the inventory, either from a working
55
 
    directory or from a store.
56
 
 
57
 
    It is possible for trees to contain files that are not described
58
 
    in their inventory or vice versa; for this use `filenames()`.
59
 
 
60
53
    Trees can be compared, etc, regardless of whether they are working
61
54
    trees or versioned trees.
62
55
    """
128
121
        raise NotImplementedError(self.has_filename)
129
122
 
130
123
    def has_id(self, file_id):
131
 
        return self.inventory.has_id(file_id)
 
124
        raise NotImplementedError(self.has_id)
132
125
 
133
126
    def __contains__(self, file_id):
134
127
        return self.has_id(file_id)
135
128
 
136
129
    def has_or_had_id(self, file_id):
137
 
        return self.inventory.has_id(file_id)
 
130
        raise NotImplementedError(self.has_or_had_id)
138
131
 
139
132
    def is_ignored(self, filename):
140
133
        """Check whether the filename is ignored by this tree.
145
138
        return False
146
139
 
147
140
    def __iter__(self):
148
 
        return iter(self.inventory)
 
141
        """Yield all file ids in this tree."""
 
142
        raise NotImplementedError(self.__iter__)
149
143
 
150
144
    def all_file_ids(self):
151
145
        """Iterate through all file ids, including ids for missing files."""
156
150
 
157
151
        :raises NoSuchId:
158
152
        """
159
 
        return self.inventory.id2path(file_id)
 
153
        raise NotImplementedError(self.id2path)
160
154
 
161
 
    @needs_read_lock
162
155
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
163
156
        """Walk the tree in 'by_dir' order.
164
157
 
187
180
            down to specific_file_ids that have been requested. This has no
188
181
            impact if specific_file_ids is None.
189
182
        """
190
 
        return self.inventory.iter_entries_by_dir(
191
 
            specific_file_ids=specific_file_ids, yield_parents=yield_parents)
 
183
        raise NotImplementedError(self.iter_entries_by_dir)
192
184
 
193
185
    def iter_references(self):
194
186
        if self.supports_tree_reference():
245
237
    def _file_size(self, entry, stat_value):
246
238
        raise NotImplementedError(self._file_size)
247
239
 
248
 
    def _get_inventory(self):
249
 
        return self._inventory
250
 
 
251
240
    def get_file(self, file_id, path=None):
252
241
        """Return a file object for the file file_id in the tree.
253
242
 
322
311
        raise NotImplementedError(self.get_file_size)
323
312
 
324
313
    def get_file_by_path(self, path):
325
 
        return self.get_file(self._inventory.path2id(path), path)
 
314
        raise NotImplementedError(self.get_file_by_path)
326
315
 
327
316
    def is_executable(self, file_id, path=None):
328
317
        """Check if a file is executable.
369
358
        """
370
359
        raise NotImplementedError(self.get_symlink_target)
371
360
 
372
 
    def get_canonical_inventory_paths(self, paths):
373
 
        """Like get_canonical_inventory_path() but works on multiple items.
374
 
 
375
 
        :param paths: A sequence of paths relative to the root of the tree.
376
 
        :return: A list of paths, with each item the corresponding input path
377
 
        adjusted to account for existing elements that match case
378
 
        insensitively.
379
 
        """
380
 
        return list(self._yield_canonical_inventory_paths(paths))
381
 
 
382
 
    def get_canonical_inventory_path(self, path):
383
 
        """Returns the first inventory item that case-insensitively matches path.
384
 
 
385
 
        If a path matches exactly, it is returned. If no path matches exactly
386
 
        but more than one path matches case-insensitively, it is implementation
387
 
        defined which is returned.
388
 
 
389
 
        If no path matches case-insensitively, the input path is returned, but
390
 
        with as many path entries that do exist changed to their canonical
391
 
        form.
392
 
 
393
 
        If you need to resolve many names from the same tree, you should
394
 
        use get_canonical_inventory_paths() to avoid O(N) behaviour.
395
 
 
396
 
        :param path: A paths relative to the root of the tree.
397
 
        :return: The input path adjusted to account for existing elements
398
 
        that match case insensitively.
399
 
        """
400
 
        return self._yield_canonical_inventory_paths([path]).next()
401
 
 
402
 
    def _yield_canonical_inventory_paths(self, paths):
403
 
        for path in paths:
404
 
            # First, if the path as specified exists exactly, just use it.
405
 
            if self.path2id(path) is not None:
406
 
                yield path
407
 
                continue
408
 
            # go walkin...
409
 
            cur_id = self.get_root_id()
410
 
            cur_path = ''
411
 
            bit_iter = iter(path.split("/"))
412
 
            for elt in bit_iter:
413
 
                lelt = elt.lower()
414
 
                new_path = None
415
 
                for child in self.iter_children(cur_id):
416
 
                    try:
417
 
                        # XXX: it seem like if the child is known to be in the
418
 
                        # tree, we shouldn't need to go from its id back to
419
 
                        # its path -- mbp 2010-02-11
420
 
                        #
421
 
                        # XXX: it seems like we could be more efficient
422
 
                        # by just directly looking up the original name and
423
 
                        # only then searching all children; also by not
424
 
                        # chopping paths so much. -- mbp 2010-02-11
425
 
                        child_base = os.path.basename(self.id2path(child))
426
 
                        if (child_base == elt):
427
 
                            # if we found an exact match, we can stop now; if
428
 
                            # we found an approximate match we need to keep
429
 
                            # searching because there might be an exact match
430
 
                            # later.  
431
 
                            cur_id = child
432
 
                            new_path = osutils.pathjoin(cur_path, child_base)
433
 
                            break
434
 
                        elif child_base.lower() == lelt:
435
 
                            cur_id = child
436
 
                            new_path = osutils.pathjoin(cur_path, child_base)
437
 
                    except errors.NoSuchId:
438
 
                        # before a change is committed we can see this error...
439
 
                        continue
440
 
                if new_path:
441
 
                    cur_path = new_path
442
 
                else:
443
 
                    # got to the end of this directory and no entries matched.
444
 
                    # Return what matched so far, plus the rest as specified.
445
 
                    cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
446
 
                    break
447
 
            yield cur_path
448
 
        # all done.
449
361
 
450
362
    def get_root_id(self):
451
363
        """Return the file_id for the root of this tree."""
513
425
    @staticmethod
514
426
    def _file_revision(revision_tree, file_id):
515
427
        """Determine the revision associated with a file in a given tree."""
 
428
        # FIXME: Shouldn't this be a RevisionTree method?
516
429
        revision_tree.lock_read()
517
430
        try:
518
431
            return revision_tree.inventory[file_id].revision
537
450
            vf.fallback_versionedfiles.append(base_vf)
538
451
        return last_revision
539
452
 
540
 
    inventory = property(_get_inventory,
541
 
                         doc="Inventory of this Tree")
542
 
 
543
453
    def _check_retrieved(self, ie, f):
544
454
        if not __debug__:
545
455
            return
562
472
                     "file is actually %s" % fp['sha1'],
563
473
                     "store is probably damaged/corrupt"])
564
474
 
565
 
    @needs_read_lock
566
475
    def path2id(self, path):
567
476
        """Return the id for path in this tree."""
568
 
        return self._inventory.path2id(path)
 
477
        raise NotImplementedError(self.path2id)
569
478
 
570
479
    def paths2ids(self, paths, trees=[], require_versioned=True):
571
480
        """Return all the ids that can be reached by walking from paths.
628
537
 
629
538
        :return: set of paths.
630
539
        """
631
 
        # NB: we specifically *don't* call self.has_filename, because for
632
 
        # WorkingTrees that can indicate files that exist on disk but that
633
 
        # are not versioned.
634
 
        pred = self.inventory.has_filename
635
 
        return set((p for p in paths if not pred(p)))
 
540
        raise NotImplementedError(self.filter_unversioned_files)
636
541
 
637
542
    def walkdirs(self, prefix=""):
638
543
        """Walk the contents of this tree from path down.
735
640
        return searcher
736
641
 
737
642
 
 
643
class InventoryTree(Tree):
 
644
    """A tree that relies on an inventory for its metadata.
 
645
 
 
646
    Trees contain an `Inventory` object, and also know how to retrieve
 
647
    file texts mentioned in the inventory, either from a working
 
648
    directory or from a store.
 
649
 
 
650
    It is possible for trees to contain files that are not described
 
651
    in their inventory or vice versa; for this use `filenames()`.
 
652
 
 
653
    Subclasses should set the _inventory attribute, which is considered
 
654
    private to external API users.
 
655
    """
 
656
 
 
657
    def get_canonical_inventory_paths(self, paths):
 
658
        """Like get_canonical_inventory_path() but works on multiple items.
 
659
 
 
660
        :param paths: A sequence of paths relative to the root of the tree.
 
661
        :return: A list of paths, with each item the corresponding input path
 
662
        adjusted to account for existing elements that match case
 
663
        insensitively.
 
664
        """
 
665
        return list(self._yield_canonical_inventory_paths(paths))
 
666
 
 
667
    def get_canonical_inventory_path(self, path):
 
668
        """Returns the first inventory item that case-insensitively matches path.
 
669
 
 
670
        If a path matches exactly, it is returned. If no path matches exactly
 
671
        but more than one path matches case-insensitively, it is implementation
 
672
        defined which is returned.
 
673
 
 
674
        If no path matches case-insensitively, the input path is returned, but
 
675
        with as many path entries that do exist changed to their canonical
 
676
        form.
 
677
 
 
678
        If you need to resolve many names from the same tree, you should
 
679
        use get_canonical_inventory_paths() to avoid O(N) behaviour.
 
680
 
 
681
        :param path: A paths relative to the root of the tree.
 
682
        :return: The input path adjusted to account for existing elements
 
683
        that match case insensitively.
 
684
        """
 
685
        return self._yield_canonical_inventory_paths([path]).next()
 
686
 
 
687
    def _yield_canonical_inventory_paths(self, paths):
 
688
        for path in paths:
 
689
            # First, if the path as specified exists exactly, just use it.
 
690
            if self.path2id(path) is not None:
 
691
                yield path
 
692
                continue
 
693
            # go walkin...
 
694
            cur_id = self.get_root_id()
 
695
            cur_path = ''
 
696
            bit_iter = iter(path.split("/"))
 
697
            for elt in bit_iter:
 
698
                lelt = elt.lower()
 
699
                new_path = None
 
700
                for child in self.iter_children(cur_id):
 
701
                    try:
 
702
                        # XXX: it seem like if the child is known to be in the
 
703
                        # tree, we shouldn't need to go from its id back to
 
704
                        # its path -- mbp 2010-02-11
 
705
                        #
 
706
                        # XXX: it seems like we could be more efficient
 
707
                        # by just directly looking up the original name and
 
708
                        # only then searching all children; also by not
 
709
                        # chopping paths so much. -- mbp 2010-02-11
 
710
                        child_base = os.path.basename(self.id2path(child))
 
711
                        if (child_base == elt):
 
712
                            # if we found an exact match, we can stop now; if
 
713
                            # we found an approximate match we need to keep
 
714
                            # searching because there might be an exact match
 
715
                            # later.  
 
716
                            cur_id = child
 
717
                            new_path = osutils.pathjoin(cur_path, child_base)
 
718
                            break
 
719
                        elif child_base.lower() == lelt:
 
720
                            cur_id = child
 
721
                            new_path = osutils.pathjoin(cur_path, child_base)
 
722
                    except errors.NoSuchId:
 
723
                        # before a change is committed we can see this error...
 
724
                        continue
 
725
                if new_path:
 
726
                    cur_path = new_path
 
727
                else:
 
728
                    # got to the end of this directory and no entries matched.
 
729
                    # Return what matched so far, plus the rest as specified.
 
730
                    cur_path = osutils.pathjoin(cur_path, elt, *list(bit_iter))
 
731
                    break
 
732
            yield cur_path
 
733
        # all done.
 
734
 
 
735
    def _get_inventory(self):
 
736
        return self._inventory
 
737
 
 
738
    inventory = property(_get_inventory,
 
739
                         doc="Inventory of this Tree")
 
740
 
 
741
    @needs_read_lock
 
742
    def path2id(self, path):
 
743
        """Return the id for path in this tree."""
 
744
        return self._inventory.path2id(path)
 
745
 
 
746
    def id2path(self, file_id):
 
747
        """Return the path for a file id.
 
748
 
 
749
        :raises NoSuchId:
 
750
        """
 
751
        return self.inventory.id2path(file_id)
 
752
 
 
753
    def has_id(self, file_id):
 
754
        return self.inventory.has_id(file_id)
 
755
 
 
756
    def has_or_had_id(self, file_id):
 
757
        return self.inventory.has_id(file_id)
 
758
 
 
759
    def __iter__(self):
 
760
        return iter(self.inventory)
 
761
 
 
762
    def filter_unversioned_files(self, paths):
 
763
        """Filter out paths that are versioned.
 
764
 
 
765
        :return: set of paths.
 
766
        """
 
767
        # NB: we specifically *don't* call self.has_filename, because for
 
768
        # WorkingTrees that can indicate files that exist on disk but that
 
769
        # are not versioned.
 
770
        pred = self.inventory.has_filename
 
771
        return set((p for p in paths if not pred(p)))
 
772
 
 
773
    @needs_read_lock
 
774
    def iter_entries_by_dir(self, specific_file_ids=None, yield_parents=False):
 
775
        """Walk the tree in 'by_dir' order.
 
776
 
 
777
        This will yield each entry in the tree as a (path, entry) tuple.
 
778
        The order that they are yielded is:
 
779
 
 
780
        See Tree.iter_entries_by_dir for details.
 
781
 
 
782
        :param yield_parents: If True, yield the parents from the root leading
 
783
            down to specific_file_ids that have been requested. This has no
 
784
            impact if specific_file_ids is None.
 
785
        """
 
786
        return self.inventory.iter_entries_by_dir(
 
787
            specific_file_ids=specific_file_ids, yield_parents=yield_parents)
 
788
 
 
789
    def get_file_by_path(self, path):
 
790
        return self.get_file(self._inventory.path2id(path), path)
 
791
 
 
792
 
738
793
######################################################################
739
794
# diff
740
795