← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Jelmer Vernooij
  • Date: 2012-02-20 12:19:29 UTC
  • mfrom: (6437.23.11 2.5)
  • mto: (6581.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6582.
  • Revision ID: jelmer@samba.org-20120220121929-7ni2psvjoatm1yp4
Merge bzr/2.5.

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
 
 
19
import bzrlib.bzrdir
17
20
 
18
21
from cStringIO import StringIO
19
22
 
20
23
from bzrlib.lazy_import import lazy_import
21
24
lazy_import(globals(), """
22
 
from itertools import chain
 
25
import itertools
23
26
from bzrlib import (
24
 
        bzrdir,
25
 
        cache_utf8,
26
 
        cleanup,
27
 
        config as _mod_config,
28
 
        debug,
29
 
        errors,
30
 
        fetch,
31
 
        graph as _mod_graph,
32
 
        lockdir,
33
 
        lockable_files,
34
 
        remote,
35
 
        repository,
36
 
        revision as _mod_revision,
37
 
        rio,
38
 
        transport,
39
 
        ui,
40
 
        urlutils,
41
 
        )
42
 
from bzrlib.config import BranchConfig, TransportConfig
43
 
from bzrlib.tag import (
44
 
    BasicTags,
45
 
    DisabledTags,
 
27
    bzrdir,
 
28
    controldir,
 
29
    cache_utf8,
 
30
    cleanup,
 
31
    config as _mod_config,
 
32
    debug,
 
33
    errors,
 
34
    fetch,
 
35
    graph as _mod_graph,
 
36
    lockdir,
 
37
    lockable_files,
 
38
    remote,
 
39
    repository,
 
40
    revision as _mod_revision,
 
41
    rio,
 
42
    tag as _mod_tag,
 
43
    transport,
 
44
    ui,
 
45
    urlutils,
 
46
    vf_search,
46
47
    )
 
48
from bzrlib.i18n import gettext, ngettext
47
49
""")
48
50
 
 
51
# Explicitly import bzrlib.bzrdir so that the BzrProber
 
52
# is guaranteed to be registered.
 
53
import bzrlib.bzrdir
 
54
 
49
55
from bzrlib import (
 
56
    bzrdir,
50
57
    controldir,
51
58
    )
52
59
from bzrlib.decorators import (
87
94
    def user_transport(self):
88
95
        return self.bzrdir.user_transport
89
96
 
90
 
    def __init__(self, *ignored, **ignored_too):
 
97
    def __init__(self, possible_transports=None):
91
98
        self.tags = self._format.make_tags(self)
92
99
        self._revision_history_cache = None
93
100
        self._revision_id_to_revno_cache = None
97
104
        self._last_revision_info_cache = None
98
105
        self._master_branch_cache = None
99
106
        self._merge_sorted_revisions_cache = None
100
 
        self._open_hook()
 
107
        self._open_hook(possible_transports)
101
108
        hooks = Branch.hooks['open']
102
109
        for hook in hooks:
103
110
            hook(self)
104
111
 
105
 
    def _open_hook(self):
 
112
    def _open_hook(self, possible_transports):
106
113
        """Called by init to allow simpler extension of the base class."""
107
114
 
108
 
    def _activate_fallback_location(self, url):
 
115
    def _activate_fallback_location(self, url, possible_transports):
109
116
        """Activate the branch/repository from url as a fallback repository."""
110
117
        for existing_fallback_repo in self.repository._fallback_repositories:
111
118
            if existing_fallback_repo.user_url == url:
112
119
                # This fallback is already configured.  This probably only
113
 
                # happens because BzrDir.sprout is a horrible mess.  To avoid
 
120
                # happens because ControlDir.sprout is a horrible mess.  To avoid
114
121
                # confusing _unstack we don't add this a second time.
115
122
                mutter('duplicate activation of fallback %r on %r', url, self)
116
123
                return
117
 
        repo = self._get_fallback_repository(url)
 
124
        repo = self._get_fallback_repository(url, possible_transports)
118
125
        if repo.has_same_location(self.repository):
119
126
            raise errors.UnstackableLocationError(self.user_url, url)
120
127
        self.repository.add_fallback_repository(repo)
174
181
        For instance, if the branch is at URL/.bzr/branch,
175
182
        Branch.open(URL) -> a Branch instance.
176
183
        """
177
 
        control = bzrdir.BzrDir.open(base, _unsupported,
178
 
                                     possible_transports=possible_transports)
179
 
        return control.open_branch(unsupported=_unsupported)
 
184
        control = controldir.ControlDir.open(base,
 
185
            possible_transports=possible_transports, _unsupported=_unsupported)
 
186
        return control.open_branch(unsupported=_unsupported,
 
187
            possible_transports=possible_transports)
180
188
 
181
189
    @staticmethod
182
 
    def open_from_transport(transport, name=None, _unsupported=False):
 
190
    def open_from_transport(transport, name=None, _unsupported=False,
 
191
            possible_transports=None):
183
192
        """Open the branch rooted at transport"""
184
 
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
185
 
        return control.open_branch(name=name, unsupported=_unsupported)
 
193
        control = controldir.ControlDir.open_from_transport(transport, _unsupported)
 
194
        return control.open_branch(name=name, unsupported=_unsupported,
 
195
            possible_transports=possible_transports)
186
196
 
187
197
    @staticmethod
188
198
    def open_containing(url, possible_transports=None):
196
206
        format, UnknownFormatError or UnsupportedFormatError are raised.
197
207
        If there is one, it is returned, along with the unused portion of url.
198
208
        """
199
 
        control, relpath = bzrdir.BzrDir.open_containing(url,
 
209
        control, relpath = controldir.ControlDir.open_containing(url,
200
210
                                                         possible_transports)
201
 
        return control.open_branch(), relpath
 
211
        branch = control.open_branch(possible_transports=possible_transports)
 
212
        return (branch, relpath)
202
213
 
203
214
    def _push_should_merge_tags(self):
204
215
        """Should _basic_push merge this branch's tags into the target?
216
227
 
217
228
        :return: A bzrlib.config.BranchConfig.
218
229
        """
219
 
        return BranchConfig(self)
 
230
        return _mod_config.BranchConfig(self)
 
231
 
 
232
    def get_config_stack(self):
 
233
        """Get a bzrlib.config.BranchStack for this Branch.
 
234
 
 
235
        This can then be used to get and set configuration options for the
 
236
        branch.
 
237
 
 
238
        :return: A bzrlib.config.BranchStack.
 
239
        """
 
240
        return _mod_config.BranchStack(self)
220
241
 
221
242
    def _get_config(self):
222
243
        """Get the concrete config for just the config in this branch.
230
251
        """
231
252
        raise NotImplementedError(self._get_config)
232
253
 
233
 
    def _get_fallback_repository(self, url):
 
254
    def _get_fallback_repository(self, url, possible_transports):
234
255
        """Get the repository we fallback to at url."""
235
256
        url = urlutils.join(self.base, url)
236
 
        a_branch = Branch.open(url,
237
 
            possible_transports=[self.bzrdir.root_transport])
 
257
        a_branch = Branch.open(url, possible_transports=possible_transports)
238
258
        return a_branch.repository
239
259
 
240
260
    @needs_read_lock
514
534
                    # The decision to include the start or not
515
535
                    # depends on the stop_rule if a stop is provided
516
536
                    # so pop this node back into the iterator
517
 
                    rev_iter = chain(iter([node]), rev_iter)
 
537
                    rev_iter = itertools.chain(iter([node]), rev_iter)
518
538
                    break
519
539
        if stop_revision_id is None:
520
540
            # Yield everything
645
665
        """
646
666
        raise errors.UpgradeRequired(self.user_url)
647
667
 
 
668
    def get_append_revisions_only(self):
 
669
        """Whether it is only possible to append revisions to the history.
 
670
        """
 
671
        if not self._format.supports_set_append_revisions_only():
 
672
            return False
 
673
        return self.get_config_stack().get('append_revisions_only')
 
674
 
648
675
    def set_append_revisions_only(self, enabled):
649
676
        if not self._format.supports_set_append_revisions_only():
650
677
            raise errors.UpgradeRequired(self.user_url)
651
 
        if enabled:
652
 
            value = 'True'
653
 
        else:
654
 
            value = 'False'
655
 
        self.get_config().set_user_option('append_revisions_only', value,
656
 
            warn_masked=True)
 
678
        self.get_config_stack().set('append_revisions_only', enabled)
657
679
 
658
680
    def set_reference_info(self, file_id, tree_path, branch_location):
659
681
        """Set the branch location to use for a tree reference."""
688
710
        """
689
711
        raise errors.UpgradeRequired(self.user_url)
690
712
 
691
 
    def get_commit_builder(self, parents, config=None, timestamp=None,
 
713
    def get_commit_builder(self, parents, config_stack=None, timestamp=None,
692
714
                           timezone=None, committer=None, revprops=None,
693
715
                           revision_id=None, lossy=False):
694
716
        """Obtain a CommitBuilder for this branch.
704
726
            represented, when pushing to a foreign VCS 
705
727
        """
706
728
 
707
 
        if config is None:
708
 
            config = self.get_config()
 
729
        if config_stack is None:
 
730
            config_stack = self.get_config_stack()
709
731
 
710
 
        return self.repository.get_commit_builder(self, parents, config,
 
732
        return self.repository.get_commit_builder(self, parents, config_stack,
711
733
            timestamp, timezone, committer, revprops, revision_id,
712
734
            lossy)
713
735
 
718
740
        """
719
741
        return None
720
742
 
 
743
    @deprecated_method(deprecated_in((2, 5, 0)))
721
744
    def get_revision_delta(self, revno):
722
745
        """Return the delta for one revision.
723
746
 
724
747
        The delta is relative to its mainline predecessor, or the
725
748
        empty tree for revision 1.
726
749
        """
727
 
        rh = self.revision_history()
728
 
        if not (1 <= revno <= len(rh)):
 
750
        try:
 
751
            revid = self.get_rev_id(revno)
 
752
        except errors.NoSuchRevision:
729
753
            raise errors.InvalidRevisionNumber(revno)
730
 
        return self.repository.get_revision_delta(rh[revno-1])
 
754
        return self.repository.get_revision_delta(revid)
731
755
 
732
756
    def get_stacked_on_url(self):
733
757
        """Get the URL this branch is stacked against.
832
856
                return
833
857
            self._unstack()
834
858
        else:
835
 
            self._activate_fallback_location(url)
 
859
            self._activate_fallback_location(url,
 
860
                possible_transports=[self.bzrdir.root_transport])
836
861
        # write this out after the repository is stacked to avoid setting a
837
862
        # stacked config that doesn't work.
838
863
        self._set_config_location('stacked_on_location', url)
844
869
        """
845
870
        pb = ui.ui_factory.nested_progress_bar()
846
871
        try:
847
 
            pb.update("Unstacking")
 
872
            pb.update(gettext("Unstacking"))
848
873
            # The basic approach here is to fetch the tip of the branch,
849
874
            # including all available ghosts, from the existing stacked
850
875
            # repository into a new repository object without the fallbacks. 
864
889
            # stream from one of them to the other.  This does mean doing
865
890
            # separate SSH connection setup, but unstacking is not a
866
891
            # common operation so it's tolerable.
867
 
            new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
 
892
            new_bzrdir = controldir.ControlDir.open(
 
893
                self.bzrdir.root_transport.base)
868
894
            new_repository = new_bzrdir.find_repository()
869
895
            if new_repository._fallback_repositories:
870
896
                raise AssertionError("didn't expect %r to have "
913
939
                    tags_to_fetch = set(self.tags.get_reverse_tag_dict())
914
940
                except errors.TagsNotSupported:
915
941
                    tags_to_fetch = set()
916
 
                fetch_spec = _mod_graph.NotInOtherForRevs(self.repository,
 
942
                fetch_spec = vf_search.NotInOtherForRevs(self.repository,
917
943
                    old_repository, required_ids=[self.last_revision()],
918
944
                    if_present_ids=tags_to_fetch, find_ghosts=True).execute()
919
945
                self.repository.fetch(old_repository, fetch_spec=fetch_spec)
987
1013
        """
988
1014
        raise NotImplementedError(self._gen_revision_history)
989
1015
 
 
1016
    @deprecated_method(deprecated_in((2, 5, 0)))
990
1017
    @needs_read_lock
991
1018
    def revision_history(self):
992
1019
        """Return sequence of revision ids on this branch.
994
1021
        This method will cache the revision history for as long as it is safe to
995
1022
        do so.
996
1023
        """
 
1024
        return self._revision_history()
 
1025
 
 
1026
    def _revision_history(self):
997
1027
        if 'evil' in debug.debug_flags:
998
1028
            mutter_callsite(3, "revision_history scales with history.")
999
1029
        if self._revision_history_cache is not None:
1069
1099
        """Given a revision id, return its revno"""
1070
1100
        if _mod_revision.is_null(revision_id):
1071
1101
            return 0
1072
 
        history = self.revision_history()
 
1102
        history = self._revision_history()
1073
1103
        try:
1074
1104
            return history.index(revision_id) + 1
1075
1105
        except ValueError:
1140
1170
    def _set_config_location(self, name, url, config=None,
1141
1171
                             make_relative=False):
1142
1172
        if config is None:
1143
 
            config = self.get_config()
 
1173
            config = self.get_config_stack()
1144
1174
        if url is None:
1145
1175
            url = ''
1146
1176
        elif make_relative:
1147
1177
            url = urlutils.relative_url(self.base, url)
1148
 
        config.set_user_option(name, url, warn_masked=True)
 
1178
        config.set(name, url)
1149
1179
 
1150
1180
    def _get_config_location(self, name, config=None):
1151
1181
        if config is None:
1152
 
            config = self.get_config()
1153
 
        location = config.get_user_option(name)
 
1182
            config = self.get_config_stack()
 
1183
        location = config.get(name)
1154
1184
        if location == '':
1155
1185
            location = None
1156
1186
        return location
1157
1187
 
1158
1188
    def get_child_submit_format(self):
1159
1189
        """Return the preferred format of submissions to this branch."""
1160
 
        return self.get_config().get_user_option("child_submit_format")
 
1190
        return self.get_config_stack().get('child_submit_format')
1161
1191
 
1162
1192
    def get_submit_branch(self):
1163
1193
        """Return the submit location of the branch.
1166
1196
        pattern is that the user can override it by specifying a
1167
1197
        location.
1168
1198
        """
1169
 
        return self.get_config().get_user_option('submit_branch')
 
1199
        return self.get_config_stack().get('submit_branch')
1170
1200
 
1171
1201
    def set_submit_branch(self, location):
1172
1202
        """Return the submit location of the branch.
1175
1205
        pattern is that the user can override it by specifying a
1176
1206
        location.
1177
1207
        """
1178
 
        self.get_config().set_user_option('submit_branch', location,
1179
 
            warn_masked=True)
 
1208
        self.get_config_stack().set('submit_branch', location)
1180
1209
 
1181
1210
    def get_public_branch(self):
1182
1211
        """Return the public location of the branch.
1195
1224
        self._set_config_location('public_branch', location)
1196
1225
 
1197
1226
    def get_push_location(self):
1198
 
        """Return the None or the location to push this branch to."""
1199
 
        push_loc = self.get_config().get_user_option('push_location')
1200
 
        return push_loc
 
1227
        """Return None or the location to push this branch to."""
 
1228
        return self.get_config_stack().get('push_location')
1201
1229
 
1202
1230
    def set_push_location(self, location):
1203
1231
        """Set a new push location for this branch."""
1372
1400
        # TODO: We should probably also check that self.revision_history
1373
1401
        # matches the repository for older branch formats.
1374
1402
        # If looking for the code that cross-checks repository parents against
1375
 
        # the iter_reverse_revision_history output, that is now a repository
 
1403
        # the Graph.iter_lefthand_ancestry output, that is now a repository
1376
1404
        # specific check.
1377
1405
        return result
1378
1406
 
1379
 
    def _get_checkout_format(self):
 
1407
    def _get_checkout_format(self, lightweight=False):
1380
1408
        """Return the most suitable metadir for a checkout of this branch.
1381
1409
        Weaves are used if this branch's repository uses weaves.
1382
1410
        """
1428
1456
        """
1429
1457
        t = transport.get_transport(to_location)
1430
1458
        t.ensure_base()
 
1459
        format = self._get_checkout_format(lightweight=lightweight)
 
1460
        try:
 
1461
            checkout = format.initialize_on_transport(t)
 
1462
        except errors.AlreadyControlDirError:
 
1463
            # It's fine if the control directory already exists,
 
1464
            # as long as there is no existing branch and working tree.
 
1465
            checkout = controldir.ControlDir.open_from_transport(t)
 
1466
            try:
 
1467
                checkout.open_branch()
 
1468
            except errors.NotBranchError:
 
1469
                pass
 
1470
            else:
 
1471
                raise errors.AlreadyControlDirError(t.base)
 
1472
            if checkout.control_transport.base == self.bzrdir.control_transport.base:
 
1473
                # When checking out to the same control directory,
 
1474
                # always create a lightweight checkout
 
1475
                lightweight = True
 
1476
 
1431
1477
        if lightweight:
1432
 
            format = self._get_checkout_format()
1433
 
            checkout = format.initialize_on_transport(t)
1434
 
            from_branch = BranchReferenceFormat().initialize(checkout, 
1435
 
                target_branch=self)
 
1478
            from_branch = checkout.set_branch_reference(target_branch=self)
1436
1479
        else:
1437
 
            format = self._get_checkout_format()
1438
 
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1439
 
                to_location, force_new_tree=False, format=format)
1440
 
            checkout = checkout_branch.bzrdir
 
1480
            policy = checkout.determine_repository_policy()
 
1481
            repo = policy.acquire_repository()[0]
 
1482
            checkout_branch = checkout.create_branch()
1441
1483
            checkout_branch.bind(self)
1442
1484
            # pull up to the specified revision_id to set the initial
1443
1485
            # branch tip correctly, and seed it with history.
1444
1486
            checkout_branch.pull(self, stop_revision=revision_id)
1445
 
            from_branch=None
 
1487
            from_branch = None
1446
1488
        tree = checkout.create_workingtree(revision_id,
1447
1489
                                           from_branch=from_branch,
1448
1490
                                           accelerator_tree=accelerator_tree,
1537
1579
            heads that must be fetched if present, but no error is necessary if
1538
1580
            they are not present.
1539
1581
        """
1540
 
        # For bzr native formats must_fetch is just the tip, and if_present_fetch
1541
 
        # are the tags.
 
1582
        # For bzr native formats must_fetch is just the tip, and
 
1583
        # if_present_fetch are the tags.
1542
1584
        must_fetch = set([self.last_revision()])
1543
1585
        if_present_fetch = set()
1544
 
        c = self.get_config()
1545
 
        include_tags = c.get_user_option_as_bool('branch.fetch_tags',
1546
 
                                                 default=False)
1547
 
        if include_tags:
 
1586
        if self.get_config_stack().get('branch.fetch_tags'):
1548
1587
            try:
1549
1588
                if_present_fetch = set(self.tags.get_reverse_tag_dict())
1550
1589
            except errors.TagsNotSupported:
1559
1598
 
1560
1599
    Formats provide three things:
1561
1600
     * An initialization routine,
1562
 
     * a format string,
 
1601
     * a format description
1563
1602
     * an open routine.
1564
1603
 
1565
1604
    Formats are placed in an dict by their format string for reference
1572
1611
    object will be created every time regardless.
1573
1612
    """
1574
1613
 
1575
 
    can_set_append_revisions_only = True
1576
 
 
1577
1614
    def __eq__(self, other):
1578
1615
        return self.__class__ is other.__class__
1579
1616
 
1581
1618
        return not (self == other)
1582
1619
 
1583
1620
    @classmethod
1584
 
    def find_format(klass, a_bzrdir, name=None):
1585
 
        """Return the format for the branch object in a_bzrdir."""
1586
 
        try:
1587
 
            transport = a_bzrdir.get_branch_transport(None, name=name)
1588
 
            format_string = transport.get_bytes("format")
1589
 
            return format_registry.get(format_string)
1590
 
        except errors.NoSuchFile:
1591
 
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1592
 
        except KeyError:
1593
 
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1594
 
 
1595
 
    @classmethod
1596
1621
    @deprecated_method(deprecated_in((2, 4, 0)))
1597
1622
    def get_default_format(klass):
1598
1623
        """Return the current default format."""
1608
1633
        """
1609
1634
        return format_registry._get_all()
1610
1635
 
1611
 
    def get_reference(self, a_bzrdir, name=None):
1612
 
        """Get the target reference of the branch in a_bzrdir.
 
1636
    def get_reference(self, controldir, name=None):
 
1637
        """Get the target reference of the branch in controldir.
1613
1638
 
1614
1639
        format probing must have been completed before calling
1615
1640
        this method - it is assumed that the format of the branch
1616
 
        in a_bzrdir is correct.
 
1641
        in controldir is correct.
1617
1642
 
1618
 
        :param a_bzrdir: The bzrdir to get the branch data from.
 
1643
        :param controldir: The controldir to get the branch data from.
1619
1644
        :param name: Name of the colocated branch to fetch
1620
1645
        :return: None if the branch is not a reference branch.
1621
1646
        """
1622
1647
        return None
1623
1648
 
1624
1649
    @classmethod
1625
 
    def set_reference(self, a_bzrdir, name, to_branch):
1626
 
        """Set the target reference of the branch in a_bzrdir.
 
1650
    def set_reference(self, controldir, name, to_branch):
 
1651
        """Set the target reference of the branch in controldir.
1627
1652
 
1628
1653
        format probing must have been completed before calling
1629
1654
        this method - it is assumed that the format of the branch
1630
 
        in a_bzrdir is correct.
 
1655
        in controldir is correct.
1631
1656
 
1632
 
        :param a_bzrdir: The bzrdir to set the branch reference for.
 
1657
        :param controldir: The controldir to set the branch reference for.
1633
1658
        :param name: Name of colocated branch to set, None for default
1634
1659
        :param to_branch: branch that the checkout is to reference
1635
1660
        """
1636
1661
        raise NotImplementedError(self.set_reference)
1637
1662
 
1638
 
    def get_format_string(self):
1639
 
        """Return the ASCII format string that identifies this format."""
1640
 
        raise NotImplementedError(self.get_format_string)
1641
 
 
1642
1663
    def get_format_description(self):
1643
1664
        """Return the short format description for this format."""
1644
1665
        raise NotImplementedError(self.get_format_description)
1645
1666
 
1646
 
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
 
1667
    def _run_post_branch_init_hooks(self, controldir, name, branch):
1647
1668
        hooks = Branch.hooks['post_branch_init']
1648
1669
        if not hooks:
1649
1670
            return
1650
 
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
 
1671
        params = BranchInitHookParams(self, controldir, name, branch)
1651
1672
        for hook in hooks:
1652
1673
            hook(params)
1653
1674
 
1654
 
    def initialize(self, a_bzrdir, name=None, repository=None):
1655
 
        """Create a branch of this format in a_bzrdir.
1656
 
        
 
1675
    def initialize(self, controldir, name=None, repository=None,
 
1676
                   append_revisions_only=None):
 
1677
        """Create a branch of this format in controldir.
 
1678
 
1657
1679
        :param name: Name of the colocated branch to create.
1658
1680
        """
1659
1681
        raise NotImplementedError(self.initialize)
1679
1701
        Note that it is normal for branch to be a RemoteBranch when using tags
1680
1702
        on a RemoteBranch.
1681
1703
        """
1682
 
        return DisabledTags(branch)
 
1704
        return _mod_tag.DisabledTags(branch)
1683
1705
 
1684
1706
    def network_name(self):
1685
1707
        """A simple byte string uniquely identifying this format for RPC calls.
1691
1713
        """
1692
1714
        raise NotImplementedError(self.network_name)
1693
1715
 
1694
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
1695
 
            found_repository=None):
1696
 
        """Return the branch object for a_bzrdir
 
1716
    def open(self, controldir, name=None, _found=False, ignore_fallbacks=False,
 
1717
            found_repository=None, possible_transports=None):
 
1718
        """Return the branch object for controldir.
1697
1719
 
1698
 
        :param a_bzrdir: A BzrDir that contains a branch.
 
1720
        :param controldir: A ControlDir that contains a branch.
1699
1721
        :param name: Name of colocated branch to open
1700
1722
        :param _found: a private parameter, do not use it. It is used to
1701
1723
            indicate if format probing has already be done.
1743
1765
        """True if this format supports tags stored in the branch"""
1744
1766
        return False  # by default
1745
1767
 
 
1768
    def tags_are_versioned(self):
 
1769
        """Whether the tag container for this branch versions tags."""
 
1770
        return False
 
1771
 
 
1772
    def supports_tags_referencing_ghosts(self):
 
1773
        """True if tags can reference ghost revisions."""
 
1774
        return True
 
1775
 
1746
1776
 
1747
1777
class MetaDirBranchFormatFactory(registry._LazyObjectGetter):
1748
1778
    """A factory for a BranchFormat object, permitting simple lazy registration.
1762
1792
        """
1763
1793
        registry._LazyObjectGetter.__init__(self, module_name, member_name)
1764
1794
        self._format_string = format_string
1765
 
        
 
1795
 
1766
1796
    def get_format_string(self):
1767
1797
        """See BranchFormat.get_format_string."""
1768
1798
        return self._format_string
1913
1943
    There are 4 fields that hooks may wish to access:
1914
1944
 
1915
1945
    :ivar format: the branch format
1916
 
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
 
1946
    :ivar bzrdir: the ControlDir where the branch will be/has been initialized
1917
1947
    :ivar name: name of colocated branch, if any (or None)
1918
1948
    :ivar branch: the branch created
1919
1949
 
1922
1952
    branch, which refer to the original branch.
1923
1953
    """
1924
1954
 
1925
 
    def __init__(self, format, a_bzrdir, name, branch):
 
1955
    def __init__(self, format, controldir, name, branch):
1926
1956
        """Create a group of BranchInitHook parameters.
1927
1957
 
1928
1958
        :param format: the branch format
1929
 
        :param a_bzrdir: the BzrDir where the branch will be/has been
 
1959
        :param controldir: the ControlDir where the branch will be/has been
1930
1960
            initialized
1931
1961
        :param name: name of colocated branch, if any (or None)
1932
1962
        :param branch: the branch created
1936
1966
        in branch, which refer to the original branch.
1937
1967
        """
1938
1968
        self.format = format
1939
 
        self.bzrdir = a_bzrdir
 
1969
        self.bzrdir = controldir
1940
1970
        self.name = name
1941
1971
        self.branch = branch
1942
1972
 
1952
1982
 
1953
1983
    There are 4 fields that hooks may wish to access:
1954
1984
 
1955
 
    :ivar control_dir: BzrDir of the checkout to change
 
1985
    :ivar control_dir: ControlDir of the checkout to change
1956
1986
    :ivar to_branch: branch that the checkout is to reference
1957
1987
    :ivar force: skip the check for local commits in a heavy checkout
1958
1988
    :ivar revision_id: revision ID to switch to (or None)
1961
1991
    def __init__(self, control_dir, to_branch, force, revision_id):
1962
1992
        """Create a group of SwitchHook parameters.
1963
1993
 
1964
 
        :param control_dir: BzrDir of the checkout to change
 
1994
        :param control_dir: ControlDir of the checkout to change
1965
1995
        :param to_branch: branch that the checkout is to reference
1966
1996
        :param force: skip the check for local commits in a heavy checkout
1967
1997
        :param revision_id: revision ID to switch to (or None)
1980
2010
            self.revision_id)
1981
2011
 
1982
2012
 
1983
 
class BranchFormatMetadir(BranchFormat):
1984
 
    """Common logic for meta-dir based branch formats."""
 
2013
class BranchFormatMetadir(bzrdir.BzrFormat, BranchFormat):
 
2014
    """Base class for branch formats that live in meta directories.
 
2015
    """
 
2016
 
 
2017
    def __init__(self):
 
2018
        BranchFormat.__init__(self)
 
2019
        bzrdir.BzrFormat.__init__(self)
 
2020
 
 
2021
    @classmethod
 
2022
    def find_format(klass, controldir, name=None):
 
2023
        """Return the format for the branch object in controldir."""
 
2024
        try:
 
2025
            transport = controldir.get_branch_transport(None, name=name)
 
2026
        except errors.NoSuchFile:
 
2027
            raise errors.NotBranchError(path=name, bzrdir=controldir)
 
2028
        try:
 
2029
            format_string = transport.get_bytes("format")
 
2030
        except errors.NoSuchFile:
 
2031
            raise errors.NotBranchError(path=transport.base, bzrdir=controldir)
 
2032
        return klass._find_format(format_registry, 'branch', format_string)
1985
2033
 
1986
2034
    def _branch_class(self):
1987
2035
        """What class to instantiate on open calls."""
1988
2036
        raise NotImplementedError(self._branch_class)
1989
2037
 
 
2038
    def _get_initial_config(self, append_revisions_only=None):
 
2039
        if append_revisions_only:
 
2040
            return "append_revisions_only = True\n"
 
2041
        else:
 
2042
            # Avoid writing anything if append_revisions_only is disabled,
 
2043
            # as that is the default.
 
2044
            return ""
 
2045
 
1990
2046
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1991
2047
                           repository=None):
1992
2048
        """Initialize a branch in a bzrdir, with specified files
1997
2053
        :param name: Name of colocated branch to create, if any
1998
2054
        :return: a branch in this format
1999
2055
        """
 
2056
        if name is None:
 
2057
            name = a_bzrdir._get_selected_branch()
2000
2058
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
2001
2059
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2002
2060
        control_files = lockable_files.LockableFiles(branch_transport,
2004
2062
        control_files.create_lock()
2005
2063
        control_files.lock_write()
2006
2064
        try:
2007
 
            utf8_files += [('format', self.get_format_string())]
 
2065
            utf8_files += [('format', self.as_string())]
2008
2066
            for (filename, content) in utf8_files:
2009
2067
                branch_transport.put_bytes(
2010
2068
                    filename, content,
2016
2074
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2017
2075
        return branch
2018
2076
 
2019
 
    def network_name(self):
2020
 
        """A simple byte string uniquely identifying this format for RPC calls.
2021
 
 
2022
 
        Metadir branch formats use their format string.
2023
 
        """
2024
 
        return self.get_format_string()
2025
 
 
2026
2077
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False,
2027
 
            found_repository=None):
 
2078
            found_repository=None, possible_transports=None):
2028
2079
        """See BranchFormat.open()."""
 
2080
        if name is None:
 
2081
            name = a_bzrdir._get_selected_branch()
2029
2082
        if not _found:
2030
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
 
2083
            format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2031
2084
            if format.__class__ != self.__class__:
2032
2085
                raise AssertionError("wrong format %r found for %r" %
2033
2086
                    (format, self))
2042
2095
                              name=name,
2043
2096
                              a_bzrdir=a_bzrdir,
2044
2097
                              _repository=found_repository,
2045
 
                              ignore_fallbacks=ignore_fallbacks)
 
2098
                              ignore_fallbacks=ignore_fallbacks,
 
2099
                              possible_transports=possible_transports)
2046
2100
        except errors.NoSuchFile:
2047
2101
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
2048
2102
 
2049
 
    def __init__(self):
2050
 
        super(BranchFormatMetadir, self).__init__()
2051
 
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2052
 
        self._matchingbzrdir.set_branch_format(self)
 
2103
    @property
 
2104
    def _matchingbzrdir(self):
 
2105
        ret = bzrdir.BzrDirMetaFormat1()
 
2106
        ret.set_branch_format(self)
 
2107
        return ret
2053
2108
 
2054
2109
    def supports_tags(self):
2055
2110
        return True
2057
2112
    def supports_leaving_lock(self):
2058
2113
        return True
2059
2114
 
 
2115
    def check_support_status(self, allow_unsupported, recommend_upgrade=True,
 
2116
            basedir=None):
 
2117
        BranchFormat.check_support_status(self,
 
2118
            allow_unsupported=allow_unsupported, recommend_upgrade=recommend_upgrade,
 
2119
            basedir=basedir)
 
2120
        bzrdir.BzrFormat.check_support_status(self, allow_unsupported=allow_unsupported,
 
2121
            recommend_upgrade=recommend_upgrade, basedir=basedir)
 
2122
 
2060
2123
 
2061
2124
class BzrBranchFormat5(BranchFormatMetadir):
2062
2125
    """Bzr branch format 5.
2074
2137
    def _branch_class(self):
2075
2138
        return BzrBranch5
2076
2139
 
2077
 
    def get_format_string(self):
 
2140
    @classmethod
 
2141
    def get_format_string(cls):
2078
2142
        """See BranchFormat.get_format_string()."""
2079
2143
        return "Bazaar-NG branch format 5\n"
2080
2144
 
2082
2146
        """See BranchFormat.get_format_description()."""
2083
2147
        return "Branch format 5"
2084
2148
 
2085
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
2149
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2150
                   append_revisions_only=None):
2086
2151
        """Create a branch of this format in a_bzrdir."""
 
2152
        if append_revisions_only:
 
2153
            raise errors.UpgradeRequired(a_bzrdir.user_url)
2087
2154
        utf8_files = [('revision-history', ''),
2088
2155
                      ('branch-name', ''),
2089
2156
                      ]
2107
2174
    def _branch_class(self):
2108
2175
        return BzrBranch6
2109
2176
 
2110
 
    def get_format_string(self):
 
2177
    @classmethod
 
2178
    def get_format_string(cls):
2111
2179
        """See BranchFormat.get_format_string()."""
2112
2180
        return "Bazaar Branch Format 6 (bzr 0.15)\n"
2113
2181
 
2115
2183
        """See BranchFormat.get_format_description()."""
2116
2184
        return "Branch format 6"
2117
2185
 
2118
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
2186
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2187
                   append_revisions_only=None):
2119
2188
        """Create a branch of this format in a_bzrdir."""
2120
2189
        utf8_files = [('last-revision', '0 null:\n'),
2121
 
                      ('branch.conf', ''),
 
2190
                      ('branch.conf',
 
2191
                          self._get_initial_config(append_revisions_only)),
2122
2192
                      ('tags', ''),
2123
2193
                      ]
2124
2194
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2125
2195
 
2126
2196
    def make_tags(self, branch):
2127
2197
        """See bzrlib.branch.BranchFormat.make_tags()."""
2128
 
        return BasicTags(branch)
 
2198
        return _mod_tag.BasicTags(branch)
2129
2199
 
2130
2200
    def supports_set_append_revisions_only(self):
2131
2201
        return True
2137
2207
    def _branch_class(self):
2138
2208
        return BzrBranch8
2139
2209
 
2140
 
    def get_format_string(self):
 
2210
    @classmethod
 
2211
    def get_format_string(cls):
2141
2212
        """See BranchFormat.get_format_string()."""
2142
2213
        return "Bazaar Branch Format 8 (needs bzr 1.15)\n"
2143
2214
 
2145
2216
        """See BranchFormat.get_format_description()."""
2146
2217
        return "Branch format 8"
2147
2218
 
2148
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
2219
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2220
                   append_revisions_only=None):
2149
2221
        """Create a branch of this format in a_bzrdir."""
2150
2222
        utf8_files = [('last-revision', '0 null:\n'),
2151
 
                      ('branch.conf', ''),
 
2223
                      ('branch.conf',
 
2224
                          self._get_initial_config(append_revisions_only)),
2152
2225
                      ('tags', ''),
2153
2226
                      ('references', '')
2154
2227
                      ]
2156
2229
 
2157
2230
    def make_tags(self, branch):
2158
2231
        """See bzrlib.branch.BranchFormat.make_tags()."""
2159
 
        return BasicTags(branch)
 
2232
        return _mod_tag.BasicTags(branch)
2160
2233
 
2161
2234
    def supports_set_append_revisions_only(self):
2162
2235
        return True
2176
2249
    This format was introduced in bzr 1.6.
2177
2250
    """
2178
2251
 
2179
 
    def initialize(self, a_bzrdir, name=None, repository=None):
 
2252
    def initialize(self, a_bzrdir, name=None, repository=None,
 
2253
                   append_revisions_only=None):
2180
2254
        """Create a branch of this format in a_bzrdir."""
2181
2255
        utf8_files = [('last-revision', '0 null:\n'),
2182
 
                      ('branch.conf', ''),
 
2256
                      ('branch.conf',
 
2257
                          self._get_initial_config(append_revisions_only)),
2183
2258
                      ('tags', ''),
2184
2259
                      ]
2185
2260
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2187
2262
    def _branch_class(self):
2188
2263
        return BzrBranch7
2189
2264
 
2190
 
    def get_format_string(self):
 
2265
    @classmethod
 
2266
    def get_format_string(cls):
2191
2267
        """See BranchFormat.get_format_string()."""
2192
2268
        return "Bazaar Branch Format 7 (needs bzr 1.6)\n"
2193
2269
 
2203
2279
 
2204
2280
    def make_tags(self, branch):
2205
2281
        """See bzrlib.branch.BranchFormat.make_tags()."""
2206
 
        return BasicTags(branch)
 
2282
        return _mod_tag.BasicTags(branch)
2207
2283
 
2208
2284
    supports_reference_locations = False
2209
2285
 
2210
2286
 
2211
 
class BranchReferenceFormat(BranchFormat):
 
2287
class BranchReferenceFormat(BranchFormatMetadir):
2212
2288
    """Bzr branch reference format.
2213
2289
 
2214
2290
    Branch references are used in implementing checkouts, they
2219
2295
     - a format string
2220
2296
    """
2221
2297
 
2222
 
    def get_format_string(self):
 
2298
    @classmethod
 
2299
    def get_format_string(cls):
2223
2300
        """See BranchFormat.get_format_string()."""
2224
2301
        return "Bazaar-NG Branch Reference Format 1\n"
2225
2302
 
2238
2315
        location = transport.put_bytes('location', to_branch.base)
2239
2316
 
2240
2317
    def initialize(self, a_bzrdir, name=None, target_branch=None,
2241
 
            repository=None):
 
2318
            repository=None, append_revisions_only=None):
2242
2319
        """Create a branch of this format in a_bzrdir."""
2243
2320
        if target_branch is None:
2244
2321
            # this format does not implement branch itself, thus the implicit
2247
2324
        mutter('creating branch reference in %s', a_bzrdir.user_url)
2248
2325
        if a_bzrdir._format.fixed_components:
2249
2326
            raise errors.IncompatibleFormat(self, a_bzrdir._format)
 
2327
        if name is None:
 
2328
            name = a_bzrdir._get_selected_branch()
2250
2329
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
2251
2330
        branch_transport.put_bytes('location',
2252
 
            target_branch.bzrdir.user_url)
2253
 
        branch_transport.put_bytes('format', self.get_format_string())
2254
 
        branch = self.open(
2255
 
            a_bzrdir, name, _found=True,
 
2331
            target_branch.user_url)
 
2332
        branch_transport.put_bytes('format', self.as_string())
 
2333
        branch = self.open(a_bzrdir, name, _found=True,
2256
2334
            possible_transports=[target_branch.bzrdir.root_transport])
2257
2335
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2258
2336
        return branch
2259
2337
 
2260
 
    def __init__(self):
2261
 
        super(BranchReferenceFormat, self).__init__()
2262
 
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2263
 
        self._matchingbzrdir.set_branch_format(self)
2264
 
 
2265
2338
    def _make_reference_clone_function(format, a_branch):
2266
2339
        """Create a clone() routine for a branch dynamically."""
2267
2340
        def clone(to_bzrdir, revision_id=None,
2289
2362
            a_bzrdir.
2290
2363
        :param possible_transports: An optional reusable transports list.
2291
2364
        """
 
2365
        if name is None:
 
2366
            name = a_bzrdir._get_selected_branch()
2292
2367
        if not _found:
2293
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
 
2368
            format = BranchFormatMetadir.find_format(a_bzrdir, name=name)
2294
2369
            if format.__class__ != self.__class__:
2295
2370
                raise AssertionError("wrong format %r found for %r" %
2296
2371
                    (format, self))
2297
2372
        if location is None:
2298
2373
            location = self.get_reference(a_bzrdir, name)
2299
 
        real_bzrdir = bzrdir.BzrDir.open(
 
2374
        real_bzrdir = controldir.ControlDir.open(
2300
2375
            location, possible_transports=possible_transports)
2301
 
        result = real_bzrdir.open_branch(name=name, 
2302
 
            ignore_fallbacks=ignore_fallbacks)
 
2376
        result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks,
 
2377
            possible_transports=possible_transports)
2303
2378
        # this changes the behaviour of result.clone to create a new reference
2304
2379
        # rather than a copy of the content of the branch.
2305
2380
        # I did not use a proxy object because that needs much more extensive
2386
2461
 
2387
2462
    def __init__(self, _format=None,
2388
2463
                 _control_files=None, a_bzrdir=None, name=None,
2389
 
                 _repository=None, ignore_fallbacks=False):
 
2464
                 _repository=None, ignore_fallbacks=False,
 
2465
                 possible_transports=None):
2390
2466
        """Create new branch object at a particular location."""
2391
2467
        if a_bzrdir is None:
2392
2468
            raise ValueError('a_bzrdir must be supplied')
2393
 
        else:
2394
 
            self.bzrdir = a_bzrdir
2395
 
        self._base = self.bzrdir.transport.clone('..').base
 
2469
        if name is None:
 
2470
            raise ValueError('name must be supplied')
 
2471
        self.bzrdir = a_bzrdir
 
2472
        self._user_transport = self.bzrdir.transport.clone('..')
 
2473
        if name != "":
 
2474
            self._user_transport.set_segment_parameter(
 
2475
                "branch", urlutils.escape(name))
 
2476
        self._base = self._user_transport.base
2396
2477
        self.name = name
2397
 
        # XXX: We should be able to just do
2398
 
        #   self.base = self.bzrdir.root_transport.base
2399
 
        # but this does not quite work yet -- mbp 20080522
2400
2478
        self._format = _format
2401
2479
        if _control_files is None:
2402
2480
            raise ValueError('BzrBranch _control_files is None')
2403
2481
        self.control_files = _control_files
2404
2482
        self._transport = _control_files._transport
2405
2483
        self.repository = _repository
2406
 
        Branch.__init__(self)
 
2484
        Branch.__init__(self, possible_transports)
2407
2485
 
2408
2486
    def __str__(self):
2409
 
        if self.name is None:
2410
 
            return '%s(%s)' % (self.__class__.__name__, self.user_url)
2411
 
        else:
2412
 
            return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
2413
 
                self.name)
 
