/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

cope with branch argument to _warn_if_deprecated

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(os.path.join(os.path.dirname(__file__), '_lib')))
 
74
 
 
75
_versions_checked = False
 
76
def lazy_check_versions():
 
77
    global _versions_checked
 
78
    if _versions_checked:
 
79
        return
 
80
    _versions_checked = True
 
81
    try:
 
82
        from dulwich import __version__ as dulwich_version
 
83
    except ImportError:
 
84
        raise bzr_errors.DependencyNotPresent("dulwich",
 
85
            "bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
86
    else:
 
87
        if dulwich_version < dulwich_minimum_version:
 
88
            raise bzr_errors.DependencyNotPresent("dulwich", "bzr-git: Dulwich is too old; at least %d.%d.%d is required" % dulwich_minimum_version)
 
89
 
 
90
bzrdir.format_registry.register_lazy('git',
 
91
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
 
92
    help='GIT repository.', native=False, experimental=True,
 
93
    )
 
94
 
 
95
from bzrlib.revisionspec import revspec_registry
 
96
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
 
97
    "RevisionSpec_git")
 
98
 
 
99
try:
 
100
    from bzrlib.revisionspec import dwim_revspecs
 
101
except ImportError:
 
102
    pass
 
103
else:
 
104
    from bzrlib.plugins.git.revspec import RevisionSpec_git
 
105
    dwim_revspecs.append(RevisionSpec_git)
 
106
 
 
107
 
 
108
class GitBzrDirFormat(bzrdir.BzrDirFormat):
 
109
 
 
110
    _lock_class = TransportLock
 
111
 
 
112
    def is_supported(self):
 
113
        return True
 
114
 
 
115
    def network_name(self):
 
116
        return "git"
 
117
 
 
118
 
 
119
class LocalGitBzrDirFormat(GitBzrDirFormat):
 
120
    """The .git directory control format."""
 
121
 
 
122
    @classmethod
 
123
    def _known_formats(self):
 
124
        return set([LocalGitBzrDirFormat()])
 
125
 
 
126
    def open(self, transport, _found=None):
 
127
        """Open this directory.
 
128
 
 
129
        """
 
130
        lazy_check_versions()
 
131
        # we dont grok readonly - git isn't integrated with transport.
 
132
        from bzrlib.transport.local import LocalTransport
 
133
        if isinstance(transport, LocalTransport):
 
134
            import dulwich
 
135
            gitrepo = dulwich.repo.Repo(transport.local_abspath(".").encode(osutils._fs_enc))
 
136
        else:
 
137
            from bzrlib.plugins.git.transportgit import TransportRepo
 
138
            gitrepo = TransportRepo(transport)
 
139
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
 
140
        lockfiles = GitLockableFiles(transport, GitLock())
 
141
        return LocalGitDir(transport, lockfiles, gitrepo, self)
 
142
 
 
143
    @classmethod
 
144
    def probe_transport(klass, transport):
 
145
        try:
 
146
            if not (transport.has('info/refs') or transport.has('.git/branches') or 
 
147
                    transport.has('branches')):
 
148
                raise bzr_errors.NotBranchError(path=transport.base)
 
149
        except bzr_errors.NoSuchFile:
 
150
            raise bzr_errors.NotBranchError(path=transport.base)
 
151
        lazy_check_versions()
 
152
        import dulwich
 
153
        format = klass()
 
154
        try:
 
155
            format.open(transport)
 
156
            return format
 
157
        except dulwich.errors.NotGitRepository, e:
 
158
            raise bzr_errors.NotBranchError(path=transport.base)
 
159
        raise bzr_errors.NotBranchError(path=transport.base)
 
160
 
 
161
    def get_format_description(self):
 
162
        return "Local Git Repository"
 
163
 
 
164
    def get_format_string(self):
 
165
        return "Local Git Repository"
 
166
 
 
167
    def initialize_on_transport(self, transport):
 
168
        from bzrlib.transport.local import LocalTransport
 
169
 
 
170
        if not isinstance(transport, LocalTransport):
 
171
            raise NotImplementedError(self.initialize,
 
172
                "Can't create Git Repositories/branches on "
 
173
                "non-local transports")
 
174
        lazy_check_versions()
 
175
        from dulwich.repo import Repo
 
