/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

More renames.

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
    errors as bzr_errors,
 
47
    osutils,
 
48
    )
 
49
try:
 
50
    from bzrlib.controldir import (
 
51
        ControlDirFormat,
 
52
        ControlDir,
 
53
        Prober,
 
54
        format_registry,
 
55
        )
 
56
except ImportError:
 
57
    # bzr < 2.3
 
58
    from bzrlib.bzrdir import (
 
59
        BzrDirFormat,
 
60
        BzrDir,
 
61
        format_registry,
 
62
        )
 
63
    ControlDir = BzrDir
 
64
    ControlDirFormat = BzrDirFormat
 
65
    has_controldir = False
 
66
else:
 
67
    has_controldir = True
 
68
 
 
69
from bzrlib.foreign import (
 
70
    foreign_vcs_registry,
 
71
    )
 
72
from bzrlib.help_topics import (
 
73
    topic_registry,
 
74
    )
 
75
from bzrlib.lockable_files import (
 
76
    TransportLock,
 
77
    )
 
78
from bzrlib.transport import (
 
79
    register_lazy_transport,
 
80
    register_transport_proto,
 
81
    )
 
82
from bzrlib.commands import (
 
83
    plugin_cmds,
 
84
    )
 
85
from bzrlib.version_info_formats.format_rio import (
 
86
    RioVersionInfoBuilder,
 
87
    )
 
88
from bzrlib.send import (
 
89
    format_registry as send_format_registry,
 
90
    )
 
91
 
 
92
 
 
93
if getattr(sys, "frozen", None):
 
94
    # allow import additional libs from ./_lib for bzr.exe only
 
95
    sys.path.append(os.path.normpath(
 
96
        os.path.join(os.path.dirname(__file__), '_lib')))
 
97
 
 
98
 
 
99
def import_dulwich():
 
100
    try:
 
101
        from dulwich import __version__ as dulwich_version
 
102
    except ImportError:
 
103
        raise bzr_errors.DependencyNotPresent("dulwich",
 
104
            "bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
105
    else:
 
106
        if dulwich_version < dulwich_minimum_version:
 
107
            raise bzr_errors.DependencyNotPresent("dulwich",
 
108
                "bzr-git: Dulwich is too old; at least %d.%d.%d is required" %
 
109
                    dulwich_minimum_version)
 
110
 
 
111
 
 
112
_versions_checked = False
 
113
def lazy_check_versions():
 
114
    global _versions_checked
 
115
    if _versions_checked:
 
116
        return
 
117
    import_dulwich()
 
118
    _versions_checked = True
 
119
 
 
120
format_registry.register_lazy('git',
 
121
    "bzrlib.plugins.git.dir", "LocalGitControlDirFormat",
 
122
    help='GIT repository.', native=False, experimental=True,
 
123
    )
 
124
 
 
125
from bzrlib.revisionspec import revspec_registry
 
126
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
 
127
    "RevisionSpec_git")
 
128
 
 
129
try:
 
130
    from bzrlib.revisionspec import dwim_revspecs
 
131
except ImportError:
 
132
    pass
 
133
else:
 
134
    from bzrlib.plugins.git.revspec import RevisionSpec_git
 
135
    dwim_revspecs.append(RevisionSpec_git)
 
136
 
 
137
 
 
138
class GitControlDirFormat(ControlDirFormat):
 
139
 
 
140
    _lock_class = TransportLock
 
141
 
 
142
    colocated_branches = True
 
143
 
 
144
    def __eq__(self, other):
 
145
        return type(self) == type(other)
 
146
 
 
147
    def is_supported(self):
 
148
        return True
 
149
 
 
150
    def network_name(self):
 
151
        return "git"
 
152
 
 
153
 
 
154
class LocalGitControlDirFormat(GitControlDirFormat):
 
155
    """The .git directory control format."""
 
156
 
 
157
    @classmethod
 
158
    def _known_formats(self):
 
159
        return set([LocalGitControlDirFormat()])
 
160
 
 
161
    def open(self, transport, _found=None):
 
162
        """Open this directory.
 
163
 
 
164
        """
 
165
        lazy_check_versions()
 
166
        from bzrlib.plugins.git.transportgit import TransportRepo
 
167
        gitrepo = TransportRepo(transport)
 
168
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
 
169
        lockfiles = GitLockableFiles(transport, GitLock())
 
170
        return LocalGitDir(transport, lockfiles, gitrepo, self)
 
171
 
 
172
    @classmethod
 
173
    def probe_transport(klass, transport):
 
174
        try:
 
175
            if not transport.has_any(['info/refs', '.git/branches',
 
176
                                      'branches']):
 
177
                raise bzr_errors.NotBranchError(path=transport.base)
 
178
        except bzr_errors.NoSuchFile:
 
179
            raise bzr_errors.NotBranchError(path=transport.base)
 
180
        from bzrlib import urlutils
 
181
        if urlutils.split(transport.base)[1] == ".git":
 
182
            raise bzr_errors.NotBranchError(path=transport.base)
 
183
        lazy_check_versions()
 
184
        import dulwich
 
185
        format = klass()
 
186
        try:
 
187
            format.open(transport)
 
188
            return format
 
189
        except dulwich.errors.NotGitRepository, e:
 
190
            raise bzr_errors.NotBranchError(path=transport.base)
 
191
        raise bzr_errors.NotBranchError(path=transport.base)
 
192
 
 
193
    def get_format_description(self):
 
194
        return "Local Git Repository"
 
