/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

Use dictionary with verifiers rather than requiring testament3-sha1 everywhere.

Show diffs side-by-side

added added

removed removed

Lines of Context:
dir.py
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
 
"""An adapter between a Git control dir and a Bazaar BzrDir."""
 
18
"""An adapter between a Git control dir and a Bazaar ControlDir."""
19
19
 
20
20
from bzrlib import (
21
 
    bzrdir,
22
21
    errors as bzr_errors,
23
22
    lockable_files,
24
23
    urlutils,
28
27
LockWarner = getattr(lockable_files, "_LockWarner", None)
29
28
 
30
29
from bzrlib.plugins.git import (
31
 
    LocalGitBzrDirFormat,
 
30
    LocalGitControlDirFormat,
32
31
    )
 
32
try:
 
33
    from bzrlib.controldir import (
 
34
        ControlDir,
 
35
        format_registry,
 
36
        )
 
37
except ImportError:
 
38
    # bzr < 2.3
 
39
    from bzrlib.bzrdir import (
 
40
        BzrDir,
 
41
        format_registry,
 
42
        )
 
43
    ControlDir = BzrDir
33
44
 
34
45
 
35
46
class GitLock(object):
69
80
            self._lock_warner = LockWarner(repr(self))
70
81
 
71
82
 
72
 
class GitDir(bzrdir.BzrDir):
 
83
class GitDirConfig(object):
 
84
 
 
85
    def get_default_stack_on(self):
 
86
        return None
 
87
 
 
88
    def set_default_stack_on(self, value):
 
89
        raise bzr_errors.BzrError("Cannot set configuration")
 
90
 
 
91
 
 
92
class GitDir(ControlDir):
73
93
    """An adapter to the '.git' dir used by git."""
74
94
 
75
95
    def is_supported(self):
76
96
        return True
77
97
 
 
98
    def can_convert_format(self):
 
99
        return False
 
100
 
 
101
    def break_lock(self):
 
102
        pass
 
103
 
78
104
    def cloning_metadir(self, stacked=False):
79
 
        return bzrdir.format_registry.make_bzrdir("default")
 
105
        return format_registry.make_bzrdir("default")
80
106
 
81
107
    def _branch_name_to_ref(self, name):
82
108
        raise NotImplementedError(self._branch_name_to_ref)
83
109
 
84
110
    if bzrlib_version >= (2, 2):
85
 
        def open_branch(self, name=None, ignore_fallbacks=None,
86
 
            unsupported=False):
 
111
        def open_branch(self, name=None, unsupported=False, 
 
112
            ignore_fallbacks=None):
87
113
            return self._open_branch(name=name,
88
114
                ignore_fallbacks=ignore_fallbacks, unsupported=unsupported)
89
115
    else:
91
117
            return self._open_branch(name=None,
92
118
                ignore_fallbacks=ignore_fallbacks, unsupported=unsupported)
93
119
 
 
120
    def get_config(self):
 
121
        return GitDirConfig()
 
122
 
94
123
 
95
124
class LocalGitDir(GitDir):
96
125
    """An adapter to the '.git' dir used by git."""
101
130
 
102
131
    _gitrepository_class = property(_get_gitrepository_class)
103
132
 
 
133
    @property
 
134
    def user_transport(self):
 
135
        return self.root_transport
 
136
 
 
137
    @property
 
138
    def control_transport(self):
 
139
        return self.transport
 
140
 
104
141
    def __init__(self, transport, lockfiles, gitrepo, format):
105
142
        self._format = format
106
143
        self.root_transport = transport
 
144
        self._mode_check_done = False
107
145
        self._git = gitrepo
108
146
        if gitrepo.bare:
109
147
            self.transport = transport
125
163
    def is_control_filename(self, filename):
126
164
        return filename == '.git' or filename.startswith('.git/')
127
165
 
128
 
    def get_branch_transport(self, branch_format, name):
 
166
    def get_branch_transport(self, branch_format, name=None):
129
167
        if branch_format is None:
130
168
            return self.transport
131
 
        if isinstance(branch_format, LocalGitBzrDirFormat):
 
169
        if isinstance(branch_format, LocalGitControlDirFormat):
132
170
            return self.transport
133
171
        raise bzr_errors.IncompatibleFormat(branch_format, self._format)
134
172
 
135
173
    def get_repository_transport(self, format):
136
174
        if format is None:
137
175
            return self.transport
138
 
        if isinstance(format, LocalGitBzrDirFormat):
 
176
        if isinstance(format, LocalGitControlDirFormat):
139
177
            return self.transport
140
178
        raise bzr_errors.IncompatibleFormat(format, self._format)
141
179
 
142
180
    def get_workingtree_transport(self, format):
143
181
        if format is None:
144
182
            return self.transport
145
 
        if isinstance(format, LocalGitBzrDirFormat):
 
183
        if isinstance(format, LocalGitControlDirFormat):
146
184
            return self.transport
147
185
        raise bzr_errors.IncompatibleFormat(format, self._format)
148
186
 
154
192
            self._lockfiles)
