/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

Default to using global user id rather than making one up.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
1
 
# Copyright (C) 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2009 Canonical Ltd
 
2
 
2
3
# Authors: Robert Collins <robert.collins@canonical.com>
 
4
#          Jelmer Vernooij <jelmer@samba.org>
 
5
#          John Carr <john.carr@unrouted.co.uk>
3
6
#
4
7
# This program is free software; you can redistribute it and/or modify
5
8
# it under the terms of the GNU General Public License as published by
18
21
 
19
22
"""A GIT branch and repository format implementation for bzr."""
20
23
 
21
 
from bzrlib import bzrdir
22
 
from bzrlib.foreign import ForeignVcs, VcsMappingRegistry, foreign_vcs_registry
23
 
from bzrlib.plugins.git.dir import GitBzrDirFormat
24
 
 
25
 
bzrdir.format_registry.register(
26
 
    'git', GitBzrDirFormat,
27
 
    help='GIT repository.', 
28
 
    native=False, experimental=True,
29
 
    )
30
 
 
31
 
bzrdir.BzrDirFormat.register_control_format(GitBzrDirFormat)
32
 
 
33
 
 
34
 
class ForeignGit(ForeignVcs):
35
 
    """Foreign Git."""
36
 
 
37
 
 
38
 
git_mapping_registry = VcsMappingRegistry()
39
 
git_mapping_registry.register_lazy('git-experimental', "bzrlib.plugins.git.mapping",
40
 
                                   "BzrGitMappingExperimental")
41
 
foreign_vcs_registry.register("git", ForeignGit(git_mapping_registry), 
42
 
                                      "Stupid content tracker")
43
 
 
 
24
import os
 
25
import sys
 
26
 
 
27
import bzrlib
 
28
import bzrlib.api
 
29
 
 
30
# versions ending in 'exp' mean experimental mappings
 
31
# versions ending in 'dev' mean development version
 
32
# versions ending in 'final' mean release (well tested, etc)
 
33
version_info = (0, 3, 1, 'final', 0)
 
34
 
 
35
if version_info[3] == 'final':
 
36
    version_string = '%d.%d.%d' % version_info[:3]
 
37
else:
 
38
    version_string = '%d.%d.%d%s%d' % version_info
 
39
__version__ = version_string
 
40
 
 
41
MINIMUM_DULWICH_VERSION = (0, 3, 1)
 
42
COMPATIBLE_BZR_VERSIONS = [(1, 14, 0), (1, 15, 0)]
 
43
 
 
44
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
 
45
 
 
46
 
 
47
from bzrlib import (
 
48
    bzrdir,
 
49
    errors as bzr_errors,
 
50
    osutils,
 
51
    )
 
52
from bzrlib.foreign import (
 
53
    foreign_vcs_registry,
 
54
    )
 
55
from bzrlib.lockable_files import (
 
56
    TransportLock,
 
57
    )
 
58
from bzrlib.transport import (
 
59
    register_lazy_transport,
 
60
    register_transport_proto,
 
61
    )
 
62
from bzrlib.commands import (
 
63
    plugin_cmds,
 
64
    )
 
65
from bzrlib.trace import (
 
66
    warning,
 
67
    )
 
68
from bzrlib.version_info_formats.format_rio import (
 
69
    RioVersionInfoBuilder,
 
70
    )
 
71
 
 
72
 
 
73
if getattr(sys, "frozen", None):
 
74
    # allow import additional libs from ./_lib for bzr.exe only
 
75
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
 
76
 
 
77
_versions_checked = False
 
78
def lazy_check_versions():
 
79
    global _versions_checked
 
80
    if _versions_checked:
 
81
        return
 
82
    _versions_checked = True
 
83
    try:
 
84
        from dulwich import __version__ as dulwich_version
 
85
    except ImportError:
 
86
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
87
    else:
 
88
        if dulwich_version < MINIMUM_DULWICH_VERSION:
 
89
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
 
90
 
 
91
bzrdir.format_registry.register_lazy('git', 
 
92
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
 
93
    help='GIT repository.', native=False, experimental=True,
 
94
    )
 
95
 
 
96
from bzrlib.revisionspec import revspec_registry
 
97
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
 
98
    "RevisionSpec_git")
 
99
 
 
100
 
 
101
class GitBzrDirFormat(bzrdir.BzrDirFormat):
 
102
    _lock_class = TransportLock
 
103
 
 
104
    def is_supported(self):
 
105
        return True
 
106
 
 
107
 
 
108
class LocalGitBzrDirFormat(GitBzrDirFormat):
 
109
    """The .git directory control format."""
 
110
 
 
111
    @classmethod
 
112
    def _known_formats(self):
 
113
        return set([LocalGitBzrDirFormat()])
 
114
 
 
115
    def open(self, transport, _found=None):
 
116
        """Open this directory.
 
117
 
 
118
        """
 
119
        import dulwich as git
 
120
        # we dont grok readonly - git isn't integrated with transport.
 
121
        url = transport.base
 
122
        if url.startswith('readonly+'):
 
123
            url = url[len('readonly+'):]
 
124
 
 
125
        try:
 
126
            gitrepo = git.repo.Repo(transport.local_abspath(".").encode(osutils._fs_enc))
 
127
        except bzr_errors.NotLocalUrl:
 
128
            raise bzr_errors.NotBranchError(path=transport.base)
 
129
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
 
