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

  • Committer: John Arbash Meinel
  • Date: 2007-07-11 23:45:20 UTC
  • mfrom: (2601 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2643.
  • Revision ID: john@arbash-meinel.com-20070711234520-do3h7zw8skbathpz
[merge] bzr.dev 2601

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/repository.py
20
20
lazy_import(globals(), """
21
21
import re
22
22
import time
23
 
import unittest
24
23
 
25
24
from bzrlib import (
26
25
    bzrdir,
27
26
    check,
 
27
    deprecated_graph,
28
28
    errors,
29
29
    generate_ids,
30
30
    gpg,
703
703
        :param revision_ids: an iterable of revisions to graph or None for all.
704
704
        :return: a Graph object with the graph reachable from revision_ids.
705
705
        """
706
 
        result = graph.Graph()
 
706
        result = deprecated_graph.Graph()
707
707
        if not revision_ids:
708
708
            pending = set(self.all_revision_ids())
709
709
            required = set([])
818
818
            yield RevisionTree(self, inv, revision_id)
819
819
 
820
820
    @needs_read_lock
821
 
    def get_ancestry(self, revision_id):
 
821
    def get_ancestry(self, revision_id, topo_sorted=True):
822
822
        """Return a list of revision-ids integrated by a revision.
823
823
 
824
824
        The first element of the list is always None, indicating the origin 
833
833
        if not self.has_revision(revision_id):
834
834
            raise errors.NoSuchRevision(self, revision_id)
835
835
        w = self.get_inventory_weave()
836
 
        candidates = w.get_ancestry(revision_id)
 
836
        candidates = w.get_ancestry(revision_id, topo_sorted)
837
837
        return [None] + candidates # self._eliminate_revisions_not_present(candidates)
838
838
 
839
839
    @needs_read_lock
862
862
        revision_id = osutils.safe_revision_id(revision_id)
863
863
        return self.get_inventory_weave().parent_names(revision_id)
864
864
 
 
865
    def get_parents(self, revision_ids):
 
866
        """See StackedParentsProvider.get_parents"""
 
867
        parents_list = []
 
868
        for revision_id in revision_ids:
 
869
            if revision_id == _mod_revision.NULL_REVISION:
 
870
                parents = []
 
871
            else:
 
872
                try:
 
873
                    parents = self.get_revision(revision_id).parent_ids
 
874
                except errors.NoSuchRevision:
 
875
                    parents = None
 
876
                else:
 
877
                    if len(parents) == 0:
 
878
                        parents = [_mod_revision.NULL_REVISION]
 
879
            parents_list.append(parents)
 
880
        return parents_list
 
881
 
 
882
    def _make_parents_provider(self):
 
883
        return self
 
884
 
 
885
    def get_graph(self, other_repository=None):
 
886
        """Return the graph walker for this repository format"""
 
887
        parents_provider = self._make_parents_provider()
 
888
        if (other_repository is not None and
 
889
            other_repository.bzrdir.transport.base !=
 
890
            self.bzrdir.transport.base):
 
891
            parents_provider = graph._StackedParentsProvider(
 
892
                [parents_provider, other_repository._make_parents_provider()])
 
893
        return graph.Graph(parents_provider)
 
894
 
865
895
    @needs_write_lock
866
896
    def set_make_working_trees(self, new_value):
867
897
        """Set the policy flag for making working trees when creating branches.
1756
1786
InterRepository.register_optimiser(InterRemoteRepository)
1757
1787
 
1758
1788
 
1759
 
class RepositoryTestProviderAdapter(object):
1760
 
    """A tool to generate a suite testing multiple repository formats at once.
1761
 
 
1762
 
    This is done by copying the test once for each transport and injecting
1763
 
    the transport_server, transport_readonly_server, and bzrdir_format and
1764
 
    repository_format classes into each copy. Each copy is also given a new id()
1765
 
    to make it easy to identify.
1766
 
    """
1767
 
 
1768
 
    def __init__(self, transport_server, transport_readonly_server, formats,
1769
 
                 vfs_transport_factory=None):
1770
 
        self._transport_server = transport_server
1771
 
        self._transport_readonly_server = transport_readonly_server
1772
 
        self._vfs_transport_factory = vfs_transport_factory
1773
 
        self._formats = formats
1774
 
    
1775
 
    def adapt(self, test):
1776
 
        result = unittest.TestSuite()
1777
 
        for repository_format, bzrdir_format in self._formats:
1778
 
            from copy import deepcopy
1779
 
            new_test = deepcopy(test)
1780
 
            new_test.transport_server = self._transport_server
1781
 
            new_test.transport_readonly_server = self._transport_readonly_server
1782
 
            # Only override the test's vfs_transport_factory if one was
1783
 
            # specified, otherwise just leave the default in place.
1784
 
            if self._vfs_transport_factory:
1785
 
                new_test.vfs_transport_factory = self._vfs_transport_factory
1786
 
            new_test.bzrdir_format = bzrdir_format
1787
 
            new_test.repository_format = repository_format
1788
 
            def make_new_test_id():
1789
 
                new_id = "%s(%s)" % (new_test.id(), repository_format.__class__.__name__)
1790
 
                return lambda: new_id
1791
 
            new_test.id = make_new_test_id()
1792
 
            result.addTest(new_test)
1793
 
        return result
1794
 
 
1795
 
 
1796
 
class InterRepositoryTestProviderAdapter(object):
1797
 
    """A tool to generate a suite testing multiple inter repository formats.
1798
 
 
1799
 
    This is done by copying the test once for each interrepo provider and injecting
1800
 
    the transport_server, transport_readonly_server, repository_format and 
1801
 
    repository_to_format classes into each copy.
1802
 
    Each copy is also given a new id() to make it easy to identify.
1803
 
    """
1804
 
 
1805
 
    def __init__(self, transport_server, transport_readonly_server, formats):
1806
 
        self._transport_server = transport_server
1807
 
        self._transport_readonly_server = transport_readonly_server
1808
 
        self._formats = formats
1809
 
    
1810
 
    def adapt(self, test):
1811
 
        result = unittest.TestSuite()
1812
 
        for interrepo_class, repository_format, repository_format_to in self._formats:
1813
 
            from copy import deepcopy
1814
 
            new_test = deepcopy(test)
1815
 
            new_test.transport_server = self._transport_server
1816
 
            new_test.transport_readonly_server = self._transport_readonly_server
1817
 
            new_test.interrepo_class = interrepo_class
1818
 
            new_test.repository_format = repository_format
1819
 
            new_test.repository_format_to = repository_format_to
1820
 
            def make_new_test_id():
1821
 
                new_id = "%s(%s)" % (new_test.id(), interrepo_class.__name__)
1822
 
                return lambda: new_id
1823
 
            new_test.id = make_new_test_id()
1824
 
            result.addTest(new_test)
1825
 
        return result
1826
 
 
1827
 
    @staticmethod
1828
 
    def default_test_list():
1829
 
        """Generate the default list of interrepo permutations to test."""
1830
 
        from bzrlib.repofmt import knitrepo, weaverepo
1831
 
        result = []
1832
 
        # test the default InterRepository between format 6 and the current 
1833
 
        # default format.
1834
 
        # XXX: robertc 20060220 reinstate this when there are two supported
1835
 
        # formats which do not have an optimal code path between them.
1836
 
        #result.append((InterRepository,
1837
 
        #               RepositoryFormat6(),
1838
 
        #               RepositoryFormatKnit1()))
1839
 
        for optimiser_class in InterRepository._optimisers:
1840
 
            format_to_test = optimiser_class._get_repo_format_to_test()
1841
 
            if format_to_test is not None:
1842
 
                result.append((optimiser_class,
1843
 
                               format_to_test, format_to_test))
1844
 
        # if there are specific combinations we want to use, we can add them 
1845
 
        # here.
1846
 
        result.append((InterModel1and2,
1847
 
                       weaverepo.RepositoryFormat5(),
1848
 
                       knitrepo.RepositoryFormatKnit3()))
1849
 
        result.append((InterKnit1and2,
1850
 
                       knitrepo.RepositoryFormatKnit1(),
1851
 
                       knitrepo.RepositoryFormatKnit3()))
1852
 
        return result
1853
 
 
1854
 
 
1855
1789
class CopyConverter(object):
1856
1790
    """A repository conversion tool which just performs a copy of the content.
1857
1791