/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-04 06:22:51 UTC
  • mto: This revision was merged to the branch mainline in revision 5206.
  • Revision ID: robertc@robertcollins.net-20100504062251-1ocjhrl53mum9ehw
Minor local_abspath docstring improvement.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bzrdir.py
86
86
    registry,
87
87
    symbol_versioning,
88
88
    )
89
 
 
90
 
 
91
 
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):
92
125
    """A .bzr control diretory.
93
126
 
94
127
    BzrDir instances let you create or open any of the things that can be
261
294
                # copied, and finally if we are copying up to a specific
262
295
                # revision_id then we can use the pending-ancestry-result which
263
296
                # does not require traversing all of history to describe it.
264
 
                if (result_repo.bzrdir.root_transport.base ==
265
 
                    result.root_transport.base and not require_stacking and
 
297
                if (result_repo.user_url == result.user_url
 
298
                    and not require_stacking and
266
299
                    revision_id is not None):
267
300
                    fetch_spec = graph.PendingAncestryResult(
268
301
                        [revision_id], local_repo)
458
491
            stop = False
459
492
            stack_on = config.get_default_stack_on()
460
493
            if stack_on is not None:
461
 
                stack_on_pwd = found_bzrdir.root_transport.base
 
494
                stack_on_pwd = found_bzrdir.user_url
462
495
                stop = True
463
496
            # does it have a repository ?
464
497
            try:
466
499
            except errors.NoRepositoryPresent:
467
500
                repository = None
468
501
            else:
469
 
                if ((found_bzrdir.root_transport.base !=
470
 
                     self.root_transport.base) and not repository.is_shared()):
 
502
                if (found_bzrdir.user_url != self.user_url 
 
503
                    and not repository.is_shared()):
471
504
                    # Don't look higher, can't use a higher shared repo.
472
505
                    repository = None
473
506
                    stop = True
602
635
            # already exists, but it should instead either remove it or make
603
636
            # a new backup directory.
604
637
            #
605
 
            # FIXME: bug 262450 -- the backup directory should have the same
606
 
            # permissions as the .bzr directory (probably a bug in copy_tree)
607
638
            old_path = self.root_transport.abspath('.bzr')
608
639
            new_path = self.root_transport.abspath(backup_dir)
609
640
            ui.ui_factory.note('making backup of %s\n  to %s' % (old_path, new_path,))
671
702
            if stop:
672
703
                return result
673
704
            next_transport = found_bzrdir.root_transport.clone('..')
674
 
            if (found_bzrdir.root_transport.base == next_transport.base):
 
705
            if (found_bzrdir.user_url == next_transport.base):
675
706
                # top of the file system
676
707
                return None
677
708
            # find the next containing bzrdir
694
725
                repository = found_bzrdir.open_repository()
695
726
            except errors.NoRepositoryPresent:
696
727
                return None, False
697
 
            if found_bzrdir.root_transport.base == self.root_transport.base:
 
728
            if found_bzrdir.user_url == self.user_url:
698
729
                return repository, True
699
730
            elif repository.is_shared():
700
731
                return repository, True
715
746
        """
716
747
        return None
717
748
 
718
 
    def get_branch_transport(self, branch_format):
 
749
    def get_branch_transport(self, branch_format, name=None):
719
750
        """Get the transport for use by branch format in this BzrDir.
720
751
 
721
752
        Note that bzr dirs that do not support format strings will raise
816
847
        :param _transport: the transport this dir is based at.
817
848
        """
818
849
        self._format = _format
 
850
        # these are also under the more standard names of 
 
851
        # control_transport and user_transport
819
852
        self.transport = _transport.clone('.bzr')
820
853
        self.root_transport = _transport
821
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
822
863
 
823
864
    def is_control_filename(self, filename):
