/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

https://launchpad.net/bugs/605394
Add some basic documentation in 'bzr help git'.

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