/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 __init__.py

Fix formatting, drop support for Bazaar < 2.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
 
1
# Copyright (C) 2006-2009 Canonical Ltd
 
2
 
 
3
# Authors: Robert Collins <robert.collins@canonical.com>
 
4
#          Jelmer Vernooij <jelmer@samba.org>
 
5
#          John Carr <john.carr@unrouted.co.uk>
 
6
#
 
7
# This program is free software; you can redistribute it and/or modify
 
8
# it under the terms of the GNU General Public License as published by
 
9
# the Free Software Foundation; either version 2 of the License, or
 
10
# (at your option) any later version.
 
11
#
 
12
# This program is distributed in the hope that it will be useful,
 
13
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
# GNU General Public License for more details.
 
16
#
 
17
# You should have received a copy of the GNU General Public License
 
18
# along with this program; if not, write to the Free Software
 
19
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
20
 
 
21
 
 
22
"""A GIT branch and repository format implementation for bzr."""
 
23
 
 
24
import os
 
25
import sys
 
26
 
 
27
import bzrlib
 
28
import bzrlib.api
 
29
 
 
30
from info import (
 
31
    bzr_compatible_versions,
 
32
    bzr_plugin_version as version_info,
 
33
    dulwich_minimum_version,
 
34
    )
 
35
 
 
36
if version_info[3] == 'final':
 
37
    version_string = '%d.%d.%d' % version_info[:3]
 
38
else:
 
39
    version_string = '%d.%d.%d%s%d' % version_info
 
40
__version__ = version_string
 
41
 
 
42
bzrlib.api.require_any_api(bzrlib, bzr_compatible_versions)
 
43
 
 
44
 
 
45
from bzrlib import (
 
46
    bzrdir,
 
47
    errors as bzr_errors,
 
48
    osutils,
 
49
    )
 
50
from bzrlib.foreign import (
 
51
    foreign_vcs_registry,
 
52
    )
 
53
from bzrlib.lockable_files import (
 
54
    TransportLock,
 
55
    )
 
56
from bzrlib.transport import (
 
57
    register_lazy_transport,
 
58
    register_transport_proto,
 
59
    )
 
60
from bzrlib.commands import (
 
61
    plugin_cmds,
 
62
    )
 
63
from bzrlib.version_info_formats.format_rio import (
 
64
    RioVersionInfoBuilder,
 
65
    )
 
66
from bzrlib.send import (
 
67
    format_registry as send_format_registry,
 
68
    )
 
69
 
 
70
 
 
71
if getattr(sys, "frozen", None):
 
72
    # allow import additional libs from ./_lib for bzr.exe only
 
73
    sys.path.append(os.path.normpath(
 
74
        os.path.join(os.path.dirname(__file__), '_lib')))
 
75
 
 
76
_versions_checked = False
 
77
def lazy_check_versions():
 
78
    global _versions_checked
 
79
    if _versions_checked:
 
80
        return
 
81
    _versions_checked = True
 
82
    try:
 
83
        from dulwich import __version__ as dulwich_version
 
84
    except ImportError:
 
85
        raise bzr_errors.DependencyNotPresent("dulwich",
 
86
            "bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
87
    else:
 
88
        if dulwich_version < dulwich_minimum_version:
 
89
            raise bzr_errors.DependencyNotPresent("dulwich",
 
90
                "bzr-git: Dulwich is too old; at least %d.%d.%d is required" %
 
91
                    dulwich_minimum_version)
 
92
 
 
93
bzrdir.format_registry.register_lazy('git',
 
94
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
 
95
    help='GIT repository.', native=False, experimental=True,
 
96
    )
 
97
 
 
98
from bzrlib.revisionspec import revspec_registry
 
99
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
 
100
    "RevisionSpec_git")
 
101
 
 
102
try:
 
103
    from bzrlib.revisionspec import dwim_revspecs
 
104
except ImportError:
 
105
    pass
 
106
else:
 
107
    from bzrlib.plugins.git.revspec import RevisionSpec_git
 