824
865
        """True if filename is the name of a path which is reserved for bzrdir's.
1332
1373
        self.create_hook(hooks.HookPoint('pre_open',
1333
1374
            "Invoked before attempting to open a BzrDir with the transport "
1334
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))
1335
1381
 
1336
1382
# install the default hooks
1337
1383
BzrDir.hooks = BzrDirHooks()
1338
1384
 
1339
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
 
1340
1422
class BzrDirPreSplitOut(BzrDir):
1341
1423
    """A common class for the all-in-one formats."""
1342
1424
 
1383
1465
 
1384
1466
    def create_branch(self, name=None):
1385
1467
        """See BzrDir.create_branch."""
1386
 
        if name is not None:
1387
 
            raise errors.NoColocatedBranchSupport(self)
1388
 
        return self._format.get_branch_format().initialize(self)
 
1468
        return self._format.get_branch_format().initialize(self, name=name)
1389
1469
 
1390
1470
    def destroy_branch(self, name=None):
1391
1471
        """See BzrDir.destroy_branch."""
1449
1529
        raise errors.UnsupportedOperation(self.destroy_workingtree_metadata,
1450
1530
                                          self)
1451
1531
 
1452
 
    def get_branch_transport(self, branch_format):
 
1532
    def get_branch_transport(self, branch_format, name=None):
1453
1533
        """See BzrDir.get_branch_transport()."""
 
1534
        if name is not None:
 
1535
            raise errors.NoColocatedBranchSupport(self)
1454
1536
        if branch_format is None:
1455
1537
            return self.transport
1456
1538
        try:
1492
1574
    def open_branch(self, name=None, unsupported=False,
1493
1575
                    ignore_fallbacks=False):
1494
1576
        """See BzrDir.open_branch."""
1495
 
        if name is not None:
1496
 
            raise errors.NoColocatedBranchSupport(self)
1497
1577
        from bzrlib.branch import BzrBranchFormat4
1498
1578
        format = BzrBranchFormat4()
1499
1579
        self._check_supported(format, unsupported)
1500
 
        return format.open(self, _found=True)
 
1580
        return format.open(self, name, _found=True)
1501
1581
 
1502
1582
    def sprout(self, url, revision_id=None, force_new_repo=False,
1503
1583
               possible_transports=None, accelerator_tree=None,
1622
1702
 
1623
1703
    def create_branch(self, name=None):
1624
1704
        """See BzrDir.create_branch."""
1625
 
        if name is not None:
1626
 
            raise errors.NoColocatedBranchSupport(self)
1627
 
        return self._format.get_branch_format().initialize(self)
 
1705
        return self._format.get_branch_format().initialize(self, name=name)
1628
1706
 
1629
1707
    def destroy_branch(self, name=None):
1630
1708
        """See BzrDir.create_branch."""
1678
1756
        format = BranchFormat.find_format(self)
1679
1757
        return format.get_reference(self)
1680
1758
 
1681
 
    def get_branch_transport(self, branch_format):
 
1759
    def get_branch_transport(self, branch_format, name=None):
1682
1760
        """See BzrDir.get_branch_transport()."""
 
1761
        if name is not None:
 
1762
            raise errors.NoColocatedBranchSupport(self)
1683
1763
        # XXX: this shouldn't implicitly create the directory if it's just
1684
1764
        # promising to get a transport -- mbp 20090727
1685
1765
        if branch_format is None:
1774
1854
    def open_branch(self, name=None, unsupported=False,
1775
1855
                    ignore_fallbacks=False):
1776
1856
        """See BzrDir.open_branch."""
1777
 
        if name is not None:
1778
 
            raise errors.NoColocatedBranchSupport(self)
1779
1857
        format = self.find_branch_format()
1780
1858
        self._check_supported(format, unsupported)
1781
 
        return format.open(self, _found=True, ignore_fallbacks=ignore_fallbacks)
 
1859
        return format.open(self, name=name,
 
1860
            _found=True, ignore_fallbacks=ignore_fallbacks)
1782
1861
 
1783
1862
    def open_repository(self, unsupported=False):
1784
1863
        """See BzrDir.open_repository."""
2656
2735
            if isinstance(self.bzrdir.transport, local.LocalTransport):
2657
2736
                self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2658
2737
            self._convert_to_weaves()
2659
 
            return BzrDir.open(self.bzrdir.root_transport.base)
 
2738
            return BzrDir.open(self.bzrdir.user_url)
2660
2739
        finally:
2661
2740
            self.pb.finished()
2662
2741
 
2909
2988
        try:
2910
2989
            ui.ui_factory.note('starting upgrade from format 5 to 6')
2911
2990
            self._convert_to_prefixed()
2912
 
            return BzrDir.open(self.bzrdir.root_transport.base)
 
2991
            return BzrDir.open(self.bzrdir.user_url)
2913
2992
        finally:
2914
2993
            pb.finished()
2915
2994
 
3037
3116
            BzrDirMetaFormat1().get_format_string(),
3038
3117
            mode=self.file_mode)
3039
3118
        self.pb.finished()
3040
 
        return BzrDir.open(self.bzrdir.root_transport.base)
 
3119
        return BzrDir.open(self.bzrdir.user_url)
3041
3120
 
3042
3121
    def make_lock(self, name):
3043
3122
        """Make a lock for the new control dir name."""
3624
3703
            try:
3625
3704
                stack_on = urlutils.rebase_url(self._stack_on,
3626
3705
                    self._stack_on_pwd,
3627
 
                    branch.bzrdir.root_transport.base)
 
3706
                    branch.user_url)
3628
3707
            except errors.InvalidRebaseURLs:
3629
3708
                stack_on = self._get_full_stack_on()
3630
3709
        try: