/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

Use get_file_revision.

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
    )
 
48
 
 
49
from bzrlib.controldir import (
 
50
    ControlDirFormat,
 
51
    Prober,
 
52
    format_registry,
 
53
    network_format_registry as controldir_network_format_registry,
 
54
    )
 
55
 
 
56
from bzrlib.foreign import (
 
57
    foreign_vcs_registry,
 
58
    )
 
59
from bzrlib.help_topics import (
 
60
    topic_registry,
 
61
    )
 
62
from bzrlib.transport import (
 
63
    register_lazy_transport,
 
64
    register_transport_proto,
 
65
    )
 
66
from bzrlib.commands import (
 
67
    plugin_cmds,
 
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
format_registry.register_lazy('git',
 
102
    "bzrlib.plugins.git.dir", "LocalGitControlDirFormat",
 
103
    help='GIT repository.', native=False, experimental=False,
 
104
    )
 
105
 
 
106
format_registry.register_lazy('git-bare',
 
107
    "bzrlib.plugins.git.dir", "BareLocalGitControlDirFormat",
 
108
    help='Bare GIT repository (no working tree).', native=False,
 
109
    experimental=False,
 
110
    )
 
111
 
 
112
from bzrlib.revisionspec import revspec_registry
 
113
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
 
114
    "RevisionSpec_git")
 
115
 
 
116
from bzrlib.revisionspec import dwim_revspecs, RevisionSpec_dwim
 
117
if getattr(RevisionSpec_dwim, "append_possible_lazy_revspec", None):
 
118
    RevisionSpec_dwim.append_possible_lazy_revspec(
 
119
        "bzrlib.plugins.git.revspec", "RevisionSpec_git")
 
120
else: # bzr < 2.4
 
121
    from bzrlib.plugins.git.revspec import RevisionSpec_git
 
122
    dwim_revspecs.append(RevisionSpec_git)
 
123
 
 
124
 
 
125
class LocalGitProber(Prober):
 
126
 
 
127
    def probe_transport(self, transport):
 
128
        try:
 
129
            if not transport.has_any(['info/refs', '.git/branches',
 
130
                                      'branches']):
 
131
                raise bzr_errors.NotBranchError(path=transport.base)
 
132
        except bzr_errors.NoSuchFile:
 
133
            raise bzr_errors.NotBranchError(path=transport.base)
 
134
        from bzrlib import urlutils
 
135
        if urlutils.split(transport.base)[1] == ".git":
 
136
            raise bzr_errors.NotBranchError(path=transport.base)
 
137
        lazy_check_versions()
 
138
        import dulwich
 
139
        from bzrlib.plugins.git.transportgit import TransportRepo
 
140
        try:
 
141
            gitrepo = TransportRepo(transport)
 
142
        except dulwich.errors.NotGitRepository, e:
 
143
            raise bzr_errors.NotBranchError(path=transport.base)
 
144
        else:
 
145
            from bzrlib.plugins.git.dir import (
 
146
                BareLocalGitControlDirFormat,
 
147
                LocalGitControlDirFormat,
 
148
                )
 
149
            if gitrepo.bare:
 
150
                return BareLocalGitControlDirFormat()
 
151
            else:
 
152
                return LocalGitControlDirFormat()
 
153
 
 
154
    @classmethod
 
155
    def known_formats(cls):
 
156
        from bzrlib.plugins.git.dir import (
 
157
            BareLocalGitControlDirFormat,
 
158
            LocalGitControlDirFormat,
 
159
            )
 
160
        return set([BareLocalGitControlDirFormat(), LocalGitControlDirFormat()])
 
161
 
 
162
 
 
163
class RemoteGitProber(Prober):
 
164
 
 
165
    def probe_transport(self, transport):
 
166
        url = transport.base
 
167
        if url.startswith('readonly+'):
 
168
            url = url[len('readonly+'):]
 
169
        if (not url.startswith("git://") and not url.startswith("git+")):
 
170
            raise bzr_errors.NotBranchError(transport.base)
 
171
        # little ugly, but works
 
172
        from bzrlib.plugins.git.remote import (
 
173
            GitSmartTransport,
 
174
            RemoteGitControlDirFormat,
 
175
            )
 
176
        if not isinstance(transport, GitSmartTransport):
 
177
            raise bzr_errors.NotBranchError(transport.base)
 
178
        return RemoteGitControlDirFormat()
 
179
 
 
180
    @classmethod
 
181
    def known_formats(cls):
 
182
        from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
 
183
        return set([RemoteGitControlDirFormat()])
 
184
 
 
185
 
 
186
if not getattr(Prober, "known_formats", None): # bzr < 2.4
 
187
    from bzrlib.plugins.git.dir import (
 
188
        LocalGitControlDirFormat, BareLocalGitControlDirFormat,
 
189
        )
 
190
    from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
 
191
    ControlDirFormat.register_format(LocalGitControlDirFormat())
 
192
    ControlDirFormat.register_format(BareLocalGitControlDirFormat())
 