108
    dwim_revspecs.append(RevisionSpec_git)
 
109
 
 
110
 
 
111
class GitBzrDirFormat(bzrdir.BzrDirFormat):
 
112
 
 
113
    _lock_class = TransportLock
 
114
 
 
115
    colocated_branches = True
 
116
 
 
117
    def is_supported(self):
 
118
        return True
 
119
 
 
120
    def network_name(self):
 
121
        return "git"
 
122
 
 
123
 
 
124
class LocalGitBzrDirFormat(GitBzrDirFormat):
 
125
    """The .git directory control format."""
 
126
 
 
127
    @classmethod
 
128
    def _known_formats(self):
 
129
        return set([LocalGitBzrDirFormat()])
 
130
 
 
131
    def open(self, transport, _found=None):
 
132
        """Open this directory.
 
133
 
 
134
        """
 
135
        lazy_check_versions()
 
136
        # we dont grok readonly - git isn't integrated with transport.
 
137
        from bzrlib.transport.local import LocalTransport
 
138
        if isinstance(transport, LocalTransport):
 
139
            import dulwich
 
140
            path = transport.local_abspath(".").encode(osutils._fs_enc)
 
141
            gitrepo = dulwich.repo.Repo(path)
 
142
        else:
 
143
            from bzrlib.plugins.git.transportgit import TransportRepo
 
144
            gitrepo = TransportRepo(transport)
 
145
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
 
146
        lockfiles = GitLockableFiles(transport, GitLock())
 
147
        return LocalGitDir(transport, lockfiles, gitrepo, self)
 
148
 
 
149
    @classmethod
 
150
    def probe_transport(klass, transport):
 
151
        try:
 
152
            if not transport.has_any(['info/refs', '.git/branches',
 
153
                                      'branches']):
 
154
                raise bzr_errors.NotBranchError(path=transport.base)
 
155
        except bzr_errors.NoSuchFile:
 
156
            raise bzr_errors.NotBranchError(path=transport.base)
 
157
        from bzrlib import urlutils
 
158
        if urlutils.split(transport.base)[1] == ".git":
 
159
            raise bzr_errors.NotBranchError(path=transport.base)
 
160
        lazy_check_versions()
 
161
        import dulwich
 
162
        format = klass()
 
163
        try:
 
164
            format.open(transport)
 
165
            return format
 
166
        except dulwich.errors.NotGitRepository, e:
 
167
            raise bzr_errors.NotBranchError(path=transport.base)
 
168
        raise bzr_errors.NotBranchError(path=transport.base)
 
169
 
 
170
    def get_format_description(self):
 
171
        return "Local Git Repository"
 
172
 
 
173
    def get_format_string(self):
 
174
        return "Local Git Repository"
 
175
 
 
176
    def initialize_on_transport(self, transport):
 
177
        from bzrlib.transport.local import LocalTransport
 
178
 
 
179
        if not isinstance(transport, LocalTransport):
 
180
            raise NotImplementedError(self.initialize,
 
181
                "Can't create Git Repositories/branches on "
 
182
                "non-local transports")
 
183
        lazy_check_versions()
 
184
        from dulwich.repo import Repo
 
185
        Repo.init(transport.local_abspath(".").encode(osutils._fs_enc))
 
186
        return self.open(transport)
 
187
 
 
188
    def is_supported(self):
 
189
        return True
 
190
 
 
191
 
 
192
class RemoteGitBzrDirFormat(GitBzrDirFormat):
 
193
    """The .git directory control format."""
 
194
 
 
195
    @classmethod
 
196
    def _known_formats(self):
 
197
        return set([RemoteGitBzrDirFormat()])
 
198
 
 
199
    def open(self, transport, _found=None):
 
200
        """Open this directory.
 
201
 
 
202
        """
 
203
        # we dont grok readonly - git isn't integrated with transport.
 
204
        url = transport.base
 
205
        if url.startswith('readonly+'):
 
206
            url = url[len('readonly+'):]
 
207
        if (not url.startswith("git://") and not url.startswith("git+")):
 