195
 
 
196
    def get_format_string(self):
 
197
        return "Local Git Repository"
 
198
 
 
199
    def initialize_on_transport(self, transport):
 
200
        from bzrlib.transport.local import LocalTransport
 
201
 
 
202
        if not isinstance(transport, LocalTransport):
 
203
            raise NotImplementedError(self.initialize,
 
204
                "Can't create Git Repositories/branches on "
 
205
                "non-local transports")
 
206
        lazy_check_versions()
 
207
        from dulwich.repo import Repo
 
208
        Repo.init(transport.local_abspath(".").encode(osutils._fs_enc))
 
209
        return self.open(transport)
 
210
 
 
211
    def is_supported(self):
 
212
        return True
 
213
 
 
214
 
 
215
class RemoteGitControlDirFormat(GitControlDirFormat):
 
216
    """The .git directory control format."""
 
217
 
 
218
    @classmethod
 
219
    def _known_formats(self):
 
220
        return set([RemoteGitControlDirFormat()])
 
221
 
 
222
    def open(self, transport, _found=None):
 
223
        """Open this directory.
 
224
 
 
225
        """
 
226
        # we dont grok readonly - git isn't integrated with transport.
 
227
        url = transport.base
 
228
        if url.startswith('readonly+'):
 
229
            url = url[len('readonly+'):]
 
230
        if (not url.startswith("git://") and not url.startswith("git+")):
 
231
            raise bzr_errors.NotBranchError(transport.base)
 
232
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
233
        if not isinstance(transport, GitSmartTransport):
 
234
            raise bzr_errors.NotBranchError(transport.base)
 
235
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
236
        lockfiles = GitLockableFiles(transport, GitLock())
 
237
        return RemoteGitDir(transport, lockfiles, self)
 
238
 
 
239
    @classmethod
 
240
    def probe_transport(klass, transport):
 
241
        """Our format is present if the transport ends in '.not/'."""
 
242
        url = transport.base
 
243
        if url.startswith('readonly+'):
 
244
            url = url[len('readonly+'):]
 
245
        if (not url.startswith("git://") and not url.startswith("git+")):
 
246
            raise bzr_errors.NotBranchError(transport.base)
 
247
        # little ugly, but works
 
248
        format = klass()
 
249
        from bzrlib.plugins.git.remote import GitSmartTransport
 
250
        if not isinstance(transport, GitSmartTransport):
 
251
            raise bzr_errors.NotBranchError(transport.base)
 
252
        return format
 
253
 
 
254
    def get_format_description(self):
 
255
        return "Remote Git Repository"
 
256
 
 
257
    def get_format_string(self):
 
258
        return "Remote Git Repository"
 
259
 
 
260
    def initialize_on_transport(self, transport):
 
261
        raise bzr_errors.UninitializableFormat(self)
 
262
 
 
263
 
 
264
ControlDirFormat.register_control_format(LocalGitControlDirFormat)
 
265
ControlDirFormat.register_control_format(RemoteGitControlDirFormat)
 
266
 
 
267
register_transport_proto('git://',
 
268
        help="Access using the Git smart server protocol.")
 
269
register_transport_proto('git+ssh://',
 
270
        help="Access using the Git smart server protocol over SSH.")
 
271
 
 
272
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
273
                        'TCPGitSmartTransport')
 
274
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
275
                        'SSHGitSmartTransport')
 
276
 
 
277
foreign_vcs_registry.register_lazy("git",
 
278
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
279
 
 
280
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
281
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
 
282
    "bzrlib.plugins.git.commands")
 
283
plugin_cmds.register_lazy("cmd_git_refs", [], "bzrlib.plugins.git.commands")
 
284
plugin_cmds.register_lazy("cmd_git_apply", [], "bzrlib.plugins.git.commands")
 
285
 
 
286
def update_stanza(rev, stanza):
 
287
    mapping = getattr(rev, "mapping", None)
 
288
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
289
        stanza.add("git-commit", rev.foreign_revid)
 
290
 
 
291
 
 
292
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
 
293
if rio_hooks is not None:
 
294
    rio_hooks.install_named_hook('revision', update_stanza, None)
 
295
 
 
296
 
 
297
from bzrlib.transport import transport_server_registry
 
298
transport_server_registry.register_lazy('git',
 
299
    'bzrlib.plugins.git.server',
 
300
    'serve_git',
 
301
    'Git Smart server protocol over TCP. (default port: 9418)')
 
302
 
 
303
 
 
304
from bzrlib.repository import (
 
305
    network_format_registry as repository_network_format_registry,
 
306
    )
 
307
repository_network_format_registry.register_lazy('git',
 
308
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
309
 
 
310
from bzrlib.bzrdir import (
 
311
    network_format_registry as bzrdir_network_format_registry,
 
312
    )
 
313
bzrdir_network_format_registry.register('git', GitControlDirFormat)
 
314
 
 
315
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
316
                                   'send_git', 'Git am-style diff format')
 
317
 
 
318
topic_registry.register_lazy('git',
 
319
                             'bzrlib.plugins.git.help',
 
320
                             'help_git', 'Using Bazaar with Git')
 
321
 
 
322
try:
 
323
    from bzrlib.diff import format_registry as diff_format_registry
 
324
except ImportError:
 
325
    pass
 
326
else:
 
327
    diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
328
        'GitDiffTree', 'Git am-style diff format')
 
329
 
 
330
def test_suite():
 
331
    from bzrlib.plugins.git import tests
 
332
    return tests.test_suite()