← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

(jelmer) Use the absolute_import feature everywhere in bzrlib,
 and add a source test to make sure it's used everywhere. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
from __future__ import absolute_import
 
18
 
17
19
import bzrlib.bzrdir
18
20
 
19
21
from cStringIO import StringIO
41
43
    transport,
42
44
    ui,
43
45
    urlutils,
 
46
    vf_search,
44
47
    )
45
48
from bzrlib.i18n import gettext, ngettext
46
49
""")
47
50
 
 
51
# Explicitly import bzrlib.bzrdir so that the BzrProber
 
52
# is guaranteed to be registered.
 
53
import bzrlib.bzrdir
 
54
 
48
55
from bzrlib import (
49
56
    controldir,
50
57
    )
662
669
        """
663
670
        if not self._format.supports_set_append_revisions_only():
664
671
            return False
665
 
        return self.get_config(
666
 
            ).get_user_option_as_bool('append_revisions_only')
 
672
        return self.get_config_stack().get('append_revisions_only')
667
673
 
668
674
    def set_append_revisions_only(self, enabled):
669
675
        if not self._format.supports_set_append_revisions_only():
670
676
            raise errors.UpgradeRequired(self.user_url)
671
 
        if enabled:
672
 
            value = 'True'
673
 
        else:
674
 
            value = 'False'
675
 
        self.get_config().set_user_option('append_revisions_only', value,
676
 
            warn_masked=True)
 
677
        self.get_config_stack().set('append_revisions_only', enabled)
677
678
 
678
679
    def set_reference_info(self, file_id, tree_path, branch_location):
679
680
        """Set the branch location to use for a tree reference."""
708
709
        """
709
710
        raise errors.UpgradeRequired(self.user_url)
710
711
 
711
 
    def get_commit_builder(self, parents, config=None, timestamp=None,
 
712
    def get_commit_builder(self, parents, config_stack=None, timestamp=None,
712
713
                           timezone=None, committer=None, revprops=None,
713
714
                           revision_id=None, lossy=False):
714
715
        """Obtain a CommitBuilder for this branch.
724
725
            represented, when pushing to a foreign VCS 
725
726
        """
726
727
 
727
 
        if config is None:
728
 
            config = self.get_config()
 
728
        if config_stack is None:
 
729
            config_stack = self.get_config_stack()
729
730
 
730
 
        return self.repository.get_commit_builder(self, parents, config,
 
731
        return self.repository.get_commit_builder(self, parents, config_stack,
731
732
            timestamp, timezone, committer, revprops, revision_id,
732
733
            lossy)
733
734
 
937
938
                    tags_to_fetch = set(self.tags.get_reverse_tag_dict())
938
939
                except errors.TagsNotSupported:
939
940
                    tags_to_fetch = set()
940
 
                fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
 
941
                fetch_spec = vf_search.NotInOtherForRevs(self.repository,
941
942
                    old_repository, required_ids=[self.last_revision()],
942
943
                    if_present_ids=tags_to_fetch, find_ghosts=True).execute()
943
944
                self.repository.fetch(old_repository, fetch_spec=fetch_spec)
1606
1607
        return not (self == other)
1607
1608
 
1608
1609
    @classmethod
1609
 
    def find_format(klass, controldir, name=None):
1610
 
        """Return the format for the branch object in controldir."""
1611
 
        try:
1612
 
            transport = controldir.get_branch_transport(None, name=name)
1613
 
        except errors.NoSuchFile:
1614
 
            raise errors.NotBranchError(path=name, bzrdir=controldir)
1615
 
        try:
1616
 
            format_string = transport.get_bytes("format")
1617
 
            return format_registry.get(format_string)
1618
 
        except errors.NoSuchFile:
1619
 
            raise errors.NotBranchError(path=transport.base, bzrdir=controldir)
1620
 
        except KeyError:
1621
 
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1622
 
 
1623
 
    @classmethod
1624
1610
    @deprecated_method(deprecated_in((2, 4, 0)))
1625
1611
    def get_default_format(klass):
1626
1612
        """Return the current default format."""
1663
1649
        """
1664
1650
        raise NotImplementedError(self.set_reference)
1665
1651
 
1666
 
    def get_format_string(self):
1667
 
        """Return the ASCII format string that identifies this format."""
1668
 
        raise NotImplementedError(self.get_format_string)
1669
 
 
1670
1652
    def get_format_description(self):
1671
1653
        """Return the short format description for this format."""
1672
1654
        raise NotImplementedError(self.get_format_description)