208
            raise bzr_errors.NotBranchError(transport.base)
 
209
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
210
        if not isinstance(transport, GitSmartTransport):
 
211
            raise bzr_errors.NotBranchError(transport.base)
 
212
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
213
        lockfiles = GitLockableFiles(transport, GitLock())
 
214
        return RemoteGitDir(transport, lockfiles, self)
 
215
 
 
216
    @classmethod
 
217
    def probe_transport(klass, transport):
 
218
        """Our format is present if the transport ends in '.not/'."""
 
219
        url = transport.base
 
220
        if url.startswith('readonly+'):
 
221
            url = url[len('readonly+'):]
 
222
        if (not url.startswith("git://") and not url.startswith("git+")):
 
223
            raise bzr_errors.NotBranchError(transport.base)
 
224
        # little ugly, but works
 
225
        format = klass()
 
226
        from bzrlib.plugins.git.remote import GitSmartTransport
 
227
        if not isinstance(transport, GitSmartTransport):
 
228
            raise bzr_errors.NotBranchError(transport.base)
 
229
        return format
 
230
 
 
231
    def get_format_description(self):
 
232
        return "Remote Git Repository"
 
233
 
 
234
    def get_format_string(self):
 
235
        return "Remote Git Repository"
 
236
 
 
237
    def initialize_on_transport(self, transport):
 
238
        raise bzr_errors.UninitializableFormat(self)
 
239
 
 
240
 
 
241
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
 
242
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
 
243
 
 
244
register_transport_proto('git://',
 
245
        help="Access using the Git smart server protocol.")
 
246
register_transport_proto('git+ssh://',
 
247
        help="Access using the Git smart server protocol over SSH.")
 
248
 
 
249
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
250
                        'TCPGitSmartTransport')
 
251
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
252
                        'SSHGitSmartTransport')
 
253
 
 
254
foreign_vcs_registry.register_lazy("git",
 
255
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
256
 
 
257
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
258
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
 
259
    "bzrlib.plugins.git.commands")
 
260
plugin_cmds.register_lazy("cmd_git_refs", [], "bzrlib.plugins.git.commands")
 
261
plugin_cmds.register_lazy("cmd_git_apply", [], "bzrlib.plugins.git.commands")
 
262
 
 
263
def update_stanza(rev, stanza):
 
264
    mapping = getattr(rev, "mapping", None)
 
265
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
266
        stanza.add("git-commit", rev.foreign_revid)
 
267
 
 
268
 
 
269
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
 
270
if rio_hooks is not None:
 
271
    rio_hooks.install_named_hook('revision', update_stanza, None)
 
272
 
 
273
 
 
274
from bzrlib.transport import transport_server_registry
 
275
transport_server_registry.register_lazy('git',
 
276
    'bzrlib.plugins.git.server',
 
277
    'serve_git',
 
278
    'Git Smart server protocol over TCP. (default port: 9418)')
 
279
 
 
280
 
 
281
from bzrlib.repository import (
 
282
    network_format_registry as repository_network_format_registry,
 
283
    )
 
284
repository_network_format_registry.register_lazy('git',
 
285
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
286
 
 
287
from bzrlib.bzrdir import (
 
288
    network_format_registry as bzrdir_network_format_registry,
 
289
    )
 
290
bzrdir_network_format_registry.register('git', GitBzrDirFormat)
 
291
 
 
292
 
 
293
def get_rich_root_format(stacked=False):
 
294
    return bzrdir.format_registry.make_bzrdir("default-rich-root")
 
295
 
 
296
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
297
                                   'send_git', 'Git am-style diff format')
 
298
 
 
299
try:
 
300
    from bzrlib.diff import format_registry as diff_format_registry
 
301
except ImportError:
 
302
    pass
 
303
else:
 
304
    diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
305
        'GitDiffTree', 'Git am-style diff format')
 
306
 
 
307
def test_suite():
 
308
    from bzrlib.plugins.git import tests
 
309
    return tests.test_suite()