/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: Parth Malwankar
  • Date: 2010-04-14 10:12:22 UTC
  • mto: This revision was merged to the branch mainline in revision 5156.
  • Revision ID: parth.malwankar@gmail.com-20100414101222-uiu2ucurptoz1dg1
improved bug description.

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 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):
 
89
 
 
90
 
 
91
class BzrDir(object):
125
92
    """A .bzr control diretory.
126
93
 
127
94
    BzrDir instances let you create or open any of the things that can be
294
261
                # copied, and finally if we are copying up to a specific
295
262
                # revision_id then we can use the pending-ancestry-result which
296
263
                # 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
 
264
                if (result_repo.bzrdir.root_transport.base ==
 
265
                    result.root_transport.base and not require_stacking and
299
266
                    revision_id is not None):
300
267
                    fetch_spec = graph.PendingAncestryResult(
301
268
                        [revision_id], local_repo)
491
458
            stop = False
492
459
            stack_on = config.get_default_stack_on()
493
460
            if stack_on is not None:
494
 
                stack_on_pwd = found_bzrdir.user_url
 
461
                stack_on_pwd = found_bzrdir.root_transport.base
495
462
                stop = True
496
463
            # does it have a repository ?
497
464
            try:
499
466
            except errors.NoRepositoryPresent:
500
467
                repository = None
501
468
            else:
502
 
                if (found_bzrdir.user_url != self.user_url 
503
 
                    and not repository.is_shared()):
 
469
                if ((found_bzrdir.root_transport.base !=
 
470
                     self.root_transport.base) and not repository.is_shared()):
504
471
                    # Don't look higher, can't use a higher shared repo.
505
472
                    repository = None
506
473
                    stop = True
702
669
            if stop:
703
670
                return result
704
671
            next_transport = found_bzrdir.root_transport.clone('..')
705
 
            if (found_bzrdir.user_url == next_transport.base):
 
672
            if (found_bzrdir.root_transport.base == next_transport.base):
706
673
                # top of the file system
707
674
                return None
708
675
            # find the next containing bzrdir
725
692
                repository = found_bzrdir.open_repository()
726
693
            except errors.NoRepositoryPresent:
727
694
                return None, False
728
 
            if found_bzrdir.user_url == self.user_url:
 
695
            if found_bzrdir.root_transport.base == self.root_transport.base:
729
696
                return repository, True
730
697
            elif repository.is_shared():
731
698
                return repository, True
737
704
            raise errors.NoRepositoryPresent(self)
738
705
        return found_repo
739
706
 
740
 
    def get_branch_reference(self, name=None):
 
707
    def get_branch_reference(self):
741
708
        """Return the referenced URL for the branch in this bzrdir.
742
709
 
743
 
        :param name: Optional colocated branch name
744
710
        :raises NotBranchError: If there is no Branch.
745
 
        :raises NoColocatedBranchSupport: If a branch name was specified
746
 
            but colocated branches are not supported.
747
711
        :return: The URL the branch in this bzrdir references if it is a
748
712
            reference branch, or None for regular branches.
749
713
        """
750
 
        if name is not None:
751
 
            raise errors.NoColocatedBranchSupport(self)
752
714
        return None
753
715
 
754
716
    def get_branch_transport(self, branch_format, name=None):
852
814
        :param _transport: the transport this dir is based at.
853
815
        """
854
816
        self._format = _format
855
 
        # these are also under the more standard names of 
856
 
        # control_transport and user_transport
857
817
        self.transport = _transport.clone('.bzr')
858
818
        self.root_transport = _transport
859
819
        self._mode_check_done = False
860
 
        
861
 
    @property 
862
 
    def user_transport(self):
863
 
        return self.root_transport
864
 
        
865
 
    @property
866
 
    def control_transport(self):
867
 
        return self.transport
868
820
 
869
821
    def is_control_filename(self, filename):
870
822
        """True if filename is the name of a path which is reserved for bzrdir's.
999
951
                raise errors.NotBranchError(path=url)
1000
952
            a_transport = new_t
1001
953
 
1002
 
    def _get_tree_branch(self, name=None):
 
954
    def _get_tree_branch(self):
1003
955
        """Return the branch and tree, if any, for this bzrdir.
1004
956
 
1005
 
        :param name: Name of colocated branch to open.
1006
 
 
1007
957
        Return None for tree if not present or inaccessible.
1008
958
        Raise NotBranchError if no branch is present.
1009
959
        :return: (tree, branch)
1012
962
            tree = self.open_workingtree()
1013
963
        except (errors.NoWorkingTree, errors.NotLocalUrl):
1014
964
            tree = None
1015
 
            branch = self.open_branch(name=name)
 
965
            branch = self.open_branch()
1016
966
        else:
1017
 
            if name is not None:
1018
 
                branch = self.open_branch(name=name)
1019
 
            else:
1020
 
                branch = tree.branch
 
967
            branch = tree.branch
1021
968
        return tree, branch
1022
969
 
1023
970
    @classmethod
1383
1330
        self.create_hook(hooks.HookPoint('pre_open',
1384
1331
            "Invoked before attempting to open a BzrDir with the transport "
1385
1332
            "that the open will use.", (1, 14), None))
1386
 
        self.create_hook(hooks.HookPoint('post_repo_init',
1387
 
            "Invoked after a repository has been initialized. "
1388
 
            "post_repo_init is called with a "
1389
 
            "bzrlib.bzrdir.RepoInitHookParams.",
1390
 
            (2, 2), None))
