← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/controldir.py

  • Committer: Jelmer Vernooij
  • Date: 2012-01-23 19:08:05 UTC
  • mfrom: (6437.3.20 2.5)
  • mto: This revision was merged to the branch mainline in revision 6450.
  • Revision ID: jelmer@samba.org-20120123190805-hlcuihkt2dep44cw
merge bzr 2.5.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/controldir.py
22
22
 
23
23
"""
24
24
 
 
25
from __future__ import absolute_import
 
26
 
25
27
from bzrlib.lazy_import import lazy_import
26
28
lazy_import(globals(), """
27
29
import textwrap
106
108
        """Return a sequence of all branches local to this control directory.
107
109
 
108
110
        """
 
111
        return self.get_branches().values()
 
112
 
 
113
    def get_branches(self):
 
114
        """Get all branches in this control directory, as a dictionary.
 
115
        
 
116
        :return: Dictionary mapping branch names to instances.
 
117
        """
109
118
        try:
110
 
            return [self.open_branch()]
 
119
           return { "": self.open_branch() }
111
120
        except (errors.NotBranchError, errors.NoRepositoryPresent):
112
 
            return []
 
121
           return {}
113
122
 
114
123
    def is_control_filename(self, filename):
115
124
        """True if filename is the name of a path which is reserved for
221
230
            raise errors.NoColocatedBranchSupport(self)
222
231
        return None
223
232
 
 
233
    def set_branch_reference(self, target_branch, name=None):
 
234
        """Set the referenced URL for the branch in this controldir.
 
235
 
 
236
        :param name: Optional colocated branch name
 
237
        :param target_branch: Branch to reference
 
238
        :raises NoColocatedBranchSupport: If a branch name was specified
 
239
            but colocated branches are not supported.
 
240
        :return: The referencing branch
 
241
        """
 
242
        raise NotImplementedError(self.set_branch_reference)
 
243
 
224
244
    def open_branch(self, name=None, unsupported=False,
225
245
                    ignore_fallbacks=False, possible_transports=None):
226
246
        """Open the branch object at this ControlDir if one is present.
253
273
        """
254
274
        raise NotImplementedError(self.find_repository)
255
275
 
256
 
    def open_workingtree(self, _unsupported=False,
 
276
    def open_workingtree(self, unsupported=False,
257
277
                         recommend_upgrade=True, from_branch=None):
258
278
        """Open the workingtree object at this ControlDir if one is present.
259
279
 
285
305
        :return: Name of the branch selected by the user, or None.
286
306
        """
287
307
        branch = self.root_transport.get_segment_parameters().get("branch")
288
 
        if branch is not None:
289
 
            branch = urlutils.unescape(branch)
290
 
        return branch
 
308
        if branch is None:
 
309
            branch = ""
 
310
        return urlutils.unescape(branch)
291
311
 
292
312
    def has_workingtree(self):
293
313
        """Tell if this controldir contains a working tree.
321
341
        raise NotImplementedError(self.cloning_metadir)
322
342
 
323
343
    def checkout_metadir(self):
324
 
        """Produce a metadir suitable for checkouts of this controldir."""
 
344
        """Produce a metadir suitable for checkouts of this controldir.
 
345
 
 
346
        :returns: A ControlDirFormat with all component formats
 
347
            either set appropriately or set to None if that component
 
348
            should not be created.
 
349
        """
325
350
        return self.cloning_metadir()
326
351
 
327
352
    def sprout(self, url, revision_id=None, force_new_repo=False,
650
675
        return klass.open(base, _unsupported=True)
651
676
 
652
677
    @classmethod
653
 
    def open(klass, base, _unsupported=False, possible_transports=None):
 
678
    def open(klass, base, possible_transports=None, probers=None,
 
679
             _unsupported=False):
654
680
        """Open an existing controldir, rooted at 'base' (url).
655
681
 
656
682
        :param _unsupported: a private parameter to the ControlDir class.
657
683
        """
658
684
        t = _mod_transport.get_transport(base, possible_transports)
659
 
        return klass.open_from_transport(t, _unsupported=_unsupported)
 
685
        return klass.open_from_transport(t, probers=probers,
 
686
                _unsupported=_unsupported)
660
687
 
661
688
    @classmethod
662
689
    def open_from_transport(klass, transport, _unsupported=False,
663
 
                            _server_formats=True):
 
690
                            probers=None):
664
691
        """Open a controldir within a particular directory.
665
692
 
666
693
        :param transport: Transport containing the controldir.
672
699
        # the redirections.
673
700
        base = transport.base
674
701
        def find_format(transport):
675
 
            return transport, ControlDirFormat.find_format(
676
 
                transport, _server_formats=_server_formats)
 
702
            return transport, ControlDirFormat.find_format(transport,
 
703
                probers=probers)
677
704
 
678
705
        def redirected(transport, e, redirection_notice):
679
706
            redirected_transport = transport._redirected_to(e.source, e.target)
726
753
                return result, urlutils.unescape(a_transport.relpath(url))
727
754
            except errors.NotBranchError, e:
728
755
                pass
 
756
            except errors.PermissionDenied:
 
757
                pass
729
758
            try:
730
759
                new_t = a_transport.clone('..')
731
760
            except errors.InvalidURLJoin:
826
855
 
827
856
 
828
857
class ControlComponentFormat(object):
829
 
    """A component that can live inside of a .bzr meta directory."""
 
858
    """A component that can live inside of a control directory."""
830
859
 
831
860
    upgrade_recommended = False
832
861
 
833
 
    def get_format_string(self):
834
 
        """Return the format of this format, if usable in meta directories."""
835
 
        raise NotImplementedError(self.get_format_string)
836
 
 
837
862
    def get_format_description(self):
838
863
        """Return the short description for this format."""
839
864
        raise NotImplementedError(self.get_format_description)
866
891
            ui.ui_factory.recommend_upgrade(
867
892
                self.get_format_description(), basedir)
868
893
 
 
894
    @classmethod
 
895
    def get_format_string(cls):
 
896
        raise NotImplementedError(cls.get_format_string)
 
897
 
869
898
 
870
899
class ControlComponentFormatRegistry(registry.FormatRegistry):
871
900
    """A registry for control components (branch, workingtree, repository)."""
1094
1123
        return self.get_format_description().rstrip()
1095
1124
 
1096
1125
    @classmethod
 
1126
    def all_probers(klass):
 
1127
        return klass._server_probers + klass._probers
 
1128
 
 
1129
    @classmethod
1097
1130
    def known_formats(klass):
1098
1131
        """Return all the known formats.
1099
1132
        """
1100
1133
        result = set()
1101
 
        for prober_kls in klass._probers + klass._server_probers:
 
1134
        for prober_kls in klass.all_probers():
1102
1135
            result.update(prober_kls.known_formats())
1103
1136
        return result
1104
1137
 
1105
1138
    @classmethod
1106
 
    def find_format(klass, transport, _server_formats=True):
 
1139
    def find_format(klass, transport, probers=None):
1107
1140
        """Return the format present at transport."""
1108
 
        if _server_formats:
1109
 
            _probers = klass._server_probers + klass._probers
1110
 
        else:
1111
 
            _probers = klass._probers
1112
 
        for prober_kls in _probers:
 
1141
        if probers is None:
 
1142
            probers = klass.all_probers()
 
1143
        for prober_kls in probers:
1113
1144
            prober = prober_kls()
1114
1145
            try:
1115
1146
                return prober.probe_transport(transport)