/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: Jelmer Vernooij
  • Date: 2020-02-07 02:14:30 UTC
  • mto: This revision was merged to the branch mainline in revision 7492.
  • Revision ID: jelmer@jelmer.uk-20200207021430-m49iq3x4x8xlib6x
Drop python2 support.

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__()