/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 bzrlib/bzrdir.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
29
29
 
30
30
import os
31
31
import sys
 
32
import warnings
32
33
 
33
34
from bzrlib.lazy_import import lazy_import
34
35
lazy_import(globals(), """
85
86
    registry,
86
87
    symbol_versioning,
87
88
    )
88
 
 
89
 
 
90
 
class BzrDir(object):
 
89
    
 
90
    
 
91
class ControlComponent(object):
 
92
    """Abstract base class for control directory components.
 
93
    
 
94
    This provides interfaces that are common across bzrdirs, 
 
95
    repositories, branches, and workingtree control directories.
 
96
    
 
97
    They all expose two urls and transports: the *user* URL is the 
 
98
    one that stops above the control directory (eg .bzr) and that 
 
99
    should normally be used in messages, and the *control* URL is
 
100
    under that in eg .bzr/checkout and is used to read the control
 
101
    files.
 
102
    
 
103
    This can be used as a mixin and is intended to fit with 
 
104
    foreign formats.
 
105
    """
 
106
    
 
107
    @property
 
108
    def control_transport(self):
 
109
        raise NotImplementedError
 
110
   
 
111
    @property
 
112
    def control_url(self):
 
113
        return self.control_transport.base
 
114
    
 
115
    @property
 
116
    def user_transport(self):
 
117
        raise NotImplementedError
 
118
        
 
119
    @property
 
120
    def user_url(self):
 
121
        return self.user_transport.base
 
122
    
 
123
 
 
124
class BzrDir(ControlComponent):
91
125
    """A .bzr control diretory.
92
126
 
93
127
    BzrDir instances let you create or open any of the things that can be
260
294
                # copied, and finally if we are copying up to a specific
261
295
                # revision_id then we can use the pending-ancestry-result which
262
296
                # does not require traversing all of history to describe it.
263
 
                if (result_repo.bzrdir.root_transport.base ==
264
 
                    result.root_transport.base and not require_stacking and
 
297
                if (result_repo.user_url == result.user_url
 
298
                    and not require_stacking and
265
299
                    revision_id is not None):
266
300
                    fetch_spec = graph.PendingAncestryResult(
267
301
                        [revision_id], local_repo)
354
388
                for subdir in sorted(subdirs, reverse=True):
355
389
                    pending.append(current_transport.clone(subdir))
356
390
 
 
391
    def list_branches(self):
 
392
        """Return a sequence of all branches local to this control directory.
 
393
 
 
394
        """
 
395
        try:
 
396
            return [self.open_branch()]
 
397
        except errors.NotBranchError:
 
398
            return []
 
399
 
357
400
    @staticmethod
358
401
    def find_branches(transport):
359
402
        """Find all branches under a transport.
371
414
            except errors.NoRepositoryPresent:
372
415
                pass
373
416
            else:
374
 
                return False, (None, repository)
375
 
            try:
376
 
                branch = bzrdir.open_branch()
377
 
            except errors.NotBranchError:
378
 
                return True, (None, None)
379
 
            else:
380
 
                return True, (branch, None)
381
 
        branches = []
382
 
        for branch, repo in BzrDir.find_bzrdirs(transport, evaluate=evaluate):
 
417
                return False, ([], repository)
 
418
            return True, (bzrdir.list_branches(), None)
 
419
        ret = []
 
420
        for branches, repo in BzrDir.find_bzrdirs(transport,
 
421
                                                  evaluate=evaluate):
383
422
            if repo is not None:
384
 
                branches.extend(repo.find_branches())
385
 
            if branch is not None:
386
 
                branches.append(branch)
387
 
        return branches
 
423
                ret.extend(repo.find_branches())
 
424
            if branches is not None:
 
425
                ret.extend(branches)
 
426
        return ret
388
427
 
389
428
    def destroy_repository(self):
390
429
        """Destroy the repository in this BzrDir"""
391
430
        raise NotImplementedError(self.destroy_repository)
392
431
 
393
 
    def create_branch(self):
 
432
    def create_branch(self, name=None):
394
433
        """Create a branch in this BzrDir.
395
434
 
 
435
        :param name: Name of the colocated branch to create, None for
 
436
            the default branch.
 
437
 
396
438
        The bzrdir's format will control what branch format is created.
397
439
        For more control see BranchFormatXX.create(a_bzrdir).
398
440
        """
399
441
        raise NotImplementedError(self.create_branch)
400
442
 
401
 
    def destroy_branch(self):
402
 
        """Destroy the branch in this BzrDir"""
 
443
    def destroy_branch(self, name=None):
 
444
        """Destroy a branch in this BzrDir.
 
445
        
 
446
        :param name: Name of the branch to destroy, None for the default 
 
447
            branch.
 
448
        """
403
449
        raise NotImplementedError(self.destroy_branch)
404
450
 
405
451
    @staticmethod
445
491
            stop = False
446
492
            stack_on = config.get_default_stack_on()
447
493
            if stack_on is not None:
448
 
                stack_on_pwd = found_bzrdir.root_transport.base
 
494
                stack_on_pwd = found_bzrdir.user_url
449
495
                stop = True
450
496
            # does it have a repository ?
451
497
            try:
453
499
            except errors.NoRepositoryPresent:
454
500
                repository = None
455
501
            else:
456
 
                if ((found_bzrdir.root_transport.base !=
457
 
                     self.root_transport.base) and not repository.is_shared()):
 
502
                if (found_bzrdir.user_url != self.user_url 
 
503
                    and not repository.is_shared()):
458
504
                    # Don't look higher, can't use a higher shared repo.
459
505
                    repository = None
460
506
                    stop = True
574
620
 
575
621
        :return: Tuple with old path name and new path name
576
622
        """
 
623
        def name_gen(base='backup.bzr'):
 
624
            counter = 1
 
625
            name = "%s.~%d~" % (base, counter)
 
626
            while self.root_transport.has(name):
 
627
                counter += 1
 
628
                name = "%s.~%d~" % (base, counter)
 
629
            return name
 
630
 
 
631
        backup_dir=name_gen()
577
632
        pb = ui.ui_factory.nested_progress_bar()
578
633
        try:
579
634
            # FIXME: bug 300001 -- the backup fails if the backup directory
580
635
            # already exists, but it should instead either remove it or make
581
636
            # a new backup directory.
582
637
            #
583
 
            # FIXME: bug 262450 -- the backup directory should have the same
584
 
            # permissions as the .bzr directory (probably a bug in copy_tree)
585
638
            old_path = self.root_transport.abspath('.bzr')
586
 
            new_path = self.root_transport.abspath('backup.bzr')
 
639
            new_path = self.root_transport.abspath(backup_dir)
587
640
            ui.ui_factory.note('making backup of %s\n  to %s' % (old_path, new_path,))
588
 
            self.root_transport.copy_tree('.bzr', 'backup.bzr')
 
641
            self.root_transport.copy_tree('.bzr', backup_dir)
589
642
            return (old_path, new_path)
590
643
        finally:
591
644
            pb.finished()
649
702
            if stop:
650
703
                return result
651
704
            next_transport = found_bzrdir.root_transport.clone('..')
652
 
            if (found_bzrdir.root_transport.base == next_transport.base):
 
705
            if (found_bzrdir.user_url == next_transport.base):
653
706
                # top of the file system
654
707
                return None
655
708
            # find the next containing bzrdir
672
725
                repository = found_bzrdir.open_repository()
673
726
            except errors.NoRepositoryPresent:
674
727
                return None, False
675
 
            if found_bzrdir.root_transport.base == self.root_transport.base:
 
728
            if found_bzrdir.user_url == self.user_url:
676
729
                return repository, True
677
730
            elif repository.is_shared():
678
731
                return repository, True
693
746
        """
694
747
        return None
695
748
 
696
 
    def get_branch_transport(self, branch_format):
 
749
    def get_branch_transport(self, branch_format, name=None):
697
750
        """Get the transport for use by branch format in this BzrDir.
698
751
 
699
752
        Note that bzr dirs that do not support format strings will raise
794
847
        :param _transport: the transport this dir is based at.
795
848
        """
796
849
        self._format = _format
 
850
        # these are also under the more standard names of 
 
851
        # control_transport and user_transport
797
852
        self.transport = _transport.clone('.bzr')
798
853
        self.root_transport = _transport
799
854
        self._mode_check_done = False
 
855
        
 
856
    @property 
 
857
    def user_transport(self):
 
858
        return self.root_transport
 
859
        
 
860
    @property
 
861
    def control_transport(self):
 
862
        return self.transport
800
863
 
801
864
    def is_control_filename(self, filename):
802
865
        """True if filename is the name of a path which is reserved for bzrdir's.
877
940
        BzrDir._check_supported(format, _unsupported)
878
941
        return format.open(transport, _found=True)
879
942
 
880
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
943
    def open_branch(self, name=None, unsupported=False,
 
944
                    ignore_fallbacks=False):
881
945
        """Open the branch object at this BzrDir if one is present.
882
946
 
883
947
        If unsupported is True, then no longer supported branch formats can
1021
1085
        """
1022
1086
        raise NotImplementedError(self.open_workingtree)
1023
1087
 
1024
 
    def has_branch(self):
 
1088
    def has_branch(self, name=None):
1025
1089
        """Tell if this bzrdir contains a branch.
1026
1090
 
1027
1091
        Note: if you're going to open the branch, you should just go ahead
1029
1093
        branch and discards it, and that's somewhat expensive.)
1030
1094
        """
1031
1095
        try:
1032
 
            self.open_branch()
 
1096
            self.open_branch(name)
1033
1097
            return True
1034
1098
        except errors.NotBranchError:
1035
1099
            return False
1309
1373
        self.create_hook(hooks.HookPoint('pre_open',
1310
1374
            "Invoked before attempting to open a BzrDir with the transport "
1311
1375
            "that the open will use.", (1, 14), None))
 
1376
        self.create_hook(hooks.HookPoint('post_repo_init',
 
1377
            "Invoked after a repository has been initialized. "
 
1378
            "post_repo_init is called with a "
 
1379
            "bzrlib.bzrdir.RepoInitHookParams.",
 
1380
            (2, 2), None))
1312
1381
 
1313
1382
# install the default hooks
1314
1383
BzrDir.hooks = BzrDirHooks()
1315
1384
 
1316
1385
 
 
1386
class RepoInitHookParams(object):
 
1387
    """Object holding parameters passed to *_repo_init hooks.
 
1388
 
 
1389
    There are 4 fields that hooks may wish to access:
 
1390
 
 
1391
    :ivar repository: Repository created
 
1392
    :ivar format: Repository format
 
1393
    :ivar bzrdir: The bzrdir for the repository
 
1394
    :ivar shared: The repository is shared
 
1395
    """
 
1396
 
 
1397
    def __init__(self, repository, format, a_bzrdir, shared):
 
1398
        """Create a group of RepoInitHook parameters.
 
1399
 
 
1400
        :param repository: Repository created
 
1401
        :param format: Repository format
 
1402
        :param bzrdir: The bzrdir for the repository
 
1403
        :param shared: The repository is shared
 
1404
        """
 
1405
        self.repository = repository
 
1406
        self.format = format
 
1407
        self.bzrdir = a_bzrdir
 
1408
        self.shared = shared
 
1409
 
 
1410
    def __eq__(self, other):
 
1411
        return self.__dict__ == other.__dict__
 
1412
 
 
1413
    def __repr__(self):
 
1414
        if self.repository:
 
1415
            return "<%s for %s>" % (self.__class__.__name__,
 
1416
                self.repository)
 
1417
        else:
 
1418
            return "<%s for %s>" % (self.__class__.__name__,
 
1419
                self.bzrdir)
 
1420
 
 
1421
 
1317
1422
class BzrDirPreSplitOut(BzrDir):
1318
1423
    """A common class for the all-in-one formats."""
1319
1424
 
1358
1463
            tree.clone(result)
1359
1464
        return result
1360
1465
 
1361
 
    def create_branch(self):
 
1466
    def create_branch(self, name=None):
1362
1467
        """See BzrDir.create_branch."""
1363
 
        return self._format.get_branch_format().initialize(self)
 
1468
        return self._format.get_branch_format().initialize(self, name=name)
1364
1469
 
1365
 
    def destroy_branch(self):
 
1470
    def destroy_branch(self, name=None):
1366
1471
        """See BzrDir.destroy_branch."""
1367
1472
        raise errors.UnsupportedOperation(self.destroy_branch, self)
1368
1473
 
1424
1529
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1425
1530
                                          self)
1426
1531
 
1427
 
    def get_branch_transport(self, branch_format):
 
1532
    def get_branch_transport(self, branch_format, name=None):
1428
1533
        """See BzrDir.get_branch_transport()."""
 
1534
        if name is not None:
 
1535
            raise errors.NoColocatedBranchSupport(self)
1429
1536
        if branch_format is None:
1430
1537
            return self.transport
1431
1538
        try:
1464
1571
            format = BzrDirFormat.get_default_format()
1465
1572
        return not isinstance(self._format, format.__class__)
1466
1573
 
1467
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
1574
    def open_branch(self, name=None, unsupported=False,
 
1575
                    ignore_fallbacks=False):
1468
1576
        """See BzrDir.open_branch."""
1469
1577
        from bzrlib.branch import BzrBranchFormat4
1470
1578
        format = BzrBranchFormat4()
1471
1579
        self._check_supported(format, unsupported)
1472
 
        return format.open(self, _found=True)
 
1580
        return format.open(self, name, _found=True)
1473
1581
 
1474
1582
    def sprout(self, url, revision_id=None, force_new_repo=False,
1475
1583
               possible_transports=None, accelerator_tree=None,
1592
1700
        """See BzrDir.can_convert_format()."""
1593
1701
        return True
1594
1702
 
1595
 
    def create_branch(self):
 
1703
    def create_branch(self, name=None):
1596
1704
        """See BzrDir.create_branch."""
1597
 
        return self._format.get_branch_format().initialize(self)
 
1705
        return self._format.get_branch_format().initialize(self, name=name)
1598
1706
 
1599
 
    def destroy_branch(self):
 
1707
    def destroy_branch(self, name=None):
1600
1708
        """See BzrDir.create_branch."""
 
1709
        if name is not None:
 
1710
            raise errors.NoColocatedBranchSupport(self)
1601
1711
        self.transport.delete_tree('branch')
1602
1712
 
1603
1713
    def create_repository(self, shared=False):
1646
1756
        format = BranchFormat.find_format(self)
1647
1757
        return format.get_reference(self)
1648
1758
 
1649
 
    def get_branch_transport(self, branch_format):
 
1759
    def get_branch_transport(self, branch_format, name=None):
1650
1760
        """See BzrDir.get_branch_transport()."""
 
1761
        if name is not None:
 
1762
            raise errors.NoColocatedBranchSupport(self)
1651
1763
        # XXX: this shouldn't implicitly create the directory if it's just
1652
1764
        # promising to get a transport -- mbp 20090727
1653
1765
        if branch_format is None:
1724
1836
                return True
1725
1837
        except errors.NoRepositoryPresent:
1726
1838
            pass
1727
 
        try:
1728
 
            if not isinstance(self.open_branch()._format,
 
1839
        for branch in self.list_branches():
 
1840
            if not isinstance(branch._format,
1729
1841
                              format.get_branch_format().__class__):
1730
1842
                # the branch needs an upgrade.
1731
1843
                return True
1732
 
        except errors.NotBranchError:
1733
 
            pass
1734
1844
        try:
1735
1845
            my_wt = self.open_workingtree(recommend_upgrade=False)
1736
1846
            if not isinstance(my_wt._format,
1741
1851
            pass
1742
1852
        return False
1743
1853
 
1744
 
    def open_branch(self, unsupported=False, ignore_fallbacks=False):
 
1854
    def open_branch(self, name=None, unsupported=False,
 
1855
                    ignore_fallbacks=False):
1745
1856
        """See BzrDir.open_branch."""
1746
1857
        format = self.find_branch_format()
1747
1858
        self._check_supported(format, unsupported)
1748
 
        return format.open(self, _found=True, ignore_fallbacks=ignore_fallbacks)
 
1859
        return format.open(self, name=name,
 
1860
            _found=True, ignore_fallbacks=ignore_fallbacks)
1749
1861
 
1750
1862
    def open_repository(self, unsupported=False):
1751
1863
        """See BzrDir.open_repository."""
1783
1895
    Once a format is deprecated, just deprecate the initialize and open
1784
1896
    methods on the format class. Do not deprecate the object, as the
1785
1897
    object will be created every system load.
 
1898
 
 
1899
    :cvar colocated_branches: Whether this formats supports colocated branches.
1786
1900
    """
1787
1901
 
1788
1902
    _default_format = None
1805
1919
 
1806
1920
    _lock_file_name = 'branch-lock'
1807
1921
 
 
1922
    colocated_branches = False
 
1923
    """Whether co-located branches are supported for this control dir format.
 
1924
    """
 
1925
 
1808
1926
    # _lock_class must be set in subclasses to the lock type, typ.
1809
1927
    # TransportLock or LockDir
1810
1928
 
1827
1945
    def probe_transport(klass, transport):
1828
1946
        """Return the .bzrdir style format present in a directory."""
1829
1947
        try:
1830
 
            format_string = transport.get(".bzr/branch-format").read()
 
1948
            format_string = transport.get_bytes(".bzr/branch-format")
1831
1949
        except errors.NoSuchFile:
1832
1950
            raise errors.NotBranchError(path=transport.base)
1833
1951
 
2609
2727
    def convert(self, to_convert, pb):
2610
2728
        """See Converter.convert()."""
2611
2729
        self.bzrdir = to_convert
2612
 
        self.pb = pb
2613
 
        ui.ui_factory.note('starting upgrade from format 4 to 5')
2614
 
        if isinstance(self.bzrdir.transport, local.LocalTransport):
2615
 
            self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2616
 
        self._convert_to_weaves()
2617
 
        return BzrDir.open(self.bzrdir.root_transport.base)
 
2730
        if pb is not None:
 
2731
            warnings.warn("pb parameter to convert() is deprecated")
 
2732
        self.pb = ui.ui_factory.nested_progress_bar()
 
2733
        try:
 
2734
            ui.ui_factory.note('starting upgrade from format 4 to 5')
 
2735
            if isinstance(self.bzrdir.transport, local.LocalTransport):
 
2736
                self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
 
2737
            self._convert_to_weaves()
 
2738
            return BzrDir.open(self.bzrdir.user_url)
 
2739
        finally:
 
2740
            self.pb.finished()
2618
2741
 
2619
2742
    def _convert_to_weaves(self):
2620
2743
        ui.ui_factory.note('note: upgrade may be faster if all store files are ungzipped first')
2861
2984
    def convert(self, to_convert, pb):
2862
2985
        """See Converter.convert()."""
2863
2986
        self.bzrdir = to_convert
2864
 
        self.pb = pb
2865
 
        ui.ui_factory.note('starting upgrade from format 5 to 6')
2866
 
        self._convert_to_prefixed()
2867
 
        return BzrDir.open(self.bzrdir.root_transport.base)
 
2987
        pb = ui.ui_factory.nested_progress_bar()
 
2988
        try:
 
2989
            ui.ui_factory.note('starting upgrade from format 5 to 6')
 
2990
            self._convert_to_prefixed()
 
2991
            return BzrDir.open(self.bzrdir.user_url)
 
2992
        finally:
 
2993
            pb.finished()
2868
2994
 
2869
2995
    def _convert_to_prefixed(self):
2870
2996
        from bzrlib.store import TransportStore
2903
3029
        from bzrlib.repofmt.weaverepo import RepositoryFormat7
2904
3030
        from bzrlib.branch import BzrBranchFormat5
2905
3031
        self.bzrdir = to_convert
2906
 
        self.pb = pb
 
3032
        self.pb = ui.ui_factory.nested_progress_bar()
2907
3033
        self.count = 0
2908
3034
        self.total = 20 # the steps we know about
2909
3035
        self.garbage_inventories = []
2989
3115
            'branch-format',
2990
3116
            BzrDirMetaFormat1().get_format_string(),
2991
3117
            mode=self.file_mode)
2992
 
        return BzrDir.open(self.bzrdir.root_transport.base)
 
3118
        self.pb.finished()
 
3119
        return BzrDir.open(self.bzrdir.user_url)
2993
3120
 
2994
3121
    def make_lock(self, name):
2995
3122
        """Make a lock for the new control dir name."""
3030
3157
    def convert(self, to_convert, pb):
3031
3158
        """See Converter.convert()."""
3032
3159
        self.bzrdir = to_convert
3033
 
        self.pb = pb
 
3160
        self.pb = ui.ui_factory.nested_progress_bar()
3034
3161
        self.count = 0
3035
3162
        self.total = 1
3036
3163
        self.step('checking repository format')
3044
3171
                ui.ui_factory.note('starting repository conversion')
3045
3172
                converter = CopyConverter(self.target_format.repository_format)
3046
3173
                converter.convert(repo, pb)
3047
 
        try:
3048
 
            branch = self.bzrdir.open_branch()
3049
 
        except errors.NotBranchError:
3050
 
            pass
3051
 
        else:
 
3174
        for branch in self.bzrdir.list_branches():
3052
3175
            # TODO: conversions of Branch and Tree should be done by
3053
3176
            # InterXFormat lookups/some sort of registry.
3054
3177
            # Avoid circular imports
3096
3219
                isinstance(self.target_format.workingtree_format,
3097
3220
                    workingtree_4.WorkingTreeFormat6)):
3098
3221
                workingtree_4.Converter4or5to6().convert(tree)
 
3222
        self.pb.finished()
3099
3223
        return to_convert
3100
3224
 
3101
3225
 
3108
3232
 
3109
3233
    def __init__(self):
3110
3234
        BzrDirMetaFormat1.__init__(self)
 
3235
        # XXX: It's a bit ugly that the network name is here, because we'd
 
3236
        # like to believe that format objects are stateless or at least
 
3237
        # immutable,  However, we do at least avoid mutating the name after
 
3238
        # it's returned.  See <https://bugs.edge.launchpad.net/bzr/+bug/504102>
3111
3239
        self._network_name = None
3112
3240
 
 
3241
    def __repr__(self):
 
3242
        return "%s(_network_name=%r)" % (self.__class__.__name__,
 
3243
            self._network_name)
 
3244
 
3113
3245
    def get_format_description(self):
 
3246
        if self._network_name:
 
3247
            real_format = network_format_registry.get(self._network_name)
 
3248
            return 'Remote: ' + real_format.get_format_description()
3114
3249
        return 'bzr remote bzrdir'
3115
3250
 
3116
3251
    def get_format_string(self):
3249
3384
        args.append(self._serialize_NoneString(repo_format_name))
3250
3385
        args.append(self._serialize_NoneTrueFalse(make_working_trees))
3251
3386
        args.append(self._serialize_NoneTrueFalse(shared_repo))
3252
 
        if self._network_name is None:
3253
 
            self._network_name = \
 
3387
        request_network_name = self._network_name or \
3254
3388
            BzrDirFormat.get_default_format().network_name()
3255
3389
        try:
3256
3390
            response = client.call('BzrDirFormat.initialize_ex_1.16',
3257
 
                self.network_name(), path, *args)
 
3391
                request_network_name, path, *args)
3258
3392
        except errors.UnknownSmartMethod:
3259
3393
            client._medium._remember_remote_is_before((1,16))
3260
3394
            local_dir_format = BzrDirMetaFormat1()
3510
3644
                experimental_pairs.append((key, help))
3511
3645
            else:
3512
3646
                output += wrapped(key, help, info)
3513
 
        output += "\nSee ``bzr help formats`` for more about storage formats."
 
3647
        output += "\nSee :doc:`formats-help` for more about storage formats."
3514
3648
        other_output = ""
3515
3649
        if len(experimental_pairs) > 0:
3516
3650
            other_output += "Experimental formats are shown below.\n\n"
3529
3663
            other_output += \
3530
3664
                "\nNo deprecated formats are available.\n\n"
3531
3665
        other_output += \
3532
 
            "\nSee ``bzr help formats`` for more about storage formats."
 
3666
                "\nSee :doc:`formats-help` for more about storage formats."
3533
3667
 
3534
3668
        if topic == 'other-formats':
3535
3669
            return other_output
3569
3703
            try:
3570
3704
                stack_on = urlutils.rebase_url(self._stack_on,
3571
3705
                    self._stack_on_pwd,
3572
 
                    branch.bzrdir.root_transport.base)
 
3706
                    branch.user_url)
3573
3707
            except errors.InvalidRebaseURLs:
3574
3708
                stack_on = self._get_full_stack_on()
3575
3709
        try:
3704
3838
format_registry.register('weave', BzrDirFormat6,
3705
3839
    'Pre-0.8 format.  Slower than knit and does not'
3706
3840
    ' support checkouts or shared repositories.',
 
3841
    hidden=True,
3707
3842
    deprecated=True)
3708
3843
format_registry.register_metadir('metaweave',
3709
3844
    'bzrlib.repofmt.weaverepo.RepositoryFormat7',
3710
3845
    'Transitional format in 0.8.  Slower than knit.',
3711
3846
    branch_format='bzrlib.branch.BzrBranchFormat5',
3712
3847
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
 
3848
    hidden=True,
3713
3849
    deprecated=True)
3714
3850
format_registry.register_metadir('knit',
3715
3851
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3716
3852
    'Format using knits.  Recommended for interoperation with bzr <= 0.14.',
3717
3853
    branch_format='bzrlib.branch.BzrBranchFormat5',
3718
3854
    tree_format='bzrlib.workingtree.WorkingTreeFormat3',
 
3855
    hidden=True,
3719
3856
    deprecated=True)
3720
3857
format_registry.register_metadir('dirstate',
3721
3858
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3725
3862
    # this uses bzrlib.workingtree.WorkingTreeFormat4 because importing
3726
3863
    # directly from workingtree_4 triggers a circular import.
3727
3864
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3865
    hidden=True,
3728
3866
    deprecated=True)
3729
3867
format_registry.register_metadir('dirstate-tags',
3730
3868
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
3733
3871
        ' Incompatible with bzr < 0.15.',
3734
3872
    branch_format='bzrlib.branch.BzrBranchFormat6',
3735
3873
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3874
    hidden=True,
3736
3875
    deprecated=True)
3737
3876
format_registry.register_metadir('rich-root',
3738
3877
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit4',
3740
3879
        ' bzr < 1.0.',
3741
3880
    branch_format='bzrlib.branch.BzrBranchFormat6',
3742
3881
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3882
    hidden=True,
3743
3883
    deprecated=True)
3744
3884
format_registry.register_metadir('dirstate-with-subtree',
3745
3885
    'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
3756
3896
    help='New in 0.92: Pack-based format with data compatible with '
3757
3897
        'dirstate-tags format repositories. Interoperates with '
3758
3898
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3759
 
        'Previously called knitpack-experimental.  '
3760
 
        'For more information, see '
3761
 
        'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
 
3899
        ,
3762
3900
    branch_format='bzrlib.branch.BzrBranchFormat6',
3763
3901
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3764
3902
    )
3767
3905
    help='New in 0.92: Pack-based format with data compatible with '
3768
3906
        'dirstate-with-subtree format repositories. Interoperates with '
3769
3907
        'bzr repositories before 0.92 but cannot be read by bzr < 0.92. '
3770
 
        'Previously called knitpack-experimental.  '
3771
 
        'For more information, see '
3772
 
        'http://doc.bazaar-vcs.org/latest/developers/packrepo.html.',
 
3908
        ,
3773
3909
    branch_format='bzrlib.branch.BzrBranchFormat6',
3774
3910
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
3775
3911
    hidden=True,
3781
3917
         '(needed for bzr-svn and bzr-git).',
3782
3918
    branch_format='bzrlib.branch.BzrBranchFormat6',
3783
3919
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3920
    hidden=True,
3784
3921
    )
3785
3922
format_registry.register_metadir('1.6',
3786
3923
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5',
3789
3926
         'not present locally.',
3790
3927
    branch_format='bzrlib.branch.BzrBranchFormat7',
3791
3928
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3929
    hidden=True,
3792
3930
    )
3793
3931
format_registry.register_metadir('1.6.1-rich-root',
3794
3932
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack5RichRoot',
3796
3934
         '(needed for bzr-svn and bzr-git).',
3797
3935
    branch_format='bzrlib.branch.BzrBranchFormat7',
3798
3936
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3937
    hidden=True,
3799
3938
    )
3800
3939
format_registry.register_metadir('1.9',
3801
3940
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3804
3943
         'performance for most operations.',
3805
3944
    branch_format='bzrlib.branch.BzrBranchFormat7',
3806
3945
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3946
    hidden=True,
3807
3947
    )
3808
3948
format_registry.register_metadir('1.9-rich-root',
3809
3949
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6RichRoot',
3811
3951
         '(needed for bzr-svn and bzr-git).',
3812
3952
    branch_format='bzrlib.branch.BzrBranchFormat7',
3813
3953
    tree_format='bzrlib.workingtree.WorkingTreeFormat4',
 
3954
    hidden=True,
3814
3955
    )
3815
3956
format_registry.register_metadir('1.14',
3816
3957
    'bzrlib.repofmt.pack_repo.RepositoryFormatKnitPack6',
3832
3973
        'to and from rich-root-pack (and anything compatible with '
3833
3974
        'rich-root-pack) format repositories. Repositories and branches in '
3834
3975
        'this format can only be read by bzr.dev. Please read '
3835
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
 
3976
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3836
3977
        'before use.',
3837
3978
    branch_format='bzrlib.branch.BzrBranchFormat7',
3838
3979
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3839
3980
    experimental=True,
3840
3981
    alias=True,
 
3982
    hidden=True,
3841
3983
    )
3842
3984
format_registry.register_metadir('development-subtree',
3843
3985
    'bzrlib.repofmt.pack_repo.RepositoryFormatPackDevelopment2Subtree',
3845
3987
        'from pack-0.92-subtree (and anything compatible with '
3846
3988
        'pack-0.92-subtree) format repositories. Repositories and branches in '
3847
3989
        'this format can only be read by bzr.dev. Please read '
3848
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
 
3990
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3849
3991
        'before use.',
3850
3992
    branch_format='bzrlib.branch.BzrBranchFormat7',
3851
3993
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3852
3994
    experimental=True,
 
3995
    hidden=True,
3853
3996
    alias=False, # Restore to being an alias when an actual development subtree format is added
3854
3997
                 # This current non-alias status is simply because we did not introduce a
3855
3998
                 # chk based subtree format.
3860
4003
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK1',
3861
4004
    help='pack-1.9 with 255-way hashed CHK inv, group compress, rich roots '
3862
4005
        'Please read '
3863
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
 
4006
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3864
4007
        'before use.',
3865
4008
    branch_format='bzrlib.branch.BzrBranchFormat7',
3866
4009
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3872
4015
    'bzrlib.repofmt.groupcompress_repo.RepositoryFormatCHK2',
3873
4016
    help='pack-1.9 with 255-way hashed CHK inv, bencode revision, group compress, '
3874
4017
        'rich roots. Please read '
3875
 
        'http://doc.bazaar-vcs.org/latest/developers/development-repo.html '
 
4018
        'http://doc.bazaar.canonical.com/latest/developers/development-repo.html '
3876
4019
        'before use.',
3877
4020
    branch_format='bzrlib.branch.BzrBranchFormat7',
3878
4021
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3899
4042
    branch_format='bzrlib.branch.BzrBranchFormat7',
3900
4043
    tree_format='bzrlib.workingtree.WorkingTreeFormat6',
3901
4044
    alias=True,
 
4045
    hidden=True,
3902
4046
    help='Same as 2a.')
3903
4047
 
3904
4048
# The current format that is made on 'bzr init'.