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

  • Committer: Jelmer Vernooij
  • Date: 2019-05-20 03:57:29 UTC
  • mto: This revision was merged to the branch mainline in revision 7328.
  • Revision ID: jelmer@jelmer.uk-20190520035729-9rxvefxkvbbivygy
use default_user_agent function.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/dir.py
21
21
 
22
22
from .. import (
23
23
    branch as _mod_branch,
24
 
    cleanup,
25
24
    errors as brz_errors,
26
25
    trace,
27
26
    osutils,
183
182
        result_branch = source_branch.sprout(
184
183
            result, revision_id=revision_id, repository=result_repo)
185
184
        if (create_tree_if_local and
186
 
            result.open_branch(name="").name == result_branch.name and
187
185
            isinstance(target_transport, LocalTransport) and
188
186
                (result_repo is None or result_repo.make_working_trees())):
189
 
            wt = result.create_workingtree(
 
187
            result.create_workingtree(
190
188
                accelerator_tree=accelerator_tree,
191
189
                hardlink=hardlink, from_branch=result_branch)
192
 
        else:
193
 
            wt = None
194
 
        if recurse == 'down':
195
 
            with cleanup.ExitStack() as stack:
196
 
                basis = None
197
 
                if wt is not None:
198
 
                    basis = wt.basis_tree()
199
 
                elif result_branch is not None:
200
 
                    basis = result_branch.basis_tree()
201
 
                elif source_branch is not None:
202
 
                    basis = source_branch.basis_tree()
203
 
                if basis is not None:
204
 
                    stack.enter_context(basis.lock_read())
205
 
                    subtrees = basis.iter_references()
206
 
                else:
207
 
                    subtrees = []
208
 
                for path in subtrees:
209
 
                    target = urlutils.join(url, urlutils.escape(path))
210
 
                    sublocation = wt.reference_parent(
211
 
                        path, possible_transports=possible_transports)
212
 
                    if sublocation is None:
213
 
                        trace.warning(
214
 
                            'Ignoring nested tree %s, parent location unknown.',
215
 
                            path)
216
 
                        continue
217
 
                    sublocation.controldir.sprout(
218
 
                        target, basis.get_reference_revision(path),
219
 
                        force_new_repo=force_new_repo, recurse=recurse,
220
 
                        stacked=stacked)
221
190
        return result
222
191
 
223
192
    def clone_on_transport(self, transport, revision_id=None,
224
193
                           force_new_repo=False, preserve_stacking=False,
225
194
                           stacked_on=None, create_prefix=False,
226
 
                           use_existing_dir=True, no_tree=False,
227
 
                           tag_selector=None):
 
195
                           use_existing_dir=True, no_tree=False):
228
196
        """See ControlDir.clone_on_transport."""
229
197
        from ..repository import InterRepository
230
198
        from .mapping import default_mapping
231
 
        from ..transport.local import LocalTransport
232
199
        if stacked_on is not None:
233
200
            raise _mod_branch.UnstackableBranchFormat(
234
201
                self._format, self.user_url)
247
214
        interrepo = InterRepository.get(source_repo, target_repo)
248
215
        if revision_id is not None:
249
216
            determine_wants = interrepo.get_determine_wants_revids(
250
 
                [revision_id], include_tags=True, tag_selector=tag_selector)
 
217
                [revision_id], include_tags=True)
251
218
        else:
252
219
            determine_wants = interrepo.determine_wants_all
253
220
        (pack_hint, _, refs) = interrepo.fetch_objects(determine_wants,
254
221
                                                       mapping=default_mapping)
255
222
        for name, val in viewitems(refs):
256
223
            target_git_repo.refs[name] = val
257
 
        result_dir = LocalGitDir(transport, target_git_repo, format)
 
224
        result_dir = self.__class__(transport, target_git_repo, format)
258
225
        if revision_id is not None:
259
226
            result_dir.open_branch().set_last_revision(revision_id)
260
 
        if not no_tree and isinstance(result_dir.root_transport, LocalTransport):
 
227
        try:
 
228
            # Cheaper to check if the target is not local, than to try making
 
229
            # the tree and fail.
 
230
            result_dir.root_transport.local_abspath('.')
261
231
            if result_dir.open_repository().make_working_trees():
262
 
                try:
263
 
                    local_wt = self.open_workingtree()
264
 
                except brz_errors.NoWorkingTree:
265
 
                    pass
266
 
                except brz_errors.NotLocalUrl:
267
 
                    result_dir.create_workingtree(revision_id=revision_id)
268
 
                else:
269
 
                    local_wt.clone(result_dir, revision_id=revision_id)
 
232
                self.open_workingtree().clone(
 
233
                    result_dir, revision_id=revision_id)
 
234
        except (brz_errors.NoWorkingTree, brz_errors.NotLocalUrl):
 
235
            pass
270
236
 
271
237
        return result_dir
272
238
 
