/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

Start splitting up the Git{Branch,Dir,Repository} into separate modules, etc.

Show diffs side-by-side

added added

removed removed

Lines of Context:
__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
 
21
 
 
22
from StringIO import StringIO
 
23
 
 
24
import stgit
 
25
import stgit.git as git
 
26
 
29
27
from bzrlib import (
30
 
    bzrdir,
31
 
    errors as bzr_errors,
32
 
    )
33
 
from bzrlib.foreign import (
34
 
    foreign_vcs_registry,
35
 
    )
36
 
from bzrlib.lockable_files import (
37
 
    TransportLock,
38
 
    )
39
 
from bzrlib.transport import (
40
 
    register_lazy_transport,
41
 
    register_transport_proto,
42
 
    )
43
 
from bzrlib.commands import (
44
 
    plugin_cmds,
45
 
    )
46
 
from bzrlib.trace import (
47
 
    warning,
48
 
    )
49
 
 
50
 
# versions ending in 'exp' mean experimental mappings
51
 
# versions ending in 'dev' mean development version
52
 
# versions ending in 'final' mean release (well tested, etc)
53
 
version_info = (0, 2, 0, 'dev', 0)
54
 
 
55
 
if version_info[3] == 'final':
56
 
    version_string = '%d.%d.%d' % version_info[:3]
57
 
else:
58
 
    version_string = '%d.%d.%d%s%d' % version_info
59
 
__version__ = version_string
60
 
 
61
 
MINIMUM_DULWICH_VERSION = (0, 1, 1)
62
 
COMPATIBLE_BZR_VERSIONS = [(1, 13, 0)]
63
 
 
64
 
if getattr(sys, "frozen", None):
65
 
    # allow import additional libs from ./_lib for bzr.exe only
66
 
    sys.path.append(os.path.normpath(os.path.join(os.path.dirname(__file__), '_lib')))
67
 
 
68
 
_versions_checked = False
69
 
def lazy_check_versions():
70
 
    global _versions_checked
71
 
    if _versions_checked:
72
 
        return
73
 
    _versions_checked = True
74
 
    try:
75
 
        from dulwich import __version__ as dulwich_version
76
 
    except ImportError:
77
 
        raise ImportError("bzr-git: Please install dulwich, https://launchpad.net/dulwich")
78
 
    else:
79
 
        if dulwich_version < MINIMUM_DULWICH_VERSION:
80
 
            raise ImportError("bzr-git: Dulwich is too old; at least %d.%d.%d is required" % MINIMUM_DULWICH_VERSION)
81
 
 
82
 
bzrlib.api.require_any_api(bzrlib, COMPATIBLE_BZR_VERSIONS)
83
 
 
84
 
bzrdir.format_registry.register_lazy('git', 
85
 
    "bzrlib.plugins.git.dir", "LocalGitBzrDirFormat",
86
 
    help='GIT repository.', native=False, experimental=True,
87
 
    )
88
 
 
89
 
from bzrlib.revisionspec import revspec_registry
90
 
revspec_registry.register_lazy("git:", "bzrlib.plugins.git.revspec", 
91
 
    "RevisionSpec_git")
92
 
 
93
 
class GitBzrDirFormat(bzrdir.BzrDirFormat):
94
 
    _lock_class = TransportLock
95
 
 
96
 
    def is_supported(self):
97
 
        return True
98
 
 
99
 
 
100
 
class LocalGitBzrDirFormat(GitBzrDirFormat):
101
 
    """The .git directory control format."""
102
 
 
103
 
    @classmethod
104
 
    def _known_formats(self):
105
 
        return set([LocalGitBzrDirFormat()])
106
 
 
107
 
    def open(self, transport, _found=None):
108
 
        """Open this directory.
109
 
 
110
 
        """
111
 
        import dulwich as git
112
 
        # we dont grok readonly - git isn't integrated with transport.
113
 
        url = transport.base
114
 
        if url.startswith('readonly+'):
115
 
            url = url[len('readonly+'):]
116
 
 
117
 
        try:
118
 
            gitrepo = git.repo.Repo(transport.local_abspath("."))
119
 
        except bzr_errors.NotLocalUrl:
120
 
            raise bzr_errors.NotBranchError(path=transport.base)
121
 
        from bzrlib.plugins.git.dir import LocalGitDir, GitLockableFiles, GitLock
122
 
        lockfiles = GitLockableFiles(transport, GitLock())
123
 
        return LocalGitDir(transport, lockfiles, gitrepo, self)
124
 
 
125
 
    @classmethod
126
 
    def probe_transport(klass, transport):
127
 
        """Our format is present if the transport ends in '.not/'."""
128
 
        from bzrlib.transport.local import LocalTransport
129
 
 
130
 
        if not isinstance(transport, LocalTransport):
131
 
            raise bzr_errors.NotBranchError(path=transport.base)
132
 
 
133
 
        # This should quickly filter out most things that are not 
134
 
        # git repositories, saving us the trouble from loading dulwich.
135
 
        if not transport.has(".git") and not transport.has("objects"):
136
 
            raise bzr_errors.NotBranchError(path=transport.base)
137
 
 
138
 
        import dulwich as git
139
 
        format = klass()
140
 
        try:
141
 
            format.open(transport)
142
 
            return format
143
 
        except git.errors.NotGitRepository, e:
144
 
            raise bzr_errors.NotBranchError(path=transport.base)