155
193
 
156
194
    def destroy_branch(self, name=None):
157
 
        del self._git.refs[self._branch_name_to_ref(name)]
 
195
        refname = self._branch_name_to_ref(name)
 
196
        if not refname in self._git.refs:
 
197
            raise bzr_errors.NotBranchError(self.root_transport.base,
 
198
                    bzrdir=self)
 
199
        del self._git.refs[refname]
 
200
 
 
201
    def destroy_repository(self):
 
202
        raise bzr_errors.UnsupportedOperation(self.destroy_repository, self)
 
203
 
 
204
    def destroy_workingtree(self):
 
205
        raise bzr_errors.UnsupportedOperation(self.destroy_workingtree, self)
 
206
 
 
207
    def needs_format_conversion(self, format=None):
 
208
        return not isinstance(self._format, format.__class__)
158
209
 
159
210
    def list_branches(self):
160
211
        ret = []
216
267
        finally:
217
268
            f.close()
218
269
        return self.open_workingtree()
 
270
 
 
271
    def find_repository(self):
 
272
        """Find the repository that should be used.
 
273
 
 
274
        This does not require a branch as we use it to find the repo for
 
275
        new branches as well as to hook existing branches up to their
 
276
        repository.
 
277
        """
 
278
        return self.open_repository()
 
279
 
 
280
    def _find_creation_modes(self):
 
281
        """Determine the appropriate modes for files and directories.
 
282
 
 
283
        They're always set to be consistent with the base directory,
 
284
        assuming that this transport allows setting modes.
 
285
        """
 
286
        # TODO: Do we need or want an option (maybe a config setting) to turn
 
287
        # this off or override it for particular locations? -- mbp 20080512
 
288
        if self._mode_check_done:
 
289
            return
 
290
        self._mode_check_done = True
 
291
        try:
 
292
            st = self.transport.stat('.')
 
293
        except TransportNotPossible:
 
294
            self._dir_mode = None
 
295
            self._file_mode = None
 
296
        else:
 
297
            # Check the directory mode, but also make sure the created
 
298
            # directories and files are read-write for this user. This is
 
299
            # mostly a workaround for filesystems which lie about being able to
 
300
            # write to a directory (cygwin & win32)
 
301
            if (st.st_mode & 07777 == 00000):
 
302
                # FTP allows stat but does not return dir/file modes
 
303
                self._dir_mode = None
 
304
                self._file_mode = None
 
305
            else:
 
306
                self._dir_mode = (st.st_mode & 07777) | 00700
 
307
                # Remove the sticky and execute bits for files
 
308
                self._file_mode = self._dir_mode & ~07111
 
309
 
 
310
    def _get_file_mode(self):
 
311
        """Return Unix mode for newly created files, or None.
 
312
        """
 
313
        if not self._mode_check_done:
 
314
            self._find_creation_modes()
 
315
        return self._file_mode
 
316
 
 
317
    def _get_dir_mode(self):
 
318
        """Return Unix mode for newly created directories, or None.
 
319
        """
 
320
        if not self._mode_check_done:
 
321
            self._find_creation_modes()
 
322
        return self._dir_mode
 
323
 
 
324