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