/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 tests, split up InterGitNonGitRepository.

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
from bzrlib import (
 
30
    bzrdir,
 
31
    errors as bzr_errors,
 
32
    )
 
33
from bzrlib.foreign import (
 
34
    foreign_vcs_registry,
 
35
    )
 
36
from bzrlib.lockable_files import (
 
37
    TransportLock,
 
38
    )
 
39
from bzrlib.transport import (
 
40
    register_lazy_transport,
 
41
    )
 
42
from bzrlib.commands import (
 
43
    plugin_cmds,
 
44
    )
 
45
from bzrlib.trace import (
 
46
    warning,
 
47
    )
 
48
 
 
49
# versions ending in 'exp' mean experimental mappings
 
50
# versions ending in 'dev' mean development version
 
51
# versions ending in 'final' mean release (well tested, etc)
 
52
version_info = (0, 2, 0, 'dev', 0)
 
53
 
 
54
if version_info[3] == 'final':
 
55
    version_string = '%d.%d.%d' % version_info[:3]
 
56
else:
 
57
    version_string = '%d.%d.%d%s%d' % version_info
 
58
__version__ = version_string
 
59
 
 
60
MINIMUM_DULWICH_VERSION = (0, 1, 1)
 
61
COMPATIBLE_BZR_VERSIONS = [(1, 13, 0)]
 
62
 
 
63
if getattr(sys, "frozen", None):
 
64
    # allow import additional libs from ./_lib for bzr.exe only
 
65
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
 
66
 
 
67
_versions_checked = False
 
68
def lazy_check_versions():
 
69
    global _versions_checked
 
70
    if _versions_checked:
 
71
        return
 
72
    _versions_checked = True
 
73
    try:
 
74
        from dulwich import __version__ as dulwich_version
 
75
    except ImportError:
 
76
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
 
77
    else:
 
78
        if dulwich_version < MINIMUM_DULWICH_VERSION:
 
79
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
 
80
 
 
81
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
 
82
 
 
83
bzrdir.format_registry.register_lazy('git', 
 
84
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
 
85
    help='GIT repository.', native=False, experimental=True,
 
86
    )
 
87
 
 
88
from bzrlib.revisionspec import revspec_registry
 
89
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
 
90
    "RevisionSpec_git")
 
91
 
 
92
class GitBzrDirFormat(bzrdir.BzrDirFormat):
 
93
    _lock_class = TransportLock
 
94
 
 
95
    def is_supported(self):
 
96
        return True
 
97
 
 
98
 
 
99
class LocalGitBzrDirFormat(GitBzrDirFormat):
 
100
    """The .git directory control format."""
 
101
 
 
102
    @classmethod
 
103
    def _known_formats(self):
 
104
        return set([LocalGitBzrDirFormat()])
 
105
 
 
106
    def open(self, transport, _found=None):
 
107
        """Open this directory.
 
108
 
 
109
        """
 
110
        import dulwich as git
 
111
        # we dont grok readonly - git isn't integrated with transport.
 
112
        url = transport.base
 
113
        if url.startswith('readonly+'):
 
114
            url = url[len('readonly+'):]
 
115
 
 
116
        try:
 
117
            gitrepo = git.repo.Repo(transport.local_abspath("."))
 
118
        except bzr_errors.NotLocalUrl:
 
119
            raise bzr_errors.NotBranchError(path=transport.base)
 
120
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
 
121
        lockfiles = GitLockableFiles(transport, GitLock())
 
122
        return LocalGitDir(transport, lockfiles, gitrepo, self)
 
123
 
 
124
    @classmethod
 
125
    def probe_transport(klass, transport):
 
126
        """Our format is present if the transport ends in '.not/'."""
 
127
        from bzrlib.transport.local import LocalTransport
 
128
 
 
129
        if not isinstance(transport, LocalTransport):
 
130
            raise bzr_errors.NotBranchError(path=transport.base)
 
131
 
 
132
        # This should quickly filter out most things that are not 
 
133
        # git repositories, saving us the trouble from loading dulwich.
 
134
        if not transport.has(".git") and not transport.has("objects"):
 