176
        Repo.create(transport.local_abspath(".").encode(osutils._fs_enc))
 
177
        return self.open(transport)
 
178
 
 
179
    def is_supported(self):
 
180
        return True
 
181
 
 
182
 
 
183
class RemoteGitBzrDirFormat(GitBzrDirFormat):
 
184
    """The .git directory control format."""
 
185
 
 
186
    @classmethod
 
187
    def _known_formats(self):
 
188
        return set([RemoteGitBzrDirFormat()])
 
189
 
 
190
    def open(self, transport, _found=None):
 
191
        """Open this directory.
 
192
 
 
193
        """
 
194
        # we dont grok readonly - git isn't integrated with transport.
 
195
        url = transport.base
 
196
        if url.startswith('readonly+'):
 
197
            url = url[len('readonly+'):]
 
198
        if (not url.startswith("git://") and not url.startswith("git+")):
 
199
            raise bzr_errors.NotBranchError(transport.base)
 
200
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
201
        if not isinstance(transport, GitSmartTransport):
 
202
            raise bzr_errors.NotBranchError(transport.base)
 
203
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
204
        lockfiles = GitLockableFiles(transport, GitLock())
 
205
        return RemoteGitDir(transport, lockfiles, self)
 
206
 
 
207
    @classmethod
 
208
    def probe_transport(klass, transport):
 
209
        """Our format is present if the transport ends in '.not/'."""
 
210
        url = transport.base
 
211
        if url.startswith('readonly+'):
 
212
            url = url[len('readonly+'):]
 
213
        if (not url.startswith("git://") and not url.startswith("git+")):
 
214
            raise bzr_errors.NotBranchError(transport.base)
 
215
        # little ugly, but works
 
216
        format = klass()
 
217
        from bzrlib.plugins.git.remote import GitSmartTransport
 
218
        if not isinstance(transport, GitSmartTransport):
 
219
            raise bzr_errors.NotBranchError(transport.base)
 
220
        return format
 
221
 
 
222
    def get_format_description(self):
 
223
        return "Remote Git Repository"
 
224
 
 
225
    def get_format_string(self):
 
226
        return "Remote Git Repository"
 
227
 
 
228
    def initialize_on_transport(self, transport):
 
229
        raise bzr_errors.UninitializableFormat(self)
 
230
 
 
231
 
 
232
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
 
233
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
 
234
 
 
235
register_transport_proto('git://',
 
236
        help="Access using the Git smart server protocol.")
 
237
register_transport_proto('git+ssh://',
 
238
        help="Access using the Git smart server protocol over SSH.")
 
239
 
 
240
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
241
                        'TCPGitSmartTransport')
 
242
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
243
                        'SSHGitSmartTransport')
 
244
 
 
245
foreign_vcs_registry.register_lazy("git",
 
246
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
247
 
 
248
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
249
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
 
250
    "bzrlib.plugins.git.commands")
 
251
 
 
252
def update_stanza(rev, stanza):
 
253
    mapping = getattr(rev, "mapping", None)
 
254
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
255
        stanza.add("git-commit", rev.foreign_revid)
 
256
 
 
257
 
 
258
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
 
259
if rio_hooks is not None:
 
260
    rio_hooks.install_named_hook('revision', update_stanza, None)
 
261
 
 
262
 
 
263
from bzrlib.transport import transport_server_registry
 
264
transport_server_registry.register_lazy('git',
 
265
    'bzrlib.plugins.git.server',
 
266
    'serve_git',
 
267
    'Git Smart server protocol over TCP. (default port: 9418)')
 
268
 
 
269
 
 
270
from bzrlib.repository import network_format_registry as repository_network_format_registry
 
271
repository_network_format_registry.register_lazy('git',
 
272
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
273
 
 
274
from bzrlib.bzrdir import network_format_registry as bzrdir_network_format_registry
 
275
bzrdir_network_format_registry.register('git', GitBzrDirFormat)
 
276
 
 
277
 
 
278
def get_rich_root_format(stacked=False):
 
279
    if stacked:
 
280
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
 
281
    else:
 
282
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
 
283
 
 
284
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
285
                                   'send_git', 'Git am-style diff format')
 
286
 
 
287
def test_suite():
 
288
    from bzrlib.plugins.git import tests
 
289
    return tests.test_suite()