130
        lockfiles = GitLockableFiles(transport, GitLock())
 
131
        return LocalGitDir(transport, lockfiles, gitrepo, self)
 
132
 
 
133
    @classmethod
 
134
    def probe_transport(klass, transport):
 
135
        """Our format is present if the transport ends in '.not/'."""
 
136
        from bzrlib.transport.local import LocalTransport
 
137
 
 
138
        if not isinstance(transport, LocalTransport):
 
139
            raise bzr_errors.NotBranchError(path=transport.base)
 
140
 
 
141
        # This should quickly filter out most things that are not 
 
142
        # git repositories, saving us the trouble from loading dulwich.
 
143
        if not transport.has(".git") and not transport.has("objects"):
 
144
            raise bzr_errors.NotBranchError(path=transport.base)
 
145
 
 
146
        import dulwich as git
 
147
        format = klass()
 
148
        try:
 
149
            format.open(transport)
 
150
            return format
 
151
        except git.errors.NotGitRepository, e:
 
152
            raise bzr_errors.NotBranchError(path=transport.base)
 
153
        raise bzr_errors.NotBranchError(path=transport.base)
 
154
 
 
155
    def get_format_description(self):
 
156
        return "Local Git Repository"
 
157
 
 
158
    def get_format_string(self):
 
159
        return "Local Git Repository"
 
160
 
 
161
    def initialize_on_transport(self, transport):
 
162
        from bzrlib.transport.local import LocalTransport
 
163
 
 
164
        if not isinstance(transport, LocalTransport):
 
165
            raise NotImplementedError(self.initialize, 
 
166
                "Can't create Git Repositories/branches on "
 
167
                "non-local transports")
 
168
 
 
169
        from dulwich.repo import Repo
 
170
        Repo.create(transport.local_abspath(".").encode(osutils._fs_enc)) 
 
171
        return self.open(transport)
 
172
 
 
173
    def is_supported(self):
 
174
        return True
 
175
 
 
176
 
 
177
class RemoteGitBzrDirFormat(GitBzrDirFormat):
 
178
    """The .git directory control format."""
 
179
 
 
180
    @classmethod
 
181
    def _known_formats(self):
 
182
        return set([RemoteGitBzrDirFormat()])
 
183
 
 
184
    def open(self, transport, _found=None):
 
185
        """Open this directory.
 
186
 
 
187
        """
 
188
        # we dont grok readonly - git isn't integrated with transport.
 
189
        url = transport.base
 
190
        if url.startswith('readonly+'):
 
191
            url = url[len('readonly+'):]
 
192
        if (not url.startswith("git://") and 
 
193
            not url.startswith("git+")):
 
194
            raise bzr_errors.NotBranchError(transport.base)
 
195
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
196
        if not isinstance(transport, GitSmartTransport):
 
197
            raise bzr_errors.NotBranchError(transport.base)
 
198
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
199
        lockfiles = GitLockableFiles(transport, GitLock())
 
200
        return RemoteGitDir(transport, lockfiles, self)
 
201
 
 
202
    @classmethod
 
203
    def probe_transport(klass, transport):
 
204
        """Our format is present if the transport ends in '.not/'."""
 
205
        url = transport.base
 
206
        if url.startswith('readonly+'):
 
207
            url = url[len('readonly+'):]
 
208
        if (not url.startswith("git://") and 
 
209
            not url.startswith("git+")):
 
210
            raise bzr_errors.NotBranchError(transport.base)
 
211
        # little ugly, but works
 
212
        format = klass()
 
213
        from bzrlib.plugins.git.remote import GitSmartTransport
 
214
        if not isinstance(transport, GitSmartTransport):
 
215
            raise bzr_errors.NotBranchError(transport.base)
 
216
        return format
 
217
 
 
218
    def get_format_description(self):
 
219
        return "Remote Git Repository"
 
220
 
 
221
    def get_format_string(self):
 
222
        return "Remote Git Repository"
 
223
 
 
224
    def initialize_on_transport(self, transport):
 
225
        raise bzr_errors.UninitializableFormat(self)
 
226
 
 
227
 
 
228
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
 
229
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
 
230
 
 
231
register_transport_proto('git://', 
 
232
        help="Access using the Git smart server protocol.")
 
233
register_transport_proto('git+ssh://', 
 
234
        help="Access using the Git smart server protocol over SSH.")
 
235
 
 
236
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
237
                        'TCPGitSmartTransport')
 
238
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
239
                        'SSHGitSmartTransport')
 
240
 
 
241
foreign_vcs_registry.register_lazy("git", 
 
242
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
243
 
 
244
plugin_cmds.register_lazy("cmd_git_serve", [], "bzrlib.plugins.git.commands")
 
245
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
246
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"], 
 
247
    "bzrlib.plugins.git.commands")
 
248
 
 
249
def update_stanza(rev, stanza):
 
250
    mapping = getattr(rev, "mapping", None)
 
251
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
252
        stanza.add("git-commit", rev.foreign_revid)
 
253
 
 
254
 
 
255
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
 
256
if rio_hooks is not None:
 
257
    rio_hooks.install_named_hook('revision', update_stanza, None)
 
258
 
 
259
def get_rich_root_format(stacked=False):
 
260
    if stacked:
 
261
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
 
262
    else:
 
263
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
44
264
 
45
265
def test_suite():
46
266
    from bzrlib.plugins.git import tests