145
 
        raise bzr_errors.NotBranchError(path=transport.base)
146
 
 
147
 
    def get_format_description(self):
148
 
        return "Local Git Repository"
149
 
 
150
 
    def get_format_string(self):
151
 
        return "Local Git Repository"
152
 
 
153
 
    def initialize_on_transport(self, transport):
154
 
        from bzrlib.transport.local import LocalTransport
155
 
 
156
 
        if not isinstance(transport, LocalTransport):
157
 
            raise NotImplementedError(self.initialize, 
158
 
                "Can't create Git Repositories/branches on "
159
 
                "non-local transports")
160
 
 
161
 
        from dulwich.repo import Repo
162
 
        Repo.create(transport.local_abspath(".")) 
163
 
        return self.open(transport)
164
 
 
165
 
    def is_supported(self):
166
 
        return True
167
 
 
168
 
 
169
 
class RemoteGitBzrDirFormat(GitBzrDirFormat):
170
 
    """The .git directory control format."""
171
 
 
172
 
    @classmethod
173
 
    def _known_formats(self):
174
 
        return set([RemoteGitBzrDirFormat()])
175
 
 
176
 
    def open(self, transport, _found=None):
177
 
        """Open this directory.
178
 
 
179
 
        """
180
 
        # we dont grok readonly - git isn't integrated with transport.
181
 
        url = transport.base
182
 
        if url.startswith('readonly+'):
183
 
            url = url[len('readonly+'):]
184
 
        if (not url.startswith("git://") and 
185
 
            not url.startswith("git+")):
186
 
            raise bzr_errors.NotBranchError(transport.base)
187
 
        from bzrlib.plugins.git.remote import RemoteGitDir, GitSmartTransport
188
 
        if not isinstance(transport, GitSmartTransport):
189
 
            raise bzr_errors.NotBranchError(transport.base)
190
 
        from bzrlib.plugins.git.dir import GitLockableFiles, GitLock
191
 
        lockfiles = GitLockableFiles(transport, GitLock())
192
 
        return RemoteGitDir(transport, lockfiles, self)
193
 
 
194
 
    @classmethod
195
 
    def probe_transport(klass, transport):
196
 
        """Our format is present if the transport ends in '.not/'."""
197
 
        url = transport.base
198
 
        if url.startswith('readonly+'):
199
 
            url = url[len('readonly+'):]
200
 
        if (not url.startswith("git://") and 
201
 
            not url.startswith("git+")):
202
 
            raise bzr_errors.NotBranchError(transport.base)
203
 
        # little ugly, but works
204
 
        format = klass()
205
 
        from bzrlib.plugins.git.remote import GitSmartTransport
206
 
        if not isinstance(transport, GitSmartTransport):
207
 
            raise bzr_errors.NotBranchError(transport.base)
208
 
        # The only way to know a path exists and contains a valid repository 
209
 
        # is to do a request against it:
210
 
        try:
211
 
            transport.fetch_pack(lambda x: [], None, lambda x: None, 
212
 
                                 lambda x: mutter("git: %s" % x))
213
 
        except errors.git_errors.GitProtocolError:
214
 
            raise bzr_errors.NotBranchError(path=transport.base)
215
 
        else:
216
 
            return format
217
 
        raise bzr_errors.NotBranchError(path=transport.base)
218
 
 
219
 
    def get_format_description(self):
220
 
        return "Remote Git Repository"
221
 
 
222
 
    def get_format_string(self):
223
 
        return "Remote Git Repository"
224
 
 
225
 
    def initialize_on_transport(self, transport):
226
 
        raise bzr_errors.UninitializableFormat(self)
227
 
 
228
 
 
229
 
bzrdir.BzrDirFormat.register_control_format(LocalGitBzrDirFormat)
230
 
bzrdir.BzrDirFormat.register_control_format(RemoteGitBzrDirFormat)
231
 
 
232
 
register_transport_proto('git://', 
233
 
        help="Access using the Git smart server protocol.")
234
 
register_transport_proto('git+ssh://', 
235
 
        help="Access using the Git smart server protocol over SSH.")
236
 
 
237
 
register_lazy_transport("git://", 'bzrlib.plugins.git.remote',
238
 
                        'TCPGitSmartTransport')
239
 
 
240
 
register_lazy_transport("git+ssh://", 'bzrlib.plugins.git.remote',
241
 
                        'SSHGitSmartTransport')
242
 
 
243
 
foreign_vcs_registry.register_lazy("git", 
244
 
                        "bzrlib.plugins.git.mapping", 
245
 
                        "foreign_git",
246
 
                        "Stupid content tracker")
247
 
 
248
 
plugin_cmds.register_lazy("cmd_git_serve", [], "bzrlib.plugins.git.commands")
249
 
plugin_cmds.register_lazy("cmd_git_import", [], "bzrlib.plugins.git.commands")
250
 
 
251
 
def get_rich_root_format():
252
 
    try:
253
 
        return bzrdir.format_registry.make_bzrdir("default-rich-root")
254
 
    except KeyError:
255
 
        return bzrdir.format_registry.make_bzrdir("1.9-rich-root")
256
 
 
 
28
    commands,
 
29
    config,
 
30
    deprecated_graph,
 
31
    iterablefile,
 
32
    osutils,
 
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')]
 
136
            else:
 
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
257
155
def test_suite():
258
156
    from bzrlib.plugins.git import tests
259
157
    return tests.test_suite()