301
267
        """
302
268
        return UseExistingRepository(self.find_repository())
303
269
 
304
 
    def branch_names(self):
305
 
        from .refs import ref_to_branch_name
306
 
        ret = []
307
 
        for ref in self.get_refs_container().keys():
308
 
            try:
309
 
                branch_name = ref_to_branch_name(ref)
310
 
            except UnicodeDecodeError:
311
 
                trace.warning("Ignoring branch %r with unicode error ref", ref)
312
 
                continue
313
 
            except ValueError:
314
 
                continue
315
 
            ret.append(branch_name)
316
 
        return ret
317
 
 
318
270
    def get_branches(self):
319
271
        from .refs import ref_to_branch_name
320
272
        ret = {}
321
273
        for ref in self.get_refs_container().keys():
322
274
            try:
323
275
                branch_name = ref_to_branch_name(ref)
 
276
            except ValueError:
 
277
                continue
324
278
            except UnicodeDecodeError:
325
279
                trace.warning("Ignoring branch %r with unicode error ref", ref)
326
280
                continue
327
 
            except ValueError:
328
 
                continue
329
281
            ret[branch_name] = self.open_branch(ref=ref)
330
282
        return ret
331
283
 
334
286
 
335
287
    def push_branch(self, source, revision_id=None, overwrite=False,
336
288
                    remember=False, create_prefix=False, lossy=False,
337
 
                    name=None, tag_selector=None):
 
289
                    name=None):
338
290
        """Push the source branch into this ControlDir."""
339
291
        push_result = GitPushResult()
340
292
        push_result.workingtree_updated = None
347
299
        target = self.open_branch(name, nascent_ok=True)
348
300
        push_result.branch_push_result = source.push(
349
301
            target, overwrite=overwrite, stop_revision=revision_id,
350
 
            lossy=lossy, tag_selector=tag_selector)
 
302
            lossy=lossy)
351
303
        push_result.new_revid = push_result.branch_push_result.new_revid
352
304
        push_result.old_revid = push_result.branch_push_result.old_revid
353
 
        try:
354
 
            wt = self.open_workingtree()
355
 
        except brz_errors.NoWorkingTree:
356
 
            push_result.workingtree_updated = None
357
 
        else:
358
 
            if self.open_branch(name="").name == target.name:
359
 
                wt._update_git_tree(
360
 
                    old_revision=push_result.old_revid,
361
 
                    new_revision=push_result.new_revid)
362
 
                push_result.workingtree_updated = True
363
 
            else:
364
 
                push_result.workingtree_updated = False
365
305
        push_result.target_branch = target
366
306
        if source.get_push_location() is None or remember:
367
307
            source.set_push_location(push_result.target_branch.base)
398
338
        from .transportgit import TransportRepo
399
339
 
400
340
        def _open(transport):
401
 
            try:
402
 
                return TransportRepo(transport, self.bare,
403
 
                                     refs_text=getattr(self, "_refs_text", None))
404
 
            except ValueError as e:
405
 
                if e.args == ('Expected file to start with \'gitdir: \'', ):
406
 
                    raise brz_errors.NotBranchError(path=transport.base)
407
 
                raise
 
341
            return TransportRepo(transport, self.bare,
 
342
                                 refs_text=getattr(self, "_refs_text", None))
408
343
 
409
344
        def redirected(transport, e, redirection_notice):
410
345
            trace.note(redirection_notice)
411
346
            return transport._redirected_to(e.source, e.target)
412
347
        gitrepo = do_catching_redirections(_open, transport, redirected)
413
 
        if not _found and not gitrepo._controltransport.has('objects'):
 
348
        if not gitrepo._controltransport.has('HEAD'):
414
349
            raise brz_errors.NotBranchError(path=transport.base)
415
350
        return LocalGitDir(transport, gitrepo, self)
416
351
 
428
363
                                   stack_on_pwd=None, repo_format_name=None,
429
364
                                   make_working_trees=None,
430
365
                                   shared_repo=False, vfs_only=False):
431
 
        if shared_repo:
432
 
            raise brz_errors.SharedRepositoriesUnsupported(self)
433
 
 
434
366
        def make_directory(transport):
435
367
            transport.mkdir('.')
436
368
            return transport
469
401
            raise brz_errors.NotBranchError(path=transport.base)
470
402
        return external_url.startswith("file:")
471
403
 
472
 
    def is_control_filename(self, filename):
473
 
        return (filename == '.git'
474
 
                or filename.startswith('.git/')
475
 
                or filename.startswith('.git\\'))
476
 
 
477
404
 
478
405
class BareLocalGitControlDirFormat(LocalGitControlDirFormat):
479
406
 
483
410
    def get_format_description(self):
484
411
        return "Local Git Repository (bare)"
485
412
 
486
 
    def is_control_filename(self, filename):
487
 
        return False
488
 
 
489
413
 
490
414
class LocalGitDir(GitDir):
491
415
    """An adapter to the '.git' dir used by git."""
519
443
            self.transport = transport.clone('.git')
520
444
        self._mode_check_done = None
521
445
 
 
446
    def is_control_filename(self, filename):
 
447
        return (filename == '.git'
 
448
                or filename.startswith('.git/')
 
449
                or filename.startswith('.git\\'))
 
450
 
522
451
    def _get_symref(self, ref):
523
452
        ref_chain, unused_sha = self._git.refs.follow(ref)
524
453
        if len(ref_chain) == 1: