← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
370
370
            pass
371
371
        next_transport = self.root_transport.clone('..')
372
372
        while True:
 
373
            # find the next containing bzrdir
373
374
            try:
374
375
                found_bzrdir = BzrDir.open_containing_from_transport(
375
376
                    next_transport)[0]
376
377
            except errors.NotBranchError:
 
378
                # none found
377
379
                raise errors.NoRepositoryPresent(self)
 
380
            # does it have a repository ?
378
381
            try:
379
382
                repository = found_bzrdir.open_repository()
380
383
            except errors.NoRepositoryPresent:
381
384
                next_transport = found_bzrdir.root_transport.clone('..')
382
 
                continue
 
385
                if (found_bzrdir.root_transport.base == next_transport.base):
 
386
                    # top of the file system
 
387
                    break
 
388
                else:
 
389
                    continue
383
390
            if ((found_bzrdir.root_transport.base == 
384
391
                 self.root_transport.base) or repository.is_shared()):
385
392
                return repository
392
399
 
393
400
        Note that bzr dirs that do not support format strings will raise
394
401
        IncompatibleFormat if the branch format they are given has
395
 
        a format string, and vice verca.
 
402
        a format string, and vice versa.
396
403
 
397
404
        If branch_format is None, the transport is returned with no 
398
405
        checking. if it is not None, then the returned transport is
405
412
 
406
413
        Note that bzr dirs that do not support format strings will raise
407
414
        IncompatibleFormat if the repository format they are given has
408
 
        a format string, and vice verca.
 
415
        a format string, and vice versa.
409
416
 
410
417
        If repository_format is None, the transport is returned with no 
411
418
        checking. if it is not None, then the returned transport is
418
425
 
419
426
        Note that bzr dirs that do not support format strings will raise
420
427
        IncompatibleFormat if the workingtree format they are given has
421
 
        a format string, and vice verca.
 
428
        a format string, and vice versa.
422
429
 
423
430
        If workingtree_format is None, the transport is returned with no 
424
431
        checking. if it is not None, then the returned transport is
453
460
        # this might be better on the BzrDirFormat class because it refers to 
454
461
        # all the possible bzrdir disk formats. 
455
462
        # This method is tested via the workingtree is_control_filename tests- 
456
 
        # it was extractd from WorkingTree.is_control_filename. If the methods
 
463
        # it was extracted from WorkingTree.is_control_filename. If the methods
457
464
        # contract is extended beyond the current trivial  implementation please
458
465
        # add new tests for it to the appropriate place.
459
466
        return filename == '.bzr' or filename.startswith('.bzr/')
626
633
            result.create_repository()
627
634
        elif source_repository is not None and result_repo is None:
628
635
            # have source, and want to make a new target repo
629
 
            # we dont clone the repo because that preserves attributes
 
636
            # we don't clone the repo because that preserves attributes
630
637
            # like is_shared(), and we have not yet implemented a 
631
638
            # repository sprout().
632
639
            result_repo = result.create_repository()
969
976
    _formats = {}
970
977
    """The known formats."""
971
978
 
 
979
    _control_formats = []
 
980
    """The registered control formats - .bzr, ....
 
981
    
 
982
    This is a list of BzrDirFormat objects.
 
983
    """
 
984
 
972
985
    _lock_file_name = 'branch-lock'
973
986
 
974
987
    # _lock_class must be set in subclasses to the lock type, typ.
976
989
 
977
990
    @classmethod
978
991
    def find_format(klass, transport):
979
 
        """Return the format registered for URL."""
 
992
        """Return the format present at transport."""
 
993
        for format in klass._control_formats:
 
994
            try:
 
995
                return format.probe_transport(transport)
 
996
            except errors.NotBranchError:
 
997
                # this format does not find a control dir here.
 
998
                pass
 
999
        raise errors.NotBranchError(path=transport.base)
 
1000
 
 
1001
    @classmethod
 
1002
    def probe_transport(klass, transport):
 
1003
        """Return the .bzrdir style transport present at URL."""
980
1004
        try:
981
1005
            format_string = transport.get(".bzr/branch-format").read()
982
1006
            return klass._formats[format_string]
1004
1028
        This returns a bzrlib.bzrdir.Converter object.
1005
1029
 
1006
1030
        This should return the best upgrader to step this format towards the
1007
 
        current default format. In the case of plugins we can/shouold provide
 
1031
        current default format. In the case of plugins we can/should provide
1008
1032
        some means for them to extend the range of returnable converters.
1009
1033
 
1010
 
        :param format: Optional format to override the default foramt of the 
 
1034
        :param format: Optional format to override the default format of the 
1011
1035
                       library.
1012
1036
        """
1013
1037
        raise NotImplementedError(self.get_converter)
1022
1046
 
1023
1047
    def initialize_on_transport(self, transport):
1024
1048
        """Initialize a new bzrdir in the base directory of a Transport."""
1025
 
        # Since we don'transport have a .bzr directory, inherit the
 
1049
        # Since we don't have a .bzr directory, inherit the
1026
1050
        # mode from the root directory
1027
1051
        temp_control = LockableFiles(transport, '', TransportLock)
1028
1052
        temp_control._transport.mkdir('.bzr',
1029
 
                                      # FIXME: RBC 20060121 dont peek under
 
1053
                                      # FIXME: RBC 20060121 don't peek under
1030
1054
                                      # the covers
1031
1055
                                      mode=temp_control._dir_mode)
1032
1056
        file_mode = temp_control._file_mode
1059
1083
        """
1060
1084
        return True
1061
1085
 
 
1086
    @classmethod
 
1087
    def known_formats(klass):
 
1088
        """Return all the known formats.
 
1089
        
 
1090
        Concrete formats should override _known_formats.
 
1091
        """
 
1092
        # There is double indirection here to make sure that control 
 
1093
        # formats used by more than one dir format will only be probed 
 
1094
        # once. This can otherwise be quite expensive for remote connections.
 
1095
        result = set()
 
1096
        for format in klass._control_formats:
 
1097
            result.update(format._known_formats())
 
1098
        return result
 
1099
    
 
1100
    @classmethod
 
1101
    def _known_formats(klass):
 
1102
        """Return the known format instances for this control format."""
 
1103
        return set(klass._formats.values())
 
1104
 
1062
1105
    def open(self, transport, _found=False):
1063
1106
        """Return an instance of this format for the dir transport points at.
1064
1107
        
1082
1125
        klass._formats[format.get_format_string()] = format
1083
1126
 
1084
1127
    @classmethod
 
1128
    def register_control_format(klass, format):
 
1129
        """Register a format that does not use '.bzrdir' for its control dir.
 
1130
 
 
1131
        TODO: This should be pulled up into a 'ControlDirFormat' base class
 
1132
        which BzrDirFormat can inherit from, and renamed to register_format 
 
1133
        there. It has been done without that for now for simplicity of
 
1134
        implementation.
 
1135
        """
 
1136
        klass._control_formats.append(format)
 
1137
 
 
1138
    @classmethod
1085
1139
    def set_default_format(klass, format):
1086
1140
        klass._default_format = format
1087
1141
 
1093
1147
        assert klass._formats[format.get_format_string()] is format
1094
1148
        del klass._formats[format.get_format_string()]
1095
1149
 
 
1150
    @classmethod
 
1151
    def unregister_control_format(klass, format):
 
1152
        klass._control_formats.remove(format)
 
1153
 
 
1154
 
 
1155
# register BzrDirFormat as a control format
 
1156
BzrDirFormat.register_control_format(BzrDirFormat)
 
1157
 
1096
1158
 
1097
1159
class BzrDirFormat4(BzrDirFormat):
1098
1160
    """Bzr dir format 4.