← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/repository.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-04-26 21:11:03 UTC
  • mfrom: (2447.1.7 bundle_empty_properties)
  • Revision ID: pqm@pqm.ubuntu.com-20070426211103-h84prqh7a4ad3ez2
(John Arbash Meinel) Fix bug #109613 by teaching Bundle how to properly read/write revision properties with no value.

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
23
24
 
24
25
from bzrlib import (
25
26
    bzrdir,
26
27
    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 = deprecated_graph.Graph()
 
706
        result = 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, topo_sorted=True):
 
821
    def get_ancestry(self, revision_id):
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, topo_sorted)
 
836
        candidates = w.get_ancestry(revision_id)
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
 
 
895
865
    @needs_write_lock
896
866
    def set_make_working_trees(self, new_value):
897
867
        """Set the policy flag for making working trees when creating branches.
1786
1756
InterRepository.register_optimiser(InterRemoteRepository)
1787
1757
 
1788
1758
 
 
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
 
1789
1855
class CopyConverter(object):
1790
1856
    """A repository conversion tool which just performs a copy of the content.
1791
1857