/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

Provide GitRepository.reconcile.

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
 
    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
 
47
    )
 
48
 
 
49
from bzrlib.controldir import (
 
50
    ControlDirFormat,
 
51
    Prober,
 
52
    format_registry,
 
53
    network_format_registry as controldir_network_format_registry,
 
54
    )
69
55
 
70
56
from bzrlib.foreign import (
71
57
    foreign_vcs_registry,
73
59
from bzrlib.help_topics import (
74
60
    topic_registry,
75
61
    )
76
 
from bzrlib.lockable_files import (
77
 
    TransportLock,
78
 
    )
79
62
from bzrlib.transport import (
80
63
    register_lazy_transport,
81
64
    register_transport_proto,
83
66
from bzrlib.commands import (
84
67
    plugin_cmds,
85
68
    )
86
 
from bzrlib.version_info_formats.format_rio import (
87
 
    RioVersionInfoBuilder,
88
 
    )
89
69
from bzrlib.send import (
90
70
    format_registry as send_format_registry,
91
71
    )
133
113
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
134
114
    "RevisionSpec_git")
135
115
 
136
 
try:
137
 
    from bzrlib.revisionspec import dwim_revspecs
138
 
except ImportError:
139
 
    pass
140
 
else:
 
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
141
121
    from bzrlib.plugins.git.revspec import RevisionSpec_git
142
122
    dwim_revspecs.append(RevisionSpec_git)
143
123
 
144
124
 
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
 
 
161
125
class LocalGitProber(Prober):
162
126
 
163
127
    def probe_transport(self, transport):
164
128
        try:
165
 
            if not transport.has_any(['info/refs', '.git/branches',
166
 
                                      'branches']):
 
129
            if not transport.has_any(['info/refs', '.git/HEAD', 'HEAD', 'objects', '.git/objects']):
167
130
                raise bzr_errors.NotBranchError(path=transport.base)
168
131
        except bzr_errors.NoSuchFile:
169
132
            raise bzr_errors.NotBranchError(path=transport.base)
178
141
        except dulwich.errors.NotGitRepository, e:
179
142
            raise bzr_errors.NotBranchError(path=transport.base)
180
143
        else:
 
144
            from bzrlib.plugins.git.dir import (
 
145
                BareLocalGitControlDirFormat,
 
146
                LocalGitControlDirFormat,
 
147
                )
181
148
            if gitrepo.bare:
182
149
                return BareLocalGitControlDirFormat()
183
150
            else:
184
151
                return LocalGitControlDirFormat()
185
152
 
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)"
 
153
    @classmethod
 
154
    def known_formats(cls):
 
155
        from bzrlib.plugins.git.dir import (
 
156
            BareLocalGitControlDirFormat,
 
157
            LocalGitControlDirFormat,
 
158
            )
 
159
        return set([BareLocalGitControlDirFormat(), LocalGitControlDirFormat()])
243
160
 
244
161
 
245
162
class RemoteGitProber(Prober):
251
168
        if (not url.startswith("git://") and not url.startswith("git+")):
252
169
            raise bzr_errors.NotBranchError(transport.base)
253
170
        # little ugly, but works
254
 
        from bzrlib.plugins.git.remote import GitSmartTransport
 
171
        from bzrlib.plugins.git.remote import (
 
172
            GitSmartTransport,
 
173
            RemoteGitControlDirFormat,
 
174
            )
255
175
        if not isinstance(transport, GitSmartTransport):
256
176
            raise bzr_errors.NotBranchError(transport.base)
257
177
        return RemoteGitControlDirFormat()
258
178
 
259
 
 
260
 
 
261
 
class RemoteGitControlDirFormat(GitControlDirFormat):
262
 
    """The .git directory control format."""
263
 
 
264
 
    supports_workingtrees = False
265
 
 
266
179
    @classmethod
267
 
    def _known_formats(self):
 
180
    def known_formats(cls):
 
181
        from bzrlib.plugins.git.remote import RemoteGitControlDirFormat
268
182
        return set([RemoteGitControlDirFormat()])
269
183
 
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:
 
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
301
190
    ControlDirFormat.register_format(LocalGitControlDirFormat())
302
191
    ControlDirFormat.register_format(BareLocalGitControlDirFormat())
303
192
    ControlDirFormat.register_format(RemoteGitControlDirFormat())
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)
 
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)
310
202
 
311
203
register_transport_proto('git://',
312
204
        help="Access using the Git smart server protocol.")
332
224
    if mapping is not None and mapping.revid_prefix.startswith("git-"):
333
225
        stanza.add("git-commit", rev.foreign_revid)
334
226
 
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)
 
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")
339
239
 
340
240
 
341
241
from bzrlib.transport import transport_server_registry
346
246
 
347
247
 
348
248
from bzrlib.repository import (
 
249
    format_registry as repository_format_registry,
349
250
    network_format_registry as repository_network_format_registry,
350
251
    )
351
252
repository_network_format_registry.register_lazy('git',
352
253
    'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
353
254
 
354
255
try:
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)
 
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")
363
296
 
364
297
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
365
298
                                   'send_git', 'Git am-style diff format')
366
299
 
367
 
topic_registry.register_lazy('git',
368
 
                             'bzrlib.plugins.git.help',
369
 
                             'help_git', 'Using Bazaar with Git')
 
300
topic_registry.register_lazy('git', 'bzrlib.plugins.git.help', 'help_git',
 
301
    'Using Bazaar with Git')
370
302
 
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')
 
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')
378
306
 
379
307
def test_suite():
380
308
    from bzrlib.plugins.git import tests