/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 dir.py

  • Committer: Eric Anderson
  • Date: 2008-11-25 01:45:22 UTC
  • mto: (0.200.116 trunk)
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: eric@pixelwareinc.com-20081125014522-leeq8vts9nv3awjm
When reading branch use active branch instead of first branch.

This allows us to interact with whatever is set as the current active 
branch instead of being limited to only the first branch (master). 
Useful for creating a branch from somewhere other than master.

Limited in its usefulness as I believe git only allows switching 
branches in a non-bare repositories and most trees being branched from 
are bare repositories. Also requiring the source repository to switch
its active branch is pretty intrusive. But something is better than
nothing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
dir.py
16
16
 
17
17
"""An adapter between a Git control dir and a Bazaar BzrDir"""
18
18
 
19
 
import os
 
19
import git, os
20
20
 
21
21
import bzrlib
22
22
from bzrlib.lazy_import import lazy_import
36
36
    )
37
37
""")
38
38
 
39
 
from bzrlib.plugins.git import LocalGitBzrDirFormat
40
 
 
41
 
 
42
39
 
43
40
class GitLock(object):
44
41
    """A lock that thunks through to Git."""
55
52
    def peek(self):
56
53
        pass
57
54
 
58
 
    def validate_token(self, token):
59
 
        pass
60
 
 
61
55
 
62
56
class GitLockableFiles(lockable_files.LockableFiles):
63
57
    """Git specific lockable files abstraction."""
64
58
 
65
 
    def __init__(self, transport, lock):
 
59
    def __init__(self, lock):
66
60
        self._lock = lock
67
61
        self._transaction = None
68
62
        self._lock_mode = None
69
63
        self._lock_count = 0
70
 
        self._transport = transport
71
64
 
72
65
 
73
66
class GitDir(bzrdir.BzrDir):
74
67
    """An adapter to the '.git' dir used by git."""
75
68
 
76
 
    def is_supported(self):
77
 
        return True
78
 
 
79
 
    def cloning_metadir(self, stacked=False):
80
 
        return bzrlib.bzrdir.format_registry.make_bzrdir("1.9-rich-root")
81
 
 
82
 
 
83
 
class LocalGitDir(GitDir):
84
 
    """An adapter to the '.git' dir used by git."""
85
 
 
86
 
    _gitrepository_class = repository.LocalGitRepository
 
69
    _gitrepository_class = repository.GitRepository
87
70
 
88
71
    def __init__(self, transport, lockfiles, gitrepo, format):
89
72
        self._format = format
98
81
    def get_branch_transport(self, branch_format):
99
82
        if branch_format is None:
100
83
            return self.transport
101
 
        if isinstance(branch_format, LocalGitBzrDirFormat):
 
84
        if isinstance(branch_format, GitBzrDirFormat):
102
85
            return self.transport
103
86
        raise errors.bzr_errors.IncompatibleFormat(branch_format, self._format)
104
87
 
105
88
    get_repository_transport = get_branch_transport
106
89
    get_workingtree_transport = get_branch_transport
107
90
 
 
91
    def is_supported(self):
 
92
        return True
 
93
 
108
94
    def open_branch(self, ignored=None):
109
95
        """'create' a branch for this dir."""
110
96
        repo = self.open_repository()
111
 
        return branch.LocalGitBranch(self, repo, "HEAD", repo._git.head(), self._lockfiles)
 
97
        if repo._git.heads == []:
 
98
            head = None
 
99
        else:
 
100
            head = filter(lambda h: h.name == repo._git.active_branch, repo._git.heads)[0].commit.id
 
101
        return branch.GitBranch(self, repo, head, 
 
102
                                    self.root_transport.base, self._lockfiles)
112
103
 
113
104
    def open_repository(self, shared=False):
114
105
        """'open' a repository for this dir."""
115
106
        return self._gitrepository_class(self, self._lockfiles)
116
107
 
117
108
    def open_workingtree(self, recommend_upgrade=True):
118
 
        if (not self._git.bare and 
119
 
            os.path.exists(os.path.join(self._git.controldir(), "index"))):
 
109
        if self._git.bare:
 
110
            loc = urlutils.unescape_for_display(self.root_transport.base, 'ascii')
 
111
            raise errors.bzr_errors.NoWorkingTree(loc)
 
112
        else:
120
113
            return workingtree.GitWorkingTree(self, self.open_repository(), 
121
114
                                                  self.open_branch())
122
 
        loc = urlutils.unescape_for_display(self.root_transport.base, 'ascii')
123
 
        raise errors.bzr_errors.NoWorkingTree(loc)
 
115
 
 
116
    def cloning_metadir(self, stacked=False):
 
117
        if stacked:
 
118
            return bzrlib.bzrdir.format_registry.make_bzrdir("pack-0.92")
 
119
        else:
 
120
            return bzrlib.bzrdir.format_registry.make_bzrdir("1.6")
124
121
 
125
122
    def create_repository(self, shared=False):
126
123
        return self.open_repository()
 
124
 
 
125
 
 
126
class GitBzrDirFormat(bzrdir.BzrDirFormat):
 
127
    """The .git directory control format."""
 
128
 
 
129
    _gitdir_class = GitDir
 
130
    _lock_class = TransportLock
 
131
 
 
132
    @classmethod
 
133
    def _known_formats(self):
 
134
        return set([GitBzrDirFormat()])
 
135
 
 
136
    def open(self, transport, _found=None):
 
137
        """Open this directory.
 
138
 
 
139
        """
 
140
        # we dont grok readonly - git isn't integrated with transport.
 
141
        url = transport.base
 
142
        if url.startswith('readonly+'):
 
143
            url = url[len('readonly+'):]
 
144
 
 
145
        try:
 
146
            gitrepo = git.repo.Repo(transport.local_abspath("."))
 
147
        except errors.bzr_errors.NotLocalUrl:
 
148
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
149
        lockfiles = GitLockableFiles(GitLock())
 
150
        return self._gitdir_class(transport, lockfiles, gitrepo, self)
 
151
 
 
152
    @classmethod
 
153
    def probe_transport(klass, transport):
 
154
        """Our format is present if the transport ends in '.not/'."""
 
155
        # little ugly, but works
 
156
        format = klass()
 
157
        # delegate to the main opening code. This pays a double rtt cost at the
 
158
        # moment, so perhaps we want probe_transport to return the opened thing
 
159
        # rather than an openener ? or we could return a curried thing with the
 
160
        # dir to open already instantiated ? Needs more thought.
 
161
        try:
 
162
            format.open(transport)
 
163
            return format
 
164
        except Exception, e:
 
165
            raise errors.bzr_errors.NotBranchError(path=transport.base)
 
166
        raise errors.bzr_errors.NotBranchError(path=transport.base)
 
167
 
 
168
    def get_format_description(self):
 
169
        return "Local Git Repository"
 
170
 
 
171
    def get_format_string(self):
 
172
        return "Local Git Repository"
 
173
 
 
174
    def initialize_on_transport(self, transport):
 
175
        from bzrlib.transport.local import LocalTransport
 
176
 
 
177
        if not isinstance(transport, LocalTransport):
 
178
            raise NotImplementedError(self.initialize, 
 
179
                "Can't create Git Repositories/branches on "
 
180
                "non-local transports")
 
181
 
 
182
        git.repo.Repo.create(transport.local_abspath(".")) 
 
183
        return self.open(transport)
 
184
 
 
185
 
 
186
bzrdir.BzrDirFormat.register_control_format(GitBzrDirFormat)