/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: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

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