2487
        return '%s(%s)' % (self.__class__.__name__, self.user_url)
2414
2488
 
2415
2489
    __repr__ = __str__
2416
2490
 
2420
2494
 
2421
2495
    base = property(_get_base, doc="The URL for the root of this branch.")
2422
2496
 
 
2497
    @property
 
2498
    def user_transport(self):
 
2499
        return self._user_transport
 
2500
 
2423
2501
    def _get_config(self):
2424
 
        return TransportConfig(self._transport, 'branch.conf')
 
2502
        return _mod_config.TransportConfig(self._transport, 'branch.conf')
 
2503
 
 
2504
    def _get_config_store(self):
 
2505
        return _mod_config.BranchStore(self)
2425
2506
 
2426
2507
    def is_locked(self):
2427
2508
        return self.control_files.is_locked()
2508
2589
            raise errors.InvalidRevisionId(revision_id=revision_id, branch=self)
2509
2590
        revision_id = _mod_revision.ensure_null(revision_id)
2510
2591
        old_revno, old_revid = self.last_revision_info()
2511
 
        if self._get_append_revisions_only():
 
2592
        if self.get_append_revisions_only():
2512
2593
            self._check_history_violation(revision_id)
2513
2594
        self._run_pre_change_branch_tip_hooks(revno, revision_id)
