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
- browse files at revision 0.200.18
- compare with another revision
- download diff
- download tarball
- view history from revision 0.200.18
- Committer: John Arbash Meinel
- Date: 2007-11-08 23:44:31 UTC
- mto: (0.312.1 master) (6883.23.1 bundle-git)
- mto: This revision was merged to the branch mainline in revision 6960.
- Revision ID: john@arbash-meinel.com-20071108234431-voyj8yoshevk353j
Start splitting up the Git{Branch,Dir,Repository} into separate modules, etc.
- files added:
- INSTALL
- gitlib
- files removed:
- HACKING
- notes
- files renamed:
- branch.py => gitlib/git_branch.py
- dir.py => gitlib/git_dir.py
- repository.py => gitlib/git_repository.py
- mapping.py => gitlib/ids.py
- tests/test_branch.py => tests/test_git_branch.py
- tests/test_dir.py => tests/test_git_dir.py
- tests/test_repository.py => tests/test_git_repository.py
- tests/test_mapping.py => tests/test_ids.py
- files modified:
- .bzrignore
added
removed
__init__.py
1
# Copyright (C) 2006-2009 Canonical Ltd
2
1
# Copyright (C) 2006 Canonical Ltd
3
2
# Authors: Robert Collins <robert.collins@canonical.com>
4
# Jelmer Vernooij <jelmer@samba.org>
5
# John Carr <john.carr@unrouted.co.uk>
6
3
#
7
4
# This program is free software; you can redistribute it and/or modify
8
5
# it under the terms of the GNU General Public License as published by
21
18
22
19
"""A GIT branch and repository format implementation for bzr."""
23
20
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
21
22
from StringIO import StringIO
23
24
import stgit
25
import stgit.git as git
44
26
45
27
from bzrlib import (
46
errors as bzr_errors,
28
commands,
29
config,
30
deprecated_graph,
31
iterablefile,
47
32
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
69
70
from bzrlib.foreign import (
71
foreign_vcs_registry,
72
)
73
from bzrlib.help_topics import (
74
topic_registry,
75
)
76
from bzrlib.lockable_files import (
77
TransportLock,
78
)
79
from bzrlib.transport import (
80
register_lazy_transport,
81
register_transport_proto,
82
)
83
from bzrlib.commands import (
84
plugin_cmds,
85
)
86
from bzrlib.version_info_formats.format_rio import (
87
RioVersionInfoBuilder,
88
)
89
from bzrlib.send import (
90
format_registry as send_format_registry,
91
)
92
93
94
if getattr(sys, "frozen", None):
95
# allow import additional libs from ./_lib for bzr.exe only
96
sys.path.append(os.path.normpath(
97
os.path.join(os.path.dirname(__file__), '_lib')))
98
99
100
def import_dulwich():
101
try:
102
from dulwich import __version__ as dulwich_version
103
except ImportError:
104
raise bzr_errors.DependencyNotPresent("dulwich",
105
"bzr-git: Please install dulwich, https://launchpad.net/dulwich")
106
else:
107
if dulwich_version < dulwich_minimum_version:
108
raise bzr_errors.DependencyNotPresent("dulwich",
109
"bzr-git: Dulwich is too old; at least %d.%d.%d is required" %
110
dulwich_minimum_version)
111
112
113
_versions_checked = False
114
def lazy_check_versions():
115
global _versions_checked
116
if _versions_checked:
117
return
118
import_dulwich()
119
_versions_checked = True
120
121
format_registry.register_lazy('git',
122
"bzrlib.plugins.git.dir", "LocalGitControlDirFormat",
123
help='GIT repository.', native=False, experimental=False,
124
)
125
126
format_registry.register_lazy('git-bare',
127
"bzrlib.plugins.git.dir", "BareLocalGitControlDirFormat",
128
help='Bare GIT repository (no working tree).', native=False,
129
experimental=False,
130
)
131
132
from bzrlib.revisionspec import revspec_registry
133
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec",
134
"RevisionSpec_git")
135
136
try:
137
from bzrlib.revisionspec import dwim_revspecs
138
except ImportError:
139
pass
140
else:
141
from bzrlib.plugins.git.revspec import RevisionSpec_git
142
dwim_revspecs.append(RevisionSpec_git)
143
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
161
class LocalGitProber(Prober):
162
163
def probe_transport(self, transport):
164
try:
165
if not transport.has_any(['info/refs', '.git/branches',
166
'branches']):
167
raise bzr_errors.NotBranchError(path=transport.base)
168
except bzr_errors.NoSuchFile:
169
raise bzr_errors.NotBranchError(path=transport.base)
170
from bzrlib import urlutils
171
if urlutils.split(transport.base)[1] == ".git":
172
raise bzr_errors.NotBranchError(path=transport.base)
173
lazy_check_versions()
174
import dulwich
175
from bzrlib.plugins.git.transportgit import TransportRepo
176
try:
177
gitrepo = TransportRepo(transport)
178
except dulwich.errors.NotGitRepository, e:
179
raise bzr_errors.NotBranchError(path=transport.base)
180
else:
181
if gitrepo.bare:
182
return BareLocalGitControlDirFormat()
33
urlutils,
34
)
35
from bzrlib.decorators import *
36
import bzrlib.branch
37
import bzrlib.bzrdir
38
import bzrlib.errors as errors
39
import bzrlib.repository
40
from bzrlib.revision import Revision
41
42
43
class GitInventory(object):
44
45
def __init__(self, revision_id):
46
self.entries = {}
47
self.root = GitEntry('', 'directory', revision_id)
48
self.entries[''] = self.root
49
50
def __getitem__(self, key):
51
return self.entries[key]
52
53
def iter_entries(self):
54
return iter(sorted(self.entries.items()))
55
56
def iter_entries_by_dir(self):
57
return self.iter_entries()
58
59
def __len__(self):
60
return len(self.entries)
61
62
63
class GitEntry(object):
64
65
def __init__(self, path, kind, revision, text_sha1=None, executable=False,
66
text_size=None):
67
self.path = path
68
self.file_id = path
69
self.kind = kind
70
self.executable = executable
71
self.name = osutils.basename(path)
72
if path == '':
73
self.parent_id = None
74
else:
75
self.parent_id = osutils.dirname(path)
76
self.revision = revision
77
self.symlink_target = None
78
self.text_sha1 = text_sha1
79
self.text_size = None
80
81
def __repr__(self):
82
return "GitEntry(%r, %r, %r, %r)" % (self.path, self.kind,
83
self.revision, self.parent_id)
84
85
86
class GitModel(object):
87
"""API that follows GIT model closely"""
88
89
def __init__(self, git_dir):
90
self.git_dir = git_dir
91
92
def git_command(self, command, args):
93
args = ' '.join("'%s'" % arg for arg in args)
94
return 'git --git-dir=%s %s %s' % (self.git_dir, command, args)
95
96
def git_lines(self, command, args):
97
return stgit.git._output_lines(self.git_command(command, args))
98
99
def git_line(self, command, args):
100
return stgit.git._output_one_line(self.git_command(command, args))
101
102
def cat_file(self, type, object_id, pretty=False):
103
args = []
104
if pretty:
105
args.append('-p')
106
else:
107
args.append(type)
108
args.append(object_id)
109
return self.git_lines('cat-file', args)
110
111
def rev_list(self, heads, max_count=None, header=False):
112
args = []
113
if max_count is not None:
114
args.append('--max-count=%d' % max_count)
115
if header is not False:
116
args.append('--header')
117
if heads is None:
118
args.append('--all')
119
else:
120
args.extend(heads)
121
return self.git_lines('rev-list', args)
122
123
def rev_parse(self, git_id):
124
args = ['--verify', git_id]
125
return self.git_line('rev-parse', args)
126
127
def get_head(self):
128
return self.rev_parse('HEAD')
129
130
def ancestor_lines(self, revisions):
131
revision_lines = []
132
for line in self.rev_list(revisions, header=True):
133
if line.startswith('\x00'):
134
yield revision_lines
135
revision_lines = [line[1:].decode('latin-1')]
183
136
else:
184
return LocalGitControlDirFormat()
185
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)"
243
244
245
class RemoteGitProber(Prober):
246
247
def probe_transport(self, transport):
248
url = transport.base
249
if url.startswith('readonly+'):
250
url = url[len('readonly+'):]
251
if (not url.startswith("git://") and not url.startswith("git+")):
252
raise bzr_errors.NotBranchError(transport.base)
253
# little ugly, but works
254
from bzrlib.plugins.git.remote import GitSmartTransport
255
if not isinstance(transport, GitSmartTransport):
256
raise bzr_errors.NotBranchError(transport.base)
257
return RemoteGitControlDirFormat()
258
259
260
261
class RemoteGitControlDirFormat(GitControlDirFormat):
262
"""The .git directory control format."""
263
264
supports_workingtrees = False
265
266
@classmethod
267
def _known_formats(self):
268
return set([RemoteGitControlDirFormat()])
269
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:
301
ControlDirFormat.register_format(LocalGitControlDirFormat())
302
ControlDirFormat.register_format(BareLocalGitControlDirFormat())
303
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)
310
311
register_transport_proto('git://',
312
help="Access using the Git smart server protocol.")
313
register_transport_proto('git+ssh://',
314
help="Access using the Git smart server protocol over SSH.")
315
316
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
317
'TCPGitSmartTransport')
318
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
319
'SSHGitSmartTransport')
320
321
foreign_vcs_registry.register_lazy("git",
322
"bzrlib.plugins.git.mapping", "foreign_git", "Stupid content tracker")
323
324
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
325
plugin_cmds.register_lazy("cmd_git_object", ["git-objects", "git-cat"],
326
"bzrlib.plugins.git.commands")
327
plugin_cmds.register_lazy("cmd_git_refs", [], "bzrlib.plugins.git.commands")
328
plugin_cmds.register_lazy("cmd_git_apply", [], "bzrlib.plugins.git.commands")
329
330
def update_stanza(rev, stanza):
331
mapping = getattr(rev, "mapping", None)
332
if mapping is not None and mapping.revid_prefix.startswith("git-"):
333
stanza.add("git-commit", rev.foreign_revid)
334
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)
339
340
341
from bzrlib.transport import transport_server_registry
342
transport_server_registry.register_lazy('git',
343
'bzrlib.plugins.git.server',
344
'serve_git',
345
'Git Smart server protocol over TCP. (default port: 9418)')
346
347
348
from bzrlib.repository import (
349
network_format_registry as repository_network_format_registry,
350
)
351
repository_network_format_registry.register_lazy('git',
352
'bzrlib.plugins.git.repository', 'GitRepositoryFormat')
353
354
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)
363
364
send_format_registry.register_lazy('git', 'bzrlib.plugins.git.send',
365
'send_git', 'Git am-style diff format')
366
367
topic_registry.register_lazy('git',
368
'bzrlib.plugins.git.help',
369
'help_git', 'Using Bazaar with Git')
370
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')
378
137
revision_lines.append(line.decode('latin-1'))
138
assert revision_lines == ['']
139
140
def get_inventory(self, tree_id):
141
for line in self.cat_file('tree', tree_id, True):
142
sections = line.split(' ', 2)
143
obj_id, name = sections[2].split('\t', 1)
144
name = name.rstrip('\n')
145
if name.startswith('"'):
146
name = name[1:-1].decode('string_escape').decode('utf-8')
147
yield (sections[0], sections[1], obj_id, name)
148
149
150
class cmd_test_git(commands.Command):
151
152
def run(self):
153
from bzrlib.tests import selftest
154
selftest
379
155
def test_suite():
380
156
from bzrlib.plugins.git import tests
381
157
return tests.test_suite()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0