/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

More work on roundtrip push support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
44
44
 
45
45
from bzrlib import (
46
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
 
    )
 
47
    osutils,
 
48
    )
 
49
try:
 
50
    from bzrlib.controldir import (
 
51
        ControlDirFormat,
 
52
        ControlDir,
 
53
        Prober,
 
54
        format_registry,
 
55
        )
 
56
except ImportError:
 
57
    # bzr < 2.3
 
58
    from bzrlib.bzrdir import (
 
59
        BzrDirFormat,
 
60
        BzrDir,
 
61
        format_registry,
 
62
        )
 
63
    ControlDir = BzrDir
 
64
    ControlDirFormat = BzrDirFormat
 
65
    Prober = object
 
66
    has_controldir = False
 
67
else:
 
68
    has_controldir = True
55
69
 
56
70
from bzrlib.foreign import (
57
71
    foreign_vcs_registry,
59
73
from bzrlib.help_topics import (
60
74
    topic_registry,
61
75
    )
 
76
from bzrlib.lockable_files import (
 
77
    TransportLock,
 
78
    )
62
79
from bzrlib.transport import (
63
80
    register_lazy_transport,
64
81
    register_transport_proto,
66
83
from bzrlib.commands import (
67
84
    plugin_cmds,
68
85
    )
 
86
from bzrlib.version_info_formats.format_rio import (
 
87
    RioVersionInfoBuilder,
 
88
    )
69
89
from bzrlib.send import (
70
90
    format_registry as send_format_registry,
71
91
    )
113
133
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
114
134
    "RevisionSpec_git")
115
135
 
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
 
136
try:
 
137
    from bzrlib.revisionspec import dwim_revspecs
 
138
except ImportError:
 
139
    pass
 
140
else:
121
141
    from bzrlib.plugins.git.revspec import RevisionSpec_git
122
142
    dwim_revspecs.append(RevisionSpec_git)
123
143
 
124
144
 
 
145
class GitControlDirFormat(ControlDirFormat):
 
146
 
 
147
    _lock_class = TransportLock
 
148
 
 
149
    colocated_branches = True
 
150
 
 
151
    def __eq__(self, other):
 
152
        return type(self) == type(other)
 
153
 
 
154
    def is_supported(self):
 
155
        return True
 
156
 
 
157
    def network_name(self):
 
158
        return "git"
 
159
 
 
160
 
125
161
class LocalGitProber(Prober):
126
162
 
127
163
    def probe_transport(self, transport):
128
164
        try:
129
 
            if not transport.has_any(['info/refs', '.git/HEAD', 'HEAD', 'objects', '.git/objects']):
 
165
            if not transport.has_any(['info/refs', '.git/branches',
 
166
                                      'branches']):
130
167
                raise bzr_errors.NotBranchError(path=transport.base)
131
168
        except bzr_errors.NoSuchFile:
132
169
            raise bzr_errors.NotBranchError(path=transport.base)
141
178
        except dulwich.errors.NotGitRepository, e:
142
179
            raise bzr_errors.NotBranchError(path=transport.base)
143
180
        else:
144
 
            from bzrlib.plugins.git.dir import (
145
 
                BareLocalGitControlDirFormat,
146
 
                LocalGitControlDirFormat,
147
 
                )
148
181
            if gitrepo.bare:
149
182
                return BareLocalGitControlDirFormat()
150
183
            else:
151
184
                return LocalGitControlDirFormat()
152
185
 
153
 
    @classmethod
154
 
    def known_formats(cls):
155
 
        from bzrlib.plugins.git.dir import (
156
 
            BareLocalGitControlDirFormat,
157
 
            LocalGitControlDirFormat,
158
 
            )
159
 
        return set([BareLocalGitControlDirFormat(), LocalGitControlDirFormat()])
 
186
 
 
187
class LocalGitControlDirFormat(GitControlDirFormat):
 
188
    """The .git directory control format."""
 
189
 
 
190
    bare = False
 
191
 
 
192
    @classmethod
 
193
    def _known_formats(self):
 
194
        return set([LocalGitControlDirFormat()])
 
195
 
 
196
    def open(self, transport, _found=None):
 
197
        """Open this directory.
 
198
 
 
199
        """
 
200
        lazy_check_versions()
 
201
        from bzrlib.plugins.git.transportgit import TransportRepo
 
202
        gitrepo = TransportRepo(transport)
 
203
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
 
204
        lockfiles = GitLockableFiles(transport, GitLock())
 
205
        return LocalGitDir(transport, lockfiles, gitrepo, self)
 
206
 
 
207
    @classmethod
 
208
    def probe_transport(klass, transport):
 
209
        prober = LocalGitProber()
 
210
        return prober.probe_transport(transport)
 
211
 
 
212
    def get_format_description(self):
 
213
        return "Local Git Repository"
 
214
 
 
215
    def initialize_on_transport(self, transport):
 
216
        from bzrlib.transport.local import LocalTransport
 
217
 
 
218
        if not isinstance(transport, LocalTransport):
 
219
            raise NotImplementedError(self.initialize,
 
220
                "Can't create Git Repositories/branches on "
 
221
                "non-local transports")
 
222
        lazy_check_versions()
 
223
        from dulwich.repo import Repo
 
224
        Repo.init(transport.local_abspath(".").encode(osutils._fs_enc),
 
225
            bare=self.bare)
 
226
        return self.open(transport)
 
227
 
 
228
    def is_supported(self):
 
229
        return True
 
230
 
 
231
 
 
232
class BareLocalGitControlDirFormat(LocalGitControlDirFormat):
 
233
 
 
234
    bare = True
 
235
    supports_workingtrees = False
 
236
 
 
237
    @classmethod
 
238
    def _known_formats(self):
 
239
        return set([RemoteGitControlDirFormat()])
 
240
 
 
241
    def get_format_description(self):
 
242
        return "Local Git Repository (bare)"
160
243
 
161
244
 
162
245
class RemoteGitProber(Prober):
168
251
        if (not url.startswith("git://") and not url.startswith("git+")):
169
252
            raise bzr_errors.NotBranchError(transport.base)
170
253
        # little ugly, but works
171
 
        from bzrlib.plugins.git.remote import (
172
 
            GitSmartTransport,
173
 
            RemoteGitControlDirFormat,
174
 
            )
 
254
        from bzrlib.plugins.git.remote import GitSmartTransport
175
255
        if not isinstance(transport, GitSmartTransport):
176
256
            raise bzr_errors.NotBranchError(transport.base)
177
257
        return RemoteGitControlDirFormat()
178
258
 
 
259
 
 
260
 
 
261
class RemoteGitControlDirFormat(GitControlDirFormat):
 
262
    """The .git directory control format."""
 
263
 
 
264
    supports_workingtrees = False
 
265
 
179
266
    @classmethod
180
 
    def known_formats(cls):
181
 
        from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
 
267
    def _known_formats(self):
182
268
        return set([RemoteGitControlDirFormat()])
183
269
 
184
 
 
185
 
if not getattr(Prober, "known_formats", None): # bzr < 2.4
186
 
    from bzrlib.plugins.git.dir import (
187
 
        LocalGitControlDirFormat, BareLocalGitControlDirFormat,
188
 
        )
189
 
    from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
 
270
    def open(self, transport, _found=None):
 
271
        """Open this directory.
 
272
 
 
273
        """
 
274
        # we dont grok readonly - git isn't integrated with transport.
 
275
        url = transport.base
 
276
        if url.startswith('readonly+'):
 
277
            url = url[len('readonly+'):]
 
278
        if (not url.startswith("git://") and not url.startswith("git+")):
 
279
            raise bzr_errors.NotBranchError(transport.base)
 
280
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
 
281
        if not isinstance(transport, GitSmartTransport):
 
282
            raise bzr_errors.NotBranchError(transport.base)
 
283
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
 
284
        lockfiles = GitLockableFiles(transport, GitLock())
 
285
        return RemoteGitDir(transport, lockfiles, self)
 
286
 
 
287
    @classmethod
 
288
    def probe_transport(klass, transport):
 
289
        """Our format is present if the transport ends in '.not/'."""
 
290
        prober = RemoteGitProber()
 
291
        return prober.probe_transport(transport)
 
292
 
 
293
    def get_format_description(self):
 
294
        return "Remote Git Repository"
 
295
 
 
296
    def initialize_on_transport(self, transport):
 
297
        raise bzr_errors.UninitializableFormat(self)
 
298
 
 
299
 
 
300
if has_controldir:
190
301
    ControlDirFormat.register_format(LocalGitControlDirFormat())
191
302
    ControlDirFormat.register_format(BareLocalGitControlDirFormat())
192
303
    ControlDirFormat.register_format(RemoteGitControlDirFormat())
193
 
    # Provide RevisionTree.get_file_revision, so various parts of bzr-svn
194
 
    # can avoid inventories.
195
 
    from bzrlib.revisiontree import RevisionTree
196
 
    def get_file_revision(tree, file_id, path=None):
197
 
        return tree.inventory[file_id].revision
198
 
    RevisionTree.get_file_revision = get_file_revision
199
 
 
200
 
ControlDirFormat.register_prober(LocalGitProber)
201
 
ControlDirFormat.register_prober(RemoteGitProber)
 
304
    ControlDirFormat.register_prober(LocalGitProber)
 
305
    ControlDirFormat.register_prober(RemoteGitProber)
 
306
else:
 
307
    ControlDirFormat.register_control_format(LocalGitControlDirFormat)
 
308
    ControlDirFormat.register_control_format(BareLocalGitControlDirFormat)
 
309
    ControlDirFormat.register_control_format(RemoteGitControlDirFormat)
202
310
 
203
311
register_transport_proto('git://',
204
312
        help="Access using the Git smart server protocol.")
224
332
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
225
333
        stanza.add("git-commit", rev.foreign_revid)
226
334
 
227
 
try:
228
 
    from bzrlib.hooks import install_lazy_named_hook
229
 
except ImportError: # Compatibility with bzr < 2.4
230
 
    from bzrlib.version_info_formats.format_rio import (
231
 
        RioVersionInfoBuilder,
232
 
        )
233
 
    RioVersionInfoBuilder.hooks.install_named_hook('revision', update_stanza,
234
 
        "git commits")
235
 
else:
236
 
    install_lazy_named_hook("bzrlib.version_info_formats.format_rio",
237
 
        "RioVersionInfoBuilder.hooks", "revision", update_stanza,
238
 
        "git commits")
 
335
 
 
336
rio_hooks = getattr(RioVersionInfoBuilder, "hooks", None)
 
337
if rio_hooks is not None:
 
338
    rio_hooks.install_named_hook('revision', update_stanza, None)
239
339
 
240
340
 
241
341
from bzrlib.transport import transport_server_registry
246
346
 
247
347
 
248
348
from bzrlib.repository import (
249
 
    format_registry as repository_format_registry,
250
349
    network_format_registry as repository_network_format_registry,
251
350
    )
252
351
repository_network_format_registry.register_lazy('git',
253
352
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
254
353
 
255
354
try:
256
 
    register_extra_lazy_repository_format = getattr(repository_format_registry,
257
 
        "register_extra_lazy")
258
 
except AttributeError: # bzr < 2.4
259
 
    pass
260
 
else:
261
 
    register_extra_lazy_repository_format('bzrlib.plugins.git.repository',
262
 
        'GitRepositoryFormat')
263
 
 
264
 
from bzrlib.branch import (
265
 
    network_format_registry as branch_network_format_registry,
266
 
    )
267
 
branch_network_format_registry.register_lazy('git',
268
 
    'bzrlib.plugins.git.branch', 'GitBranchFormat')
269
 
 
270
 
try:
271
 
    from bzrlib.branch import (
272
 
        format_registry as branch_format_registry,
273
 
        )
274
 
except ImportError: # bzr < 2.4
275
 
    pass
276
 
else:
277
 
    branch_format_registry.register_extra_lazy(
278
 
        'bzrlib.plugins.git.branch',
279
 
        'GitBranchFormat',
280
 
        )
281
 
 
282
 
try:
283
 
    from bzrlib.workingtree import (
284
 
        format_registry as workingtree_format_registry,
285
 
        )
286
 
except ImportError: # bzr < 2.4
287
 
    pass
288
 
else:
289
 
    workingtree_format_registry.register_extra_lazy(
290
 
        'bzrlib.plugins.git.workingtree',
291
 
        'GitWorkingTreeFormat',
292
 
        )
293
 
 
294
 
controldir_network_format_registry.register_lazy('git',
295
 
    "bzrlib.plugins.git.dir", "GitControlDirFormat")
 
355
    from bzrlib.controldir import (
 
356
        network_format_registry as controldir_network_format_registry,
 
357
        )
 
358
except ImportError:
 
359
    from bzrlib.bzrdir import (
 
360
        network_format_registry as controldir_network_format_registry,
 
361
        )
 
362
controldir_network_format_registry.register('git', GitControlDirFormat)
296
363
 
297
364
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
298
365
                                   'send_git', 'Git am-style diff format')
299
366
 
300
 
topic_registry.register_lazy('git', 'bzrlib.plugins.git.help', 'help_git',
301
 
    'Using Bazaar with Git')
 
367
topic_registry.register_lazy('git',
 
368
                             'bzrlib.plugins.git.help',
 
369
                             'help_git', 'Using Bazaar with Git')
302
370
 
303
 
from bzrlib.diff import format_registry as diff_format_registry
304
 
diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
305
 
    'GitDiffTree', 'Git am-style diff format')
 
371
try:
 
372
    from bzrlib.diff import format_registry as diff_format_registry
 
373
except ImportError:
 
374
    pass
 
375
else:
 
376
    diff_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
 
377
        'GitDiffTree', 'Git am-style diff format')
306
378
 
307
379
def test_suite():
308
380
    from bzrlib.plugins.git import tests