1799
1781
        """
1800
1782
        registry._LazyObjectGetter.__init__(self, module_name, member_name)
1801
1783
        self._format_string = format_string
1802
 
        
 
1784
 
1803
1785
    def get_format_string(self):
1804
1786
        """See BranchFormat.get_format_string."""
1805
1787
        return self._format_string
2017
1999
            self.revision_id)
2018
2000
 
2019
2001
 
2020
 
class BranchFormatMetadir(BranchFormat):
2021
 
    """Common logic for meta-dir based branch formats."""
 
2002
class BranchFormatMetadir(bzrdir.BzrDirMetaComponentFormat, BranchFormat):
 
2003
    """Base class for branch formats that live in meta directories.
 
2004
    """
 
2005
 
 
2006
    def __init__(self):
 
2007
        BranchFormat.__init__(self)
 
2008
        bzrdir.BzrDirMetaComponentFormat.__init__(self)
 
2009
 
 
2010
    @classmethod
 
2011
    def find_format(klass, controldir, name=None):
 
2012
        """Return the format for the branch object in controldir."""
 
2013
        try:
 
2014
            transport = controldir.get_branch_transport(None, name=name)
 
2015
        except errors.NoSuchFile:
 
2016
            raise errors.NotBranchError(path=name, bzrdir=controldir)
 
2017
        try:
 
2018
            format_string = transport.get_bytes("format")
 
2019
        except errors.NoSuchFile:
 
2020
            raise errors.NotBranchError(path=transport.base, bzrdir=controldir)
 
2021
        return klass._find_format(format_registry, 'branch', format_string)
2022
2022
 
2023
2023
    def _branch_class(self):
2024
2024
        """What class to instantiate on open calls."""
2061
2061
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2062
2062
        return branch
2063
2063
 
2064
 
    def network_name(self):
2065
 
        """A simple byte string uniquely identifying this format for RPC calls.
2066
 
 
2067
 
        Metadir branch formats use their format string.
2068
 
        """
2069
 
        return self.get_format_string()
2070
 
 
2071
2064
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2072
2065
            found_repository=None, possible_transports=None):
2073
2066
        """See BranchFormat.open()."""
2074
2067
        if not _found:
2075
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
 
2068
            format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2076
2069
            if format.__class__ != self.__class__:
2077
2070
                raise AssertionError("wrong format %r found for %r" %
2078
2071
                    (format, self))
2121
2114
    def _branch_class(self):
2122
2115
        return BzrBranch5
2123
2116
 
2124
 
    def get_format_string(self):
 
2117
    @classmethod
 
2118
    def get_format_string(cls):
2125
2119
        """See BranchFormat.get_format_string()."""
2126
2120
        return "Bazaar-NG branch format 5\n"
2127
2121
 
2157
2151
    def _branch_class(self):
2158
2152
        return BzrBranch6
2159
2153
 
2160
 
    def get_format_string(self):
 
2154
    @classmethod
 
2155
    def get_format_string(cls):
2161
2156
        """See BranchFormat.get_format_string()."""
2162
2157
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
2163
2158
 
2189
2184
    def _branch_class(self):
2190
2185
        return BzrBranch8
2191
2186
 
2192
 
    def get_format_string(self):
 
2187
    @classmethod
 
2188
    def get_format_string(cls):
2193
2189
        """See BranchFormat.get_format_string()."""
2194
2190
        return "Bazaar Branch Format 8 (needs bzr 1.15)\n"
2195
2191
 
2243
2239
    def _branch_class(self):
2244
2240
        return BzrBranch7
2245
2241
 
2246
 
    def get_format_string(self):
 
2242
    @classmethod
 
2243
    def get_format_string(cls):
2247
2244
        """See BranchFormat.get_format_string()."""
2248
2245
        return "Bazaar Branch Format 7 (needs bzr 1.6)\n"
2249
2246
 
2275
2272
     - a format string
2276
2273
    """
2277
2274
 
2278
 
    def get_format_string(self):
 
2275
    @classmethod
 
2276
    def get_format_string(cls):
2279
2277
        """See BranchFormat.get_format_string()."""
2280
2278
        return "Bazaar-NG Branch Reference Format 1\n"
2281
2279
 
2341
2339
        :param possible_transports: An optional reusable transports list.
2342
2340
        """
2343
2341
        if not _found:
2344
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
 
2342
            format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2345
2343
            if format.__class__ != self.__class__:
2346
2344
                raise AssertionError("wrong format %r found for %r" %
2347
2345
                    (format, self))