2514
2595
        self._write_last_revision_info(revno, revision_id)
2657
2738
        self._transport.put_bytes('last-revision', out_string,
2658
2739
            mode=self.bzrdir._get_file_mode())
2659
2740
 
 
2741
    @needs_write_lock
 
2742
    def update_feature_flags(self, updated_flags):
 
2743
        """Update the feature flags for this branch.
 
2744
 
 
2745
        :param updated_flags: Dictionary mapping feature names to necessities
 
2746
            A necessity can be None to indicate the feature should be removed
 
2747
        """
 
2748
        self._format._update_feature_flags(updated_flags)
 
2749
        self.control_transport.put_bytes('format', self._format.as_string())
 
2750
 
2660
2751
 
2661
2752
class FullHistoryBzrBranch(BzrBranch):
2662
2753
    """Bzr branch which contains the full revision history."""
2675
2766
        self._set_revision_history(history)
2676
2767
 
2677
2768
    def _read_last_revision_info(self):
2678
 
        rh = self.revision_history()
 
2769
        rh = self._revision_history()
2679
2770
        revno = len(rh)
2680
2771
        if revno:
2681
2772
            return (revno, rh[-1])
2735
2826
        if revision_id == _mod_revision.NULL_REVISION:
2736
2827
            new_history = []