193
    ControlDirFormat.register_format(RemoteGitControlDirFormat())
 
194
    # Provide RevisionTree.get_file_revision, so various parts of bzr-svn
 
195
    # can avoid inventories.
 
196
    from bzrlib.revisiontree import RevisionTree
 
197
    def get_file_revision(tree, file_id, path=None):
 
198
        return tree.inventory[file_id].revision
 
199
    RevisionTree.get_file_revision = get_file_revision
 
200
 
 
201
ControlDirFormat.register_prober(LocalGitProber)
 
202
ControlDirFormat.register_prober(RemoteGitProber)
 
203
 
 
204
register_transport_proto('git://',
 
205
        help="Access using the Git smart server protocol.")
 
206
register_transport_proto('git+ssh://',
 
207
        help="Access using the Git smart server protocol over SSH.")
 
208
 
 
209
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
210
                        'TCPGitSmartTransport')
 
211
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
212
                        'SSHGitSmartTransport')
 
213
 
 
214
foreign_vcs_registry.register_lazy("git",
 
215
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
216
 
 
217
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
218
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
 
219
    "bzrlib.plugins.git.commands")
 
220
plugin_cmds.register_lazy("cmd_git_refs", [], "bzrlib.plugins.git.commands")
 
221
plugin_cmds.register_lazy("cmd_git_apply", [], "bzrlib.plugins.git.commands")
 
222
 
 
223
def update_stanza(rev, stanza):
 
224
    mapping = getattr(rev, "mapping", None)
 
225
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
226
        stanza.add("git-commit", rev.foreign_revid)
 
227
 
 
228
try:
 
229
    from bzrlib.hooks import install_lazy_named_hook
 
230
except ImportError: # Compatibility with bzr < 2.4
 
231
    from bzrlib.version_info_formats.format_rio import (
 
232
        RioVersionInfoBuilder,
 
233
        )
 
234
    RioVersionInfoBuilder.hooks.install_named_hook('revision', update_stanza,
 
235
        "git commits")
 
236
else:
 
237
    install_lazy_named_hook("bzrlib.version_info_formats.format_rio",
 
238
        "RioVersionInfoBuilder.hooks", "revision", update_stanza,
 
239
        "git commits")
 
240
 
 
241
 
 
242
from bzrlib.transport import transport_server_registry
 
243
transport_server_registry.register_lazy('git',
 
244
    'bzrlib.plugins.git.server',
 
245
    'serve_git',
 
246
    'Git Smart server protocol over TCP. (default port: 9418)')
 
247
 
 
248
 
 
249
from bzrlib.repository import (
 
250
    format_registry as repository_format_registry,
 
251
    network_format_registry as repository_network_format_registry,
 
252
    )
 
253
repository_network_format_registry.register_lazy('git',
 
254
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
255
 
 
256
try:
 
257
    register_extra_lazy_repository_format = getattr(repository_format_registry,
 
258
        "register_extra_lazy")
 
259
except AttributeError: # bzr < 2.4
 
260
    pass
 
261
else:
 
262
    register_extra_lazy_repository_format('bzrlib.plugins.git.repository',
 
263
        'GitRepositoryFormat')
 
264
 
 
265
from bzrlib.branch import (
 
266
    network_format_registry as branch_network_format_registry,
 
267
    )
 
268
branch_network_format_registry.register_lazy('git',
 
269
    'bzrlib.plugins.git.branch', 'GitBranchFormat')
 
270
 
 
271
try:
 
272
    from bzrlib.branch import (
 
273
        format_registry as branch_format_registry,
 
274
        )
 
275
except ImportError: # bzr < 2.4
 
276
    pass
 
277
else:
 
278
    branch_format_registry.register_extra_lazy(
 
279
        'bzrlib.plugins.git.branch',
 
280
        'GitBranchFormat',
 
281
        )
 
282
 
 
283
try:
 
284
    from bzrlib.workingtree import (
 
285
        format_registry as workingtree_format_registry,
 
286
        )
 
287
except ImportError: # bzr < 2.4
 
288
    pass
 
289
else:
 
290
    workingtree_format_registry.register_extra_lazy(
 
291
        'bzrlib.plugins.git.workingtree',
 
292
        'GitWorkingTreeFormat',
 
293
        )
 
294
 
 
295
controldir_network_format_registry.register_lazy('git',
 
296
    "bzrlib.plugins.git.dir", "GitControlDirFormat")
 
297
 
 
298
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
299
                                   'send_git', 'Git am-style diff format')
 
300
 
 
301
topic_registry.register_lazy('git', 'bzrlib.plugins.git.help', 'help_git',
 
302
    'Using Bazaar with Git')
 
303
 
 
304
from bzrlib.diff import format_registry as diff_format_registry
 
305
diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
306
    'GitDiffTree', 'Git am-style diff format')
 
307
 
 
308
def test_suite():
 
309
    from bzrlib.plugins.git import tests
 
310
    return tests.test_suite()