/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

[merge] robertc's integration, updated tests to check for retcode=3

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