/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

Implement CommitBuilder.revision_tree.

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
ControlDirFormat.register_prober(LocalGitProber)
 
195
ControlDirFormat.register_prober(RemoteGitProber)
 
196
 
 
197
register_transport_proto('git://',
 
198
        help="Access using the Git smart server protocol.")
 
199
register_transport_proto('git+ssh://',
 
200
        help="Access using the Git smart server protocol over SSH.")
 
201
 
 
202
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
 
203
                        'TCPGitSmartTransport')
 
204
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
 
205
                        'SSHGitSmartTransport')
 
206
 
 
207
foreign_vcs_registry.register_lazy("git",
 
208
    "bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
 
209
 
 
210
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
 
211
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
 
212
    "bzrlib.plugins.git.commands")
 
213
plugin_cmds.register_lazy("cmd_git_refs", [], "bzrlib.plugins.git.commands")
 
214
plugin_cmds.register_lazy("cmd_git_apply", [], "bzrlib.plugins.git.commands")
 
215
 
 
216
def update_stanza(rev, stanza):
 
217
    mapping = getattr(rev, "mapping", None)
 
218
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
 
219
        stanza.add("git-commit", rev.foreign_revid)
 
220
 
 
221
try:
 
222
    from bzrlib.hooks import install_lazy_named_hook
 
223
except ImportError: # Compatibility with bzr < 2.4
 
224
    from bzrlib.version_info_formats.format_rio import (
 
225
        RioVersionInfoBuilder,
 
226
        )
 
227
    RioVersionInfoBuilder.hooks.install_named_hook('revision', update_stanza,
 
228
        "git commits")
 
229
else:
 
230
    install_lazy_named_hook("bzrlib.version_info_formats.format_rio",
 
231
        "RioVersionInfoBuilder.hooks", "revision", update_stanza,
 
232
        "git commits")
 
233
 
 
234
 
 
235
from bzrlib.transport import transport_server_registry
 
236
transport_server_registry.register_lazy('git',
 
237
    'bzrlib.plugins.git.server',
 
238
    'serve_git',
 
239
    'Git Smart server protocol over TCP. (default port: 9418)')
 
240
 
 
241
 
 
242
from bzrlib.repository import (
 
243
    format_registry as repository_format_registry,
 
244
    network_format_registry as repository_network_format_registry,
 
245
    )
 
246
repository_network_format_registry.register_lazy('git',
 
247
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
 
248
 
 
249
try:
 
250
    register_extra_lazy_repository_format = getattr(repository_format_registry,
 
251
        "register_extra_lazy")
 
252
except AttributeError: # bzr < 2.4
 
253
    pass
 
254
else:
 
255
    register_extra_lazy_repository_format('bzrlib.plugins.git.repository',
 
256
        'GitRepositoryFormat')
 
257
 
 
258
from bzrlib.branch import (
 
259
    network_format_registry as branch_network_format_registry,
 
260
    )
 
261
branch_network_format_registry.register_lazy('git',
 
262
    'bzrlib.plugins.git.branch', 'GitBranchFormat')
 
263
 
 
264
try:
 
265
    from bzrlib.branch import (
 
266
        format_registry as branch_format_registry,
 
267
        )
 
268
except ImportError: # bzr < 2.4
 
269
    pass
 
270
else:
 
271
    branch_format_registry.register_extra_lazy(
 
272
        'bzrlib.plugins.git.branch',
 
273
        'GitBranchFormat',
 
274
        )
 
275
 
 
276
try:
 
277
    from bzrlib.workingtree import (
 
278
        format_registry as workingtree_format_registry,
 
279
        )
 
280
except ImportError: # bzr < 2.4
 
281
    pass
 
282
else:
 
283
    workingtree_format_registry.register_extra_lazy(
 
284
        'bzrlib.plugins.git.workingtree',
 
285
        'GitWorkingTreeFormat',
 
286
        )
 
287
 
 
288
controldir_network_format_registry.register_lazy('git',
 
289
    "bzrlib.plugins.git.dir", "GitControlDirFormat")
 
290
 
 
291
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
292
                                   'send_git', 'Git am-style diff format')
 
293
 
 
294
topic_registry.register_lazy('git', 'bzrlib.plugins.git.help', 'help_git',
 
295
    'Using Bazaar with Git')
 
296
 
 
297
from bzrlib.diff import format_registry as diff_format_registry
 
298
diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
299
    'GitDiffTree', 'Git am-style diff format')
 
300
 
 
301
def test_suite():
 
302
    from bzrlib.plugins.git import tests
 
303
    return tests.test_suite()