2737
2828
        else:
2738
 
            new_history = self.revision_history()
 
2829
            new_history = self._revision_history()
2739
2830
        if revision_id is not None and new_history != []:
2740
2831
            try:
2741
2832
                new_history = new_history[:new_history.index(revision_id) + 1]
2769
2860
class BzrBranch8(BzrBranch):
2770
2861
    """A branch that stores tree-reference locations."""
2771
2862
 
2772
 
    def _open_hook(self):
 
2863
    def _open_hook(self, possible_transports=None):
2773
2864
        if self._ignore_fallbacks:
2774
2865
            return
 
2866
        if possible_transports is None:
 
2867
            possible_transports = [self.bzrdir.root_transport]
2775
2868
        try:
2776
2869
            url = self.get_stacked_on_url()
2777
2870
        except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2785
2878
                    raise AssertionError(
2786
2879
                        "'transform_fallback_location' hook %s returned "
2787
2880
                        "None, not a URL." % hook_name)
2788
 
            self._activate_fallback_location(url)
 
2881
            self._activate_fallback_location(url,
 
2882
                possible_transports=possible_transports)
2789
2883
 
2790
2884
    def __init__(self, *args, **kwargs):
2791
2885
        self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2909
3003
        """See Branch.set_push_location."""
2910
3004
        self._master_branch_cache = None