135
            raise bzr_errors.NotBranchError(path=transport.base)
 
136
 
 
137
        import dulwich as git
 
138
        format = klass()
 
139
        try:
 
140
            format.open(transport)
 
141
            return format
 
142
        except git.errors.NotGitRepository, e:
 
143
            raise bzr_errors.NotBranchError(path=transport.base)
 
144
        raise bzr_errors.NotBranchError(path=transport.base)
 
145
 
 
146
    def get_format_description(self):
 
147
        return "Local Git Repository"
 
148
 
 
149
    def get_format_string(self):
 
150
        return "Local Git Repository"
 
151
 
 
152
    def initialize_on_transport(self, transport):
 
153
        from bzrlib.transport.local import LocalTransport
 
154
 
 
155
        if not isinstance(transport, LocalTransport):
 
156
            raise NotImplementedError(self.initialize, 
 
157
                "Can't create Git Repositories/branches on "
 
158
                "non-local transports")
 
159
 
 
160
        from dulwich.repo import Repo
 
161
        Repo.create(transport.local_abspath(".")) 
 
162
        return self.open(transport)
 
163
 
 
164
    def is_supported(self):
 
165
        return True
 
166
 
 
167
 
 
168
class RemoteGitBzrDirFormat(GitBzrDirFormat):
 
169
    """The .git directory control format."""
 
170
 
 
171
    @classmethod
 
172
    def _known_formats(self):
 
173
        return set([RemoteGitBzrDirFormat()])
 
174
 
 
175
    def open(self, transport, _found=None):
 
176
        """Open this directory.
 
177
 
 
178
        """
 
179
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
180
        if not isinstance(transport, GitSmartTransport):
 
181
            raise bzr_errors.NotBranchError(transport.base)
 
182
        # we dont grok readonly - git isn't integrated with transport.
 
183
        url = transport.base
 
184
        if url.startswith('readonly+'):
 
185
            url = url[len('readonly+'):]
 
186
 
 
187
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
188
        lockfiles = GitLockableFiles(transport, GitLock())
 
189
        return RemoteGitDir(transport, lockfiles, self)
 
190
 
 
191
    @classmethod
 
192
    def probe_transport(klass, transport):
 
193
        """Our format is present if the transport ends in '.not/'."""
 
194
        # little ugly, but works
 
195
        format = klass()
 
196
        from bzrlib.plugins.git.remote import GitSmartTransport
 
197
        if not isinstance(transport, GitSmartTransport):
 
198
            raise bzr_errors.NotBranchError(transport.base)
 
199
        # The only way to know a path exists and contains a valid repository 
 
200
        # is to do a request against it:
 
201
        try:
 
202
            transport.fetch_pack(lambda x: [], None, lambda x: None, 
 
203
                                 lambda x: mutter("git: %s" % x))
 
204
        except errors.git_errors.GitProtocolError:
 
205
            raise bzr_errors.NotBranchError(path=transport.base)
 
206
        else:
 
207
            return format
 
208
        raise bzr_errors.NotBranchError(path=transport.base)
 
209
 
 
210
    def get_format_description(self):
 
211
        return "Remote Git Repository"
 
212
 
 
213
    def get_format_string(self):
 
214
        return "Remote Git Repository"
 
215
 
 
216
    def initialize_on_transport(self, transport):
 
217
        raise bzr_errors.UninitializableFormat(self)
 
218
 
 
219
 
 
220
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
 
221
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
 
222
 
 
223
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
224
                        'GitSmartTransport')
 
225
 
 
226
foreign_vcs_registry.register_lazy("git", 
 
227
                        "bzrlib.plugins.git.mapping", 
 
228
                        "foreign_git",
 
229
                        "Stupid content tracker")
 
230
 
 
231
plugin_cmds.register_lazy("cmd_git_serve", [], "bzrlib.plugins.git.commands")
 
232
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
233
 
 
234
def get_rich_root_format():
 
235
    try:
 
236
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
 
237
    except KeyError:
 
238
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
 
239
 
 
240
def test_suite():
 
241
    from bzrlib.plugins.git import tests
 
242
    return tests.test_suite()