← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bzrdir.py

  • Committer: Gordon Tyler
  • Date: 2009-11-11 21:38:02 UTC
  • mto: This revision was merged to the branch mainline in revision 4801.
  • Revision ID: gordon@doxxx.net-20091111213802-wj8d2fgirjd7saqn
Fixed globbing.normalize_pattern to not strip '/' down to '' and normalize multiple slashes.

Show diffs side-by-side

added added

removed removed

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