2911
3005
        result = None
2912
 
        config = self.get_config()
 
3006
        conf = self.get_config_stack()
2913
3007
        if location is None:
2914
 
            if config.get_user_option('bound') != 'True':
 
3008
            if not conf.get('bound'):
2915
3009
                return False
2916
3010
            else:
2917
 
                config.set_user_option('bound', 'False', warn_masked=True)
 
3011
                conf.set('bound', 'False')
2918
3012
                return True
2919
3013
        else:
2920
3014
            self._set_config_location('bound_location', location,
2921
 
                                      config=config)
2922
 
            config.set_user_option('bound', 'True', warn_masked=True)
 
3015
                                      config=conf)
 
3016
            conf.set('bound', 'True')
2923
3017
        return True
2924
3018
 
2925
3019
    def _get_bound_location(self, bound):
2926
3020
        """Return the bound location in the config file.
2927
3021
 
2928
3022
        Return None if the bound parameter does not match"""
2929
 
        config = self.get_config()
2930
 
        config_bound = (config.get_user_option('bound') == 'True')
2931
 
        if config_bound != bound:
 
3023
        conf = self.get_config_stack()
 
3024
        if conf.get('bound') != bound:
2932
3025
            return None
2933
 
        return self._get_config_location('bound_location', config=config)
 