1391
1333
 
1392
1334
# install the default hooks
1393
1335
BzrDir.hooks = BzrDirHooks()
1394
1336
 
1395
1337
 
1396
 
class RepoInitHookParams(object):
1397
 
    """Object holding parameters passed to *_repo_init hooks.
1398
 
 
1399
 
    There are 4 fields that hooks may wish to access:
1400
 
 
1401
 
    :ivar repository: Repository created
1402
 
    :ivar format: Repository format
1403
 
    :ivar bzrdir: The bzrdir for the repository
1404
 
    :ivar shared: The repository is shared
1405
 
    """
1406
 
 
1407
 
    def __init__(self, repository, format, a_bzrdir, shared):
1408
 
        """Create a group of RepoInitHook parameters.
1409
 
 
1410
 
        :param repository: Repository created
1411
 
        :param format: Repository format
1412
 
        :param bzrdir: The bzrdir for the repository
1413
 
        :param shared: The repository is shared
1414
 
        """
1415
 
        self.repository = repository
1416
 
        self.format = format
1417
 
        self.bzrdir = a_bzrdir
1418
 
        self.shared = shared
1419
 
 
1420
 
    def __eq__(self, other):
1421
 
        return self.__dict__ == other.__dict__
1422
 
 
1423
 
    def __repr__(self):
1424
 
        if self.repository:
1425
 
            return "<%s for %s>" % (self.__class__.__name__,
1426
 
                self.repository)
1427
 
        else:
1428
 
            return "<%s for %s>" % (self.__class__.__name__,
1429
 
                self.bzrdir)
1430
 
 
1431
 
 
1432
1338
class BzrDirPreSplitOut(BzrDir):
1433
1339
    """A common class for the all-in-one formats."""
1434
1340
 
1746
1652
    def destroy_workingtree_metadata(self):
1747
1653
        self.transport.delete_tree('checkout')
1748
1654
 
1749
 
    def find_branch_format(self, name=None):
 
1655
    def find_branch_format(self):
1750
1656
        """Find the branch 'format' for this bzrdir.
1751
1657
 
1752
1658
        This might be a synthetic object for e.g. RemoteBranch and SVN.
1753
1659
        """
1754
1660
        from bzrlib.branch import BranchFormat
1755
 
        return BranchFormat.find_format(self, name=name)
 
1661
        return BranchFormat.find_format(self)
1756
1662
 
1757
1663
    def _get_mkdir_mode(self):
1758
1664
        """Figure out the mode to use when creating a bzrdir subdir."""
1760
1666
                                     lockable_files.TransportLock)
1761
1667
        return temp_control._dir_mode
1762
1668
 
1763
 
    def get_branch_reference(self, name=None):
 
1669
    def get_branch_reference(self):
1764
1670
        """See BzrDir.get_branch_reference()."""
1765
1671
        from bzrlib.branch import BranchFormat
1766
 
        format = BranchFormat.find_format(self, name=name)
1767
 
        return format.get_reference(self, name=name)
 
1672
        format = BranchFormat.find_format(self)
 
1673
        return format.get_reference(self)
1768
1674
 
1769
1675
    def get_branch_transport(self, branch_format, name=None):
1770
1676
        """See BzrDir.get_branch_transport()."""
1864
1770
    def open_branch(self, name=None, unsupported=False,
1865
1771
                    ignore_fallbacks=False):
1866
1772
        """See BzrDir.open_branch."""
1867
 
        format = self.find_branch_format(name=name)
 
1773
        format = self.find_branch_format()
1868
1774
        self._check_supported(format, unsupported)
1869
1775
        return format.open(self, name=name,
1870
1776
            _found=True, ignore_fallbacks=ignore_fallbacks)
2745
2651
            if isinstance(self.bzrdir.transport, local.LocalTransport):
2746
2652
                self.bzrdir.get_workingtree_transport(None).delete('stat-cache')
2747
2653
            self._convert_to_weaves()
2748
 
            return BzrDir.open(self.bzrdir.user_url)
 
2654
            return BzrDir.open(self.bzrdir.root_transport.base)
2749
2655
        finally:
2750
2656
            self.pb.finished()
2751
2657
 
2998
2904
        try:
2999
2905
            ui.ui_factory.note('starting upgrade from format 5 to 6')
3000
2906
            self._convert_to_prefixed()
3001
 
            return BzrDir.open(self.bzrdir.user_url)
 
2907
            return BzrDir.open(self.bzrdir.root_transport.base)
3002
2908
        finally:
3003
2909
            pb.finished()
3004
2910
 
3126
3032
            BzrDirMetaFormat1().get_format_string(),
3127
3033
            mode=self.file_mode)
3128
3034
        self.pb.finished()
3129
 
        return BzrDir.open(self.bzrdir.user_url)
 
3035
        return BzrDir.open(self.bzrdir.root_transport.base)
3130
3036
 
3131
3037
    def make_lock(self, name):
3132
3038
        """Make a lock for the new control dir name."""
3713
3619
            try:
3714
3620
                stack_on = urlutils.rebase_url(self._stack_on,
3715
3621
                    self._stack_on_pwd,
3716
 
                    branch.user_url)
 
3622
                    branch.bzrdir.root_transport.base)
3717
3623
            except errors.InvalidRebaseURLs:
3718
3624
                stack_on = self._get_full_stack_on()
3719
3625
        try: