← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/controldir.py

(jelmer) Use the absolute_import feature everywhere in bzrlib,
 and add a source test to make sure it's used everywhere. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/controldir.py
1
 
# Copyright (C) 2010, 2011, 2012 Canonical Ltd
 
1
# Copyright (C) 2010, 2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
116
116
        :return: Dictionary mapping branch names to instances.
117
117
        """
118
118
        try:
119
 
           return { "": self.open_branch() }
 
119
           return { None: self.open_branch() }
120
120
        except (errors.NotBranchError, errors.NoRepositoryPresent):
121
121
           return {}
122
122
 
163
163
        """Create a branch in this ControlDir.
164
164
 
165
165
        :param name: Name of the colocated branch to create, None for
166
 
            the user selected branch or "" for the active branch.
 
166
            the default branch.
167
167
        :param append_revisions_only: Whether this branch should only allow
168
168
            appending new revisions to its history.
169
169
 
175
175
    def destroy_branch(self, name=None):
176
176
        """Destroy a branch in this ControlDir.
177
177
 
178
 
        :param name: Name of the branch to destroy, None for the 
179
 
            user selected branch or "" for the active branch.
180
 
        :raise NotBranchError: When the branch does not exist
 
178
        :param name: Name of the branch to destroy, None for the default 
 
179
            branch.
181
180
        """
182
181
        raise NotImplementedError(self.destroy_branch)
183
182
 
231
230
            raise errors.NoColocatedBranchSupport(self)
232
231
        return None
233
232
 
234
 
    def set_branch_reference(self, target_branch, name=None):
235
 
        """Set the referenced URL for the branch in this controldir.
236
 
 
237
 
        :param name: Optional colocated branch name
238
 
        :param target_branch: Branch to reference
239
 
        :raises NoColocatedBranchSupport: If a branch name was specified
240
 
            but colocated branches are not supported.
241
 
        :return: The referencing branch
242
 
        """
243
 
        raise NotImplementedError(self.set_branch_reference)
244
 
 
245
233
    def open_branch(self, name=None, unsupported=False,
246
234
                    ignore_fallbacks=False, possible_transports=None):
247
235
        """Open the branch object at this ControlDir if one is present.
274
262
        """
275
263
        raise NotImplementedError(self.find_repository)
276
264
 
277
 
    def open_workingtree(self, unsupported=False,
 
265
    def open_workingtree(self, _unsupported=False,
278
266
                         recommend_upgrade=True, from_branch=None):
279
267
        """Open the workingtree object at this ControlDir if one is present.
280
268
 
303
291
    def _get_selected_branch(self):
304
292
        """Return the name of the branch selected by the user.
305
293
 
306
 
        :return: Name of the branch selected by the user, or "".
 
294
        :return: Name of the branch selected by the user, or None.
307
295
        """
308
296
        branch = self.root_transport.get_segment_parameters().get("branch")
309
 
        if branch is None:
310
 
            branch = ""
311
 
        return urlutils.unescape(branch)
 
297
        if branch is not None:
 
298
            branch = urlutils.unescape(branch)
 
299
        return branch
312
300
 
313
301
    def has_workingtree(self):
314
302
        """Tell if this controldir contains a working tree.
406
394
            repository_to.fetch(source.repository, revision_id=revision_id)
407
395
            br_to = source.clone(self, revision_id=revision_id)
408
396
            if source.get_push_location() is None or remember:
409
 
                # FIXME: Should be done only if we succeed ? -- vila 2012-01-18
410
397
                source.set_push_location(br_to.base)
411
398
            push_result.stacked_on = None
412
399
            push_result.branch_push_result = None
418
405
        else:
419
406
            # We have successfully opened the branch, remember if necessary:
420
407
            if source.get_push_location() is None or remember:
421
 
                # FIXME: Should be done only if we succeed ? -- vila 2012-01-18
422
408
                source.set_push_location(br_to.base)
423
409
            try:
424
410
                tree_to = self.open_workingtree()
678
664
        return klass.open(base, _unsupported=True)
679
665
 
680
666
    @classmethod
681
 
    def open(klass, base, possible_transports=None, probers=None,
682
 
             _unsupported=False):
 
667
    def open(klass, base, _unsupported=False, possible_transports=None):
683
668
        """Open an existing controldir, rooted at 'base' (url).
684
669
 
685
670
        :param _unsupported: a private parameter to the ControlDir class.
686
671
        """
687
672
        t = _mod_transport.get_transport(base, possible_transports)
688
 
        return klass.open_from_transport(t, probers=probers,
689
 
                _unsupported=_unsupported)
 
673
        return klass.open_from_transport(t, _unsupported=_unsupported)
690
674
 
691
675
    @classmethod
692
676
    def open_from_transport(klass, transport, _unsupported=False,
693
 
                            probers=None):
 
677
                            _server_formats=True):
694
678
        """Open a controldir within a particular directory.
695
679
 
696
680
        :param transport: Transport containing the controldir.
702
686
        # the redirections.
703
687
        base = transport.base
704
688
        def find_format(transport):
705
 
            return transport, ControlDirFormat.find_format(transport,
706
 
                probers=probers)
 
689
            return transport, ControlDirFormat.find_format(
 
690
                transport, _server_formats=_server_formats)
707
691
 
708
692
        def redirected(transport, e, redirection_notice):
709
693
            redirected_transport = transport._redirected_to(e.source, e.target)
781
765
        return controldir._get_tree_branch()
782
766
 
783
767
    @classmethod
784
 
    def open_containing_tree_or_branch(klass, location,
785
 
            possible_transports=None):
 
768
    def open_containing_tree_or_branch(klass, location):
786
769
        """Return the branch and working tree contained by a location.
787
770
 
788
771
        Returns (tree, branch, relpath).
791
774
        raised
792
775
        relpath is the portion of the path that is contained by the branch.
793
776
        """
794
 
        controldir, relpath = klass.open_containing(location,
795
 
            possible_transports=possible_transports)
 
777
        controldir, relpath = klass.open_containing(location)
796
778
        tree, branch = controldir._get_tree_branch()
797
779
        return tree, branch, relpath
798
780
 
860
842
 
861
843
 
862
844
class ControlComponentFormat(object):
863
 
    """A component that can live inside of a control directory."""
 
845
    """A component that can live inside of a .bzr meta directory."""
864
846
 
865
847
    upgrade_recommended = False
866
848
 
1128
1110
        return self.get_format_description().rstrip()
1129
1111
 
1130
1112
    @classmethod
1131
 
    def all_probers(klass):
1132
 
        return klass._server_probers + klass._probers
1133
 
 
1134
 
    @classmethod
1135
1113
    def known_formats(klass):
1136
1114
        """Return all the known formats.
1137
1115
        """
1138
1116
        result = set()
1139
 
        for prober_kls in klass.all_probers():
 
1117
        for prober_kls in klass._probers + klass._server_probers:
1140
1118
            result.update(prober_kls.known_formats())
1141
1119
        return result
1142
1120
 
1143
1121
    @classmethod
1144
 
    def find_format(klass, transport, probers=None):
 
1122
    def find_format(klass, transport, _server_formats=True):
1145
1123
        """Return the format present at transport."""
1146
 
        if probers is None:
1147
 
            probers = klass.all_probers()
1148
 
        for prober_kls in probers:
 
1124
        if _server_formats:
 
1125
            _probers = klass._server_probers + klass._probers
 
1126
        else:
 
1127
            _probers = klass._probers
 
1128
        for prober_kls in _probers:
1149
1129
            prober = prober_kls()
1150
1130
            try:
1151
1131
                return prober.probe_transport(transport)