3026
        return self._get_config_location('bound_location', config=conf)
2934
3027
 
2935
3028
    def get_bound_location(self):
2936
 
        """See Branch.set_push_location."""
 
3029
        """See Branch.get_bound_location."""
2937
3030
        return self._get_bound_location(True)
2938
3031
 
2939
3032
    def get_old_bound_location(self):
2946
3039
        ## self._check_stackable_repo()
2947
3040
        # stacked_on_location is only ever defined in branch.conf, so don't
2948
3041
        # waste effort reading the whole stack of config files.
2949
 
        config = self.get_config()._get_branch_data_config()
 
3042
        conf = _mod_config.BranchOnlyStack(self)
2950
3043
        stacked_url = self._get_config_location('stacked_on_location',
2951
 
            config=config)
 
3044
                                                config=conf)
2952
3045
        if stacked_url is None:
2953
3046
            raise errors.NotStacked(self)
2954
 
        return stacked_url
2955
 
 
2956
 
    def _get_append_revisions_only(self):
2957
 
        return self.get_config(
2958
 
            ).get_user_option_as_bool('append_revisions_only')
 
3047
        return stacked_url.encode('utf-8')
2959
3048
 
2960
3049
    @needs_read_lock
2961
3050
    def get_rev_id(self, revno, history=None):
2991
3080
            except errors.RevisionNotPresent, e:
2992
3081
                raise errors.GhostRevisionsHaveNoRevno(revision_id, e.revision_id)
2993
3082
            index = len(self._partial_revision_history_cache) - 1
 
3083
            if index < 0:
 
3084
                raise errors.NoSuchRevision(self, revision_id)
2994
3085
            if self._partial_revision_history_cache[index] != revision_id:
2995
3086
                raise errors.NoSuchRevision(self, revision_id)
2996
3087
        return self.revno() - index
3048
3139
    :ivar local_branch: target branch if there is a Master, else None
3049
3140
    :ivar target_branch: Target/destination branch object. (write locked)
3050
3141
    :ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
 
3142
    :ivar tag_updates: A dict with new tags, see BasicTags.merge_to
3051
3143
    """
3052
3144
 
3053
3145
    @deprecated_method(deprecated_in((2, 3, 0)))
3059
3151
        return self.new_revno - self.old_revno
3060
3152
 
3061
3153
    def report(self, to_file):
 
3154
        tag_conflicts = getattr(self, "tag_conflicts", None)
 
3155
        tag_updates = getattr(self, "tag_updates", None)
3062
3156
        if not is_quiet():
3063
 
            if self.old_revid == self.new_revid:
3064
 
                to_file.write('No revisions to pull.\n')
3065
 
            else:
 
3157
            if self.old_revid != self.new_revid:
3066
3158
                to_file.write('Now on revision %d.\n' % self.new_revno)
 
3159
            if tag_updates:
 
3160
                to_file.write('%d tag(s) updated.\n' % len(tag_updates))
 
3161
            if self.old_revid == self.new_revid and not tag_updates:
 
3162
                if not tag_conflicts:
 
3163
                    to_file.write('No revisions or tags to pull.\n')
 
3164
                else:
 
3165
                    to_file.write('No revisions to pull.\n')
3067
3166
        self._show_tag_conficts(to_file)
3068
3167
 
3069
3168
 
3095
3194
        return self.new_revno - self.old_revno
3096
3195
 
3097
3196
    def report(self, to_file):
3098
 
        """Write a human-readable description of the result."""
3099
 
        if self.old_revid == self.new_revid:
3100
 
            note('No new revisions to push.')
3101
 
        else:
3102
 
            note('Pushed up to revision %d.' % self.new_revno)
 
3197
        # TODO: This function gets passed a to_file, but then
 
3198
        # ignores it and calls note() instead. This is also
 
3199
        # inconsistent with PullResult(), which writes to stdout.
 
3200
        # -- JRV20110901, bug #838853
 
3201
        tag_conflicts = getattr(self, "tag_conflicts", None)
 
3202
        tag_updates = getattr(self, "tag_updates", None)
 
3203
        if not is_quiet():
 
3204
            if self.old_revid != self.new_revid:
 
3205
                note(gettext('Pushed up to revision %d.') % self.new_revno)
 
3206
            if tag_updates:
 
3207
                note(ngettext('%d tag updated.', '%d tags updated.', len(tag_updates)) % len(tag_updates))
 
3208
            if self.old_revid == self.new_revid and not tag_updates:
 
3209
                if not tag_conflicts:
 
3210
                    note(gettext('No new revisions or tags to push.'))
 
3211
                else:
 
3212
                    note(gettext('No new revisions to push.'))
3103
3213
        self._show_tag_conficts(to_file)
3104
3214
 
3105
3215
 
3119
3229
        :param verbose: Requests more detailed display of what was checked,
3120
3230
            if any.
3121
3231
        """
3122
 
        note('checked branch %s format %s', self.branch.user_url,
3123
 
            self.branch._format)
 
3232
        note(gettext('checked branch {0} format {1}').format(
 
3233
                                self.branch.user_url, self.branch._format))
3124
3234
        for error in self.errors:
3125
 
            note('found error:%s', error)
 
3235
            note(gettext('found error:%s'), error)
3126
3236
 
3127
3237
 
3128
3238
class Converter5to6(object):
3144
3254
 
3145
3255
        # Copying done; now update target format
3146
3256
        new_branch._transport.put_bytes('format',
3147
 
            format.get_format_string(),
 
3257
            format.as_string(),
3148
3258
            mode=new_branch.bzrdir._get_file_mode())
3149
3259
 
3150
3260
        # Clean up old files
3163
3273
        format = BzrBranchFormat7()
3164
3274
        branch._set_config_location('stacked_on_location', '')
3165
3275
        # update target format
3166
 
        branch._transport.put_bytes('format', format.get_format_string())
 
3276
        branch._transport.put_bytes('format', format.as_string())
3167
3277
 
3168
3278
 
3169
3279
class Converter7to8(object):
3173
3283
        format = BzrBranchFormat8()
3174
3284
        branch._transport.put_bytes('references', '')
3175
3285
        # update target format
3176
 
        branch._transport.put_bytes('format', format.get_format_string())
 
3286
        branch._transport.put_bytes('format', format.as_string())
3177
3287
 
3178
3288
 
3179
3289
class InterBranch(InterObject):
3413
3523
            self._update_revisions(stop_revision, overwrite=overwrite,
3414
3524
                    graph=graph)
3415
3525
        if self.source._push_should_merge_tags():
3416
 
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3417
 
                overwrite)
 
3526
            result.tag_updates, result.tag_conflicts = (
 
3527
                self.source.tags.merge_to(self.target.tags, overwrite))
3418
3528
        result.new_revno, result.new_revid = self.target.last_revision_info()
3419
3529
        return result
3420
3530
 
3503
3613
            # TODO: The old revid should be specified when merging tags, 
3504
3614
            # so a tags implementation that versions tags can only 
3505
3615
            # pull in the most recent changes. -- JRV20090506
3506
 
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3507
 
                overwrite, ignore_master=not merge_tags_to_master)
 
3616
            result.tag_updates, result.tag_conflicts = (
 
3617
                self.source.tags.merge_to(self.target.tags, overwrite,
 
3618
                    ignore_master=not merge_tags_to_master))
3508
3619
            result.new_revno, result.new_revid = self.target.last_revision_info()
3509
3620
            if _hook_master:
3510
3621
                result.master_branch = _hook_master