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.201.1
- compare with another revision
- download diff
- download tarball
- view history from revision 0.201.1
- Committer: Jelmer Vernooij
- Date: 2007-02-02 18:08:31 UTC
- mto: (0.200.14 trunk)
- mto: This revision was merged to the branch mainline in revision 6960.
- Revision ID: jelmer@samba.org-20070202180831-a0owuofc45bmuoch
Add very small initial testsuite.
- files added:
- INSTALL
- files removed:
- HACKING
- notes
- files renamed:
- 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
44
45
from bzrlib import (
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
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()
183
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
21
22
from StringIO import StringIO
23
24
import stgit
25
import stgit.git as git
26
27
from bzrlib import config, iterablefile, graph, osutils, urlutils
28
from bzrlib.decorators import *
29
import bzrlib.branch
30
import bzrlib.bzrdir
31
import bzrlib.errors as errors
32
import bzrlib.repository
33
from bzrlib.revision import Revision
34
35
36
class GitBranchConfig(config.BranchConfig):
37
"""BranchConfig that uses locations.conf in place of branch.conf"""
38
39
def __init__(self, branch):
40
config.BranchConfig.__init__(self, branch)
41
# do not provide a BranchDataConfig
42
self.option_sources = self.option_sources[0], self.option_sources[2]
43
44
def set_user_option(self, name, value, local=False):
45
"""Force local to True"""
46
config.BranchConfig.set_user_option(self, name, value, local=True)
47
48
49
def gitrevid_from_bzr(revision_id):
50
if revision_id is None:
51
return None
52
return revision_id[4:]
53
54
55
def bzrrevid_from_git(revision_id):
56
return "git:" + revision_id
57
58
59
class GitLock(object):
60
"""A lock that thunks through to Git."""
61
62
def lock_write(self):
63
pass
64
65
def lock_read(self):
66
pass
67
68
def unlock(self):
69
pass
70
71
72
class GitLockableFiles(bzrlib.lockable_files.LockableFiles):
73
"""Git specific lockable files abstraction."""
74
75
def __init__(self, lock):
76
self._lock = lock
77
self._transaction = None
78
self._lock_mode = None
79
self._lock_count = 0
80
81
82
class GitDir(bzrlib.bzrdir.BzrDir):
83
"""An adapter to the '.git' dir used by git."""
84
85
def __init__(self, transport, lockfiles, format):
86
self._format = format
87
self.root_transport = transport
88
self.transport = transport.clone('.git')
89
self._lockfiles = lockfiles
90
91
def get_branch_transport(self, branch_format):
92
if branch_format is None:
93
return self.transport
94
if isinstance(branch_format, GitBzrDirFormat):
95
return self.transport
96
raise errors.IncompatibleFormat(branch_format, self._format)
97
98
get_repository_transport = get_branch_transport
99
get_workingtree_transport = get_branch_transport
100
101
def is_supported(self):
102
return True
103
104
def open_branch(self, ignored=None):
105
"""'crate' a branch for this dir."""
106
return GitBranch(self, self._lockfiles)
107
108
def open_repository(self, shared=False):
109
"""'open' a repository for this dir."""
110
return GitRepository(self._gitrepo, self, self._lockfiles)
111
112
def open_workingtree(self):
113
loc = urlutils.unescape_for_display(self.root_transport.base, 'ascii')
114
raise errors.NoWorkingTree(loc)
115
116
117
class GitBzrDirFormat(bzrlib.bzrdir.BzrDirFormat):
118
"""The .git directory control format."""
119
120
@classmethod
121
def _known_formats(self):
122
return set([GitBzrDirFormat()])
123
124
def open(self, transport, _create=False, _found=None):
125
"""Open this directory.
126
127
:param _create: create the git dir on the fly. private to GitDirFormat.
273
128
"""
274
129
# we dont grok readonly - git isn't integrated with transport.
275
130
url = transport.base
276
131
if url.startswith('readonly+'):
277
132
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)
133
if url.startswith('file://'):
134
url = url[len('file://'):]
135
url = url.encode('utf8')
136
if not transport.has('.git'):
137
raise errors.NotBranchError(path=transport.base)
138
lockfiles = GitLockableFiles(GitLock())
139
return GitDir(transport, lockfiles, self)
286
140
287
141
@classmethod
288
142
def probe_transport(klass, transport):
289
143
"""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')
144
# little ugly, but works
145
format = klass()
146
# try a manual probe first, its a little faster perhaps ?
147
if transport.has('.git'):
148
return format
149
# delegate to the main opening code. This pays a double rtt cost at the
150
# moment, so perhaps we want probe_transport to return the opened thing
151
# rather than an openener ? or we could return a curried thing with the
152
# dir to open already instantiated ? Needs more thought.
153
try:
154
format.open(transport)
155
return format
156
except Exception, e:
157
raise errors.NotBranchError(path=transport.base)
158
raise errors.NotBranchError(path=transport.base)
159
160
161
bzrlib.bzrdir.BzrDirFormat.register_control_format(GitBzrDirFormat)
162
163
164
class GitBranch(bzrlib.branch.Branch):
165
"""An adapter to git repositories for bzr Branch objects."""
166
167
def __init__(self, gitdir, lockfiles):
168
self.bzrdir = gitdir
169
self.control_files = lockfiles
170
self.repository = GitRepository(gitdir, lockfiles)
171
self.base = gitdir.root_transport.base
172
if '.git' not in gitdir.root_transport.list_dir('.'):
173
raise errors.NotBranchError(self.base)
174
175
def lock_write(self):
176
self.control_files.lock_write()
177
178
@needs_read_lock
179
def last_revision(self):
180
# perhaps should escape this ?
181
return bzrrevid_from_git(self.repository.git.get_head())
182
183
@needs_read_lock
184
def revision_history(self):
185
node = self.last_revision()
186
ancestors = self.repository.get_revision_graph(node)
187
history = []
188
while node is not None:
189
history.append(node)
190
if len(ancestors[node]) > 0:
191
node = ancestors[node][0]
192
else:
193
node = None
194
return list(reversed(history))
195
196
def get_config(self):
197
return GitBranchConfig(self)
198
199
def lock_read(self):
200
self.control_files.lock_read()
201
202
def unlock(self):
203
self.control_files.unlock()
204
205
def get_push_location(self):
206
"""See Branch.get_push_location."""
207
push_loc = self.get_config().get_user_option('push_location')
208
return push_loc
209
210
def set_push_location(self, location):
211
"""See Branch.set_push_location."""
212
self.get_config().set_user_option('push_location', location,
213
local=True)
214
215
216
class GitRepository(bzrlib.repository.Repository):
217
"""An adapter to git repositories for bzr."""
218
219
def __init__(self, gitdir, lockfiles):
220
self.bzrdir = gitdir
221
self.control_files = lockfiles
222
gitdirectory = urlutils.local_path_from_url(gitdir.transport.base)
223
self.git = GitModel(gitdirectory)
224
self._revision_cache = {}
225
226
def _ancestor_revisions(self, revision_ids):
227
if revision_ids is not None:
228
git_revisions = [gitrevid_from_bzr(r) for r in revision_ids]
229
else:
230
git_revisions = None
231
for lines in self.git.ancestor_lines(git_revisions):
232
yield self.parse_rev(lines)
233
234
def is_shared(self):
235
return True
236
237
def get_revision_graph(self, revision_id=None):
238
if revision_id is None:
239
revisions = None
240
else:
241
revisions = [revision_id]
242
return self.get_revision_graph_with_ghosts(revisions).get_ancestors()
243
244
def get_revision_graph_with_ghosts(self, revision_ids=None):
245
result = graph.Graph()
246
for revision in self._ancestor_revisions(revision_ids):
247
result.add_node(revision.revision_id, revision.parent_ids)
248
self._revision_cache[revision.revision_id] = revision
249
return result
250
251
def get_revision(self, revision_id):
252
if revision_id in self._revision_cache:
253
return self._revision_cache[revision_id]
254
raw = self.git.rev_list([gitrevid_from_bzr(revision_id)], max_count=1,
255
header=True)
256
return self.parse_rev(raw)
257
258
def has_revision(self, revision_id):
259
try:
260
self.get_revision(revision_id)
261
except NoSuchRevision:
262
return False
263
else:
264
return True
265
266
def get_revisions(self, revisions):
267
return [self.get_revision(r) for r in revisions]
268
269
def parse_rev(self, raw):
270
# first field is the rev itself.
271
# then its 'field value'
272
# until the EOF??
273
parents = []
274
log = []
275
in_log = False
276
committer = None
277
revision_id = bzrrevid_from_git(raw[0][:-1])
278
for field in raw[1:]:
279
#if field.startswith('author '):
280
# committer = field[7:]
281
if field.startswith('parent '):
282
parents.append(bzrrevid_from_git(field.split()[1]))
283
elif field.startswith('committer '):
284
commit_fields = field.split()
285
if committer is None:
286
committer = ' '.join(commit_fields[1:-3])
287
timestamp = commit_fields[-2]
288
timezone = commit_fields[-1]
289
elif field.startswith('tree '):
290
tree_id = field.split()[1]
291
elif in_log:
292
log.append(field[4:])
293
elif field == '\n':
294
in_log = True
295
296
log = ''.join(log)
297
result = Revision(revision_id)
298
result.parent_ids = parents
299
result.message = log
300
result.inventory_sha1 = ""
301
result.timezone = timezone and int(timezone)
302
result.timestamp = float(timestamp)
303
result.committer = committer
304
result.properties['git-tree-id'] = tree_id
305
return result
306
307
def revision_tree(self, revision_id):
308
return GitRevisionTree(self, revision_id)
309
310
def get_inventory(self, revision_id):
311
revision = self.get_revision(revision_id)
312
inventory = GitInventory(revision_id)
313
tree_id = revision.properties['git-tree-id']
314
type_map = {'blob': 'file', 'tree': 'directory' }
315
def get_inventory(tree_id, prefix):
316
for perms, type, obj_id, name in self.git.get_inventory(tree_id):
317
full_path = prefix + name
318
if type == 'blob':
319
text_sha1 = obj_id
320
else:
321
text_sha1 = None
322
executable = (perms[-3] in ('1', '3', '5', '7'))
323
entry = GitEntry(full_path, type_map[type], revision_id,
324
text_sha1, executable)
325
inventory.entries[full_path] = entry
326
if type == 'tree':
327
get_inventory(obj_id, full_path+'/')
328
get_inventory(tree_id, '')
329
return inventory
330
331
332
class GitRevisionTree(object):
333
334
def __init__(self, repository, revision_id):
335
self.repository = repository
336
self.revision_id = revision_id
337
self.inventory = repository.get_inventory(revision_id)
338
339
def get_file(self, file_id):
340
obj_id = self.inventory[file_id].text_sha1
341
lines = self.repository.git.cat_file('blob', obj_id)
342
return iterablefile.IterableFile(lines)
343
344
def is_executable(self, file_id):
345
return self.inventory[file_id].executable
346
347
348
class GitInventory(object):
349
350
def __init__(self, revision_id):
351
self.entries = {}
352
self.root = GitEntry('', 'directory', revision_id)
353
self.entries[''] = self.root
354
355
def __getitem__(self, key):
356
return self.entries[key]
357
358
def iter_entries(self):
359
return iter(sorted(self.entries.items()))
360
361
def iter_entries_by_dir(self):
362
return self.iter_entries()
363
364
def __len__(self):
365
return len(self.entries)
366
367
368
class GitEntry(object):
369
370
def __init__(self, path, kind, revision, text_sha1=None, executable=False,
371
text_size=None):
372
self.path = path
373
self.file_id = path
374
self.kind = kind
375
self.executable = executable
376
self.name = osutils.basename(path)
377
if path == '':
378
self.parent_id = None
379
else:
380
self.parent_id = osutils.dirname(path)
381
self.revision = revision
382
self.symlink_target = None
383
self.text_sha1 = text_sha1
384
self.text_size = None
385
386
def __repr__(self):
387
return "GitEntry(%r, %r, %r, %r)" % (self.path, self.kind,
388
self.revision, self.parent_id)
389
390
391
class GitModel(object):
392
"""API that follows GIT model closely"""
393
394
def __init__(self, git_dir):
395
self.git_dir = git_dir
396
397
def git_command(self, command, args):
398
args = ' '.join("'%s'" % arg for arg in args)
399
return 'git --git-dir=%s %s %s' % (self.git_dir, command, args)
400
401
def git_lines(self, command, args):
402
return stgit.git._output_lines(self.git_command(command, args))
403
404
def git_line(self, command, args):
405
return stgit.git._output_one_line(self.git_command(command, args))
406
407
def cat_file(self, type, object_id, pretty=False):
408
args = []
409
if pretty:
410
args.append('-p')
411
else:
412
args.append(type)
413
args.append(object_id)
414
return self.git_lines('cat-file', args)
415
416
def rev_list(self, heads, max_count=None, header=False):
417
args = []
418
if max_count is not None:
419
args.append('--max-count=%d' % max_count)
420
if header is not False:
421
args.append('--header')
422
if heads is None:
423
args.append('--all')
424
else:
425
args.extend(heads)
426
return self.git_lines('rev-list', args)
427
428
def rev_parse(self, git_id):
429
args = ['--verify', git_id]
430
return self.git_line('rev-parse', args)
431
432
def get_head(self):
433
return self.rev_parse('HEAD')
434
435
def ancestor_lines(self, revisions):
436
revision_lines = []
437
for line in self.rev_list(revisions, header=True):
438
if line.startswith('\x00'):
439
yield revision_lines
440
revision_lines = [line[1:].decode('latin-1')]
441
else:
442
revision_lines.append(line.decode('latin-1'))
443
assert revision_lines == ['']
444
445
def get_inventory(self, tree_id):
446
for line in self.cat_file('tree', tree_id, True):
447
sections = line.split(' ', 2)
448
obj_id, name = sections[2].split('\t', 1)
449
name = name.rstrip('\n')
450
if name.startswith('"'):
451
name = name[1:-1].decode('string_escape').decode('utf-8')
452
yield (sections[0], sections[1], obj_id, name)
378
453
379
454
def test_suite():
380
from bzrlib.plugins.git import tests
381
return tests.test_suite()
455
from unittest import TestSuite, TestLoader
456
import tests
457
458
suite = TestSuite()
459
460
suite.addTest(tests.test_suite())
461
462
return suite
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0