/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 breezy/foreign.py

  • Committer: Robert Collins
  • Date: 2005-12-24 02:20:45 UTC
  • mto: (1185.50.57 bzr-jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1550.
  • Revision ID: robertc@robertcollins.net-20051224022045-14efc8dfa0e1a4e9
Start tests for api usage.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/foreign.py
1
 
# Copyright (C) 2008-2012 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
"""Foreign branch utilities."""
18
 
 
19
 
from .branch import (
20
 
    Branch,
21
 
    )
22
 
from .repository import Repository
23
 
from .revision import Revision
24
 
from . import (
25
 
    errors,
26
 
    registry,
27
 
    )
28
 
 
29
 
 
30
 
class VcsMapping(object):
31
 
    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
32
 
 
33
 
    """
34
 
    # Whether this is an experimental mapping that is still open to changes.
35
 
    experimental = False
36
 
 
37
 
    # Whether this mapping supports exporting and importing all bzr semantics.
38
 
    roundtripping = False
39
 
 
40
 
    # Prefix used when importing revisions native to the foreign VCS (as
41
 
    # opposed to roundtripping bzr-native revisions) using this mapping.
42
 
    revid_prefix = None
43
 
 
44
 
    def __init__(self, vcs):
45
 
        """Create a new VcsMapping.
46
 
 
47
 
        :param vcs: VCS that this mapping maps to Bazaar
48
 
        """
49
 
        self.vcs = vcs
50
 
 
51
 
    def revision_id_bzr_to_foreign(self, bzr_revid):
52
 
        """Parse a bzr revision id and convert it to a foreign revid.
53
 
 
54
 
        :param bzr_revid: The bzr revision id (a string).
55
 
        :return: A foreign revision id, can be any sort of object.
56
 
        """
57
 
        raise NotImplementedError(self.revision_id_bzr_to_foreign)
58
 
 
59
 
    def revision_id_foreign_to_bzr(self, foreign_revid):
60
 
        """Parse a foreign revision id and convert it to a bzr revid.
61
 
 
62
 
        :param foreign_revid: Foreign revision id, can be any sort of object.
63
 
        :return: A bzr revision id.
64
 
        """
65
 
        raise NotImplementedError(self.revision_id_foreign_to_bzr)
66
 
 
67
 
 
68
 
class VcsMappingRegistry(registry.Registry):
69
 
    """Registry for Bazaar<->foreign VCS mappings.
70
 
 
71
 
    There should be one instance of this registry for every foreign VCS.
72
 
    """
73
 
 
74
 
    def register(self, key, factory, help):
75
 
        """Register a mapping between Bazaar and foreign VCS semantics.
76
 
 
77
 
        The factory must be a callable that takes one parameter: the key.
78
 
        It must produce an instance of VcsMapping when called.
79
 
        """
80
 
        if b":" in key:
81
 
            raise ValueError("mapping name can not contain colon (:)")
82
 
        registry.Registry.register(self, key, factory, help)
83
 
 
84
 
    def set_default(self, key):
85
 
        """Set the 'default' key to be a clone of the supplied key.
86
 
 
87
 
        This method must be called once and only once.
88
 
        """
89
 
        self._set_default_key(key)
90
 
 
91
 
    def get_default(self):
92
 
        """Convenience function for obtaining the default mapping to use."""
93
 
        return self.get(self._get_default_key())
94
 
 
95
 
    def revision_id_bzr_to_foreign(self, revid):
96
 
        """Convert a bzr revision id to a foreign revid."""
97
 
        raise NotImplementedError(self.revision_id_bzr_to_foreign)
98
 
 
99
 
 
100
 
class ForeignRevision(Revision):
101
 
    """A Revision from a Foreign repository. Remembers
102
 
    information about foreign revision id and mapping.
103
 
 
104
 
    """
105
 
 
106
 
    def __init__(self, foreign_revid, mapping, *args, **kwargs):
107
 
        if "inventory_sha1" not in kwargs:
108
 
            kwargs["inventory_sha1"] = b""
109
 
        super(ForeignRevision, self).__init__(*args, **kwargs)
110
 
        self.foreign_revid = foreign_revid
111
 
        self.mapping = mapping
112
 
 
113
 
 
114
 
class ForeignVcs(object):
115
 
    """A foreign version control system."""
116
 
 
117
 
    branch_format = None
118
 
 
119
 
    repository_format = None
120
 
 
121
 
    def __init__(self, mapping_registry, abbreviation=None):
122
 
        """Create a new foreign vcs instance.
123
 
 
124
 
        :param mapping_registry: Registry with mappings for this VCS.
125
 
        :param abbreviation: Optional abbreviation ('bzr', 'svn', 'git', etc)
126
 
        """
127
 
        self.abbreviation = abbreviation
128
 
        self.mapping_registry = mapping_registry
129
 
 
130
 
    def show_foreign_revid(self, foreign_revid):
131
 
        """Prepare a foreign revision id for formatting using bzr log.
132
 
 
133
 
        :param foreign_revid: Foreign revision id.
134
 
        :return: Dictionary mapping string keys to string values.
135
 
        """
136
 
        return {}
137
 
 
138
 
    def serialize_foreign_revid(self, foreign_revid):
139
 
        """Serialize a foreign revision id for this VCS.
140
 
 
141
 
        :param foreign_revid: Foreign revision id
142
 
        :return: Bytestring with serialized revid, will not contain any
143
 
            newlines.
144
 
        """
145
 
        raise NotImplementedError(self.serialize_foreign_revid)
146
 
 
147
 
 
148
 
class ForeignVcsRegistry(registry.Registry):
149
 
    """Registry for Foreign VCSes.
150
 
 
151
 
    There should be one entry per foreign VCS. Example entries would be
152
 
    "git", "svn", "hg", "darcs", etc.
153
 
 
154
 
    """
155
 
 
156
 
    def register(self, key, foreign_vcs, help):
157
 
        """Register a foreign VCS.
158
 
 
159
 
        :param key: Prefix of the foreign VCS in revision ids
160
 
        :param foreign_vcs: ForeignVCS instance
161
 
        :param help: Description of the foreign VCS
162
 
        """
163
 
        if ":" in key or "-" in key:
164
 
            raise ValueError("vcs name can not contain : or -")
165
 
        registry.Registry.register(self, key, foreign_vcs, help)
166
 
 
167
 
    def parse_revision_id(self, revid):
168
 
        """Parse a bzr revision and return the matching mapping and foreign
169
 
        revid.
170
 
 
171
 
        :param revid: The bzr revision id
172
 
        :return: tuple with foreign revid and vcs mapping
173
 
        """
174
 
        if b":" not in revid or b"-" not in revid:
175
 
            raise errors.InvalidRevisionId(revid, None)
176
 
        try:
177
 
            foreign_vcs = self.get(revid.split(b"-")[0].decode('ascii'))
178
 
        except KeyError:
179
 
            raise errors.InvalidRevisionId(revid, None)
180
 
        return foreign_vcs.mapping_registry.revision_id_bzr_to_foreign(revid)
181
 
 
182
 
 
183
 
foreign_vcs_registry = ForeignVcsRegistry()
184
 
 
185
 
 
186
 
class ForeignRepository(Repository):
187
 
    """A Repository that exists in a foreign version control system.
188
 
 
189
 
    The data in this repository can not be represented natively using
190
 
    Bazaars internal datastructures, but have to converted using a VcsMapping.
191
 
    """
192
 
 
193
 
    # This repository's native version control system
194
 
    vcs = None
195
 
 
196
 
    def has_foreign_revision(self, foreign_revid):
197
 
        """Check whether the specified foreign revision is present.
198
 
 
199
 
        :param foreign_revid: A foreign revision id, in the format used
200
 
                              by this Repository's VCS.
201
 
        """
202
 
        raise NotImplementedError(self.has_foreign_revision)
203
 
 
204
 
    def lookup_bzr_revision_id(self, revid):
205
 
        """Lookup a mapped or roundtripped revision by revision id.
206
 
 
207
 
        :param revid: Bazaar revision id
208
 
        :return: Tuple with foreign revision id and mapping.
209
 
        """
210
 
        raise NotImplementedError(self.lookup_revision_id)
211
 
 
212
 
    def all_revision_ids(self, mapping=None):
213
 
        """See Repository.all_revision_ids()."""
214
 
        raise NotImplementedError(self.all_revision_ids)
215
 
 
216
 
    def get_default_mapping(self):
217
 
        """Get the default mapping for this repository."""
218
 
        raise NotImplementedError(self.get_default_mapping)
219
 
 
220
 
 
221
 
class ForeignBranch(Branch):
222
 
    """Branch that exists in a foreign version control system."""
223
 
 
224
 
    def __init__(self, mapping):
225
 
        self.mapping = mapping
226
 
        super(ForeignBranch, self).__init__()