/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/branch.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
16
16
 
17
17
from __future__ import absolute_import
18
18
 
19
 
import bzrlib.bzrdir
20
 
 
21
 
from cStringIO import StringIO
22
 
 
23
 
from bzrlib.lazy_import import lazy_import
 
19
import breezy.bzrdir
 
20
 
 
21
from .lazy_import import lazy_import
24
22
lazy_import(globals(), """
25
23
import itertools
26
 
from bzrlib import (
 
24
from breezy import (
27
25
    bzrdir,
28
26
    controldir,
29
27
    cache_utf8,
46
44
    urlutils,
47
45
    vf_search,
48
46
    )
49
 
from bzrlib.i18n import gettext, ngettext
 
47
from breezy.i18n import gettext, ngettext
50
48
""")
51
49
 
52
 
# Explicitly import bzrlib.bzrdir so that the BzrProber
 
50
# Explicitly import breezy.bzrdir so that the BzrProber
53
51
# is guaranteed to be registered.
54
 
import bzrlib.bzrdir
 
52
import breezy.bzrdir
55
53
 
56
 
from bzrlib import (
 
54
from . import (
57
55
    bzrdir,
58
56
    controldir,
 
57
    registry,
59
58
    )
60
 
from bzrlib.decorators import (
 
59
from .decorators import (
61
60
    needs_read_lock,
62
61
    needs_write_lock,
63
62
    only_raises,
64
63
    )
65
 
from bzrlib.hooks import Hooks
66
 
from bzrlib.inter import InterObject
67
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
68
 
from bzrlib import registry
69
 
from bzrlib.symbol_versioning import (
 
64
from .hooks import Hooks
 
65
from .inter import InterObject
 
66
from .lock import _RelockDebugMixin, LogicalLockResult
 
67
from .sixish import (
 
68
    BytesIO,
 
69
    )
 
70
from .symbol_versioning import (
70
71
    deprecated_in,
71
72
    deprecated_method,
72
73
    )
73
 
from bzrlib.trace import mutter, mutter_callsite, note, is_quiet
 
74
from .trace import mutter, mutter_callsite, note, is_quiet
74
75
 
75
76
 
76
77
class Branch(controldir.ControlComponent):
170
171
    def _get_check_refs(self):
171
172
        """Get the references needed for check().
172
173
 
173
 
        See bzrlib.check.
 
174
        See breezy.check.
174
175
        """
175
176
        revid = self.last_revision()
176
177
        return [('revision-existence', revid), ('lefthand-distance', revid)]
221
222
        return self.supports_tags() and self.tags.get_tag_dict()
222
223
 
223
224
    def get_config(self):
224
 
        """Get a bzrlib.config.BranchConfig for this Branch.
 
225
        """Get a breezy.config.BranchConfig for this Branch.
225
226
 
226
227
        This can then be used to get and set configuration options for the
227
228
        branch.
228
229
 
229
 
        :return: A bzrlib.config.BranchConfig.
 
230
        :return: A breezy.config.BranchConfig.
230
231
        """
231
232
        return _mod_config.BranchConfig(self)
232
233
 
233
234
    def get_config_stack(self):
234
 
        """Get a bzrlib.config.BranchStack for this Branch.
 
235
        """Get a breezy.config.BranchStack for this Branch.
235
236
 
236
237
        This can then be used to get and set configuration options for the
237
238
        branch.
238
239
 
239
 
        :return: A bzrlib.config.BranchStack.
 
240
        :return: A breezy.config.BranchStack.
240
241
        """
241
242
        return _mod_config.BranchStack(self)
242
243
 
303
304
                if master is not None:
304
305
                    # return the master branch value
305
306
                    return master.nick
306
 
            except errors.RecursiveBind, e:
 
307
            except errors.RecursiveBind as e:
307
308
                raise e
308
 
            except errors.BzrError, e:
 
309
            except errors.BzrError as e:
309
310
                # Silently fall back to local implicit nick if the master is
310
311
                # unavailable
311
312
                mutter("Could not connect to bound branch, "
359
360
    def lock_read(self):
360
361
        """Lock the branch for read operations.
361
362
 
362
 
        :return: A bzrlib.lock.LogicalLockResult.
 
363
        :return: A breezy.lock.LogicalLockResult.
363
364
        """
364
365
        raise NotImplementedError(self.lock_read)
365
366
 
829
830
                except UnicodeEncodeError:
830
831
                    raise errors.InvalidURL(url,
831
832
                        "Urls must be 7-bit ascii, "
832
 
                        "use bzrlib.urlutils.escape")
 
833
                        "use breezy.urlutils.escape")
833
834
            url = urlutils.relative_url(self.base, url)
834
835
        self._set_parent_location(url)
835
836
 
1139
1140
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
1140
1141
        try:
1141
1142
            return urlutils.join(self.base[:-1], parent)
1142
 
        except errors.InvalidURLJoin, e:
 
1143
        except errors.InvalidURLJoin as e:
1143
1144
            raise errors.InaccessibleParent(parent, self.user_url)
1144
1145
 
1145
1146
    def _get_parent_location(self):
1482
1483
    @needs_write_lock
1483
1484
    def reconcile(self, thorough=True):
1484
1485
        """Make sure the data stored in this branch is consistent."""
1485
 
        from bzrlib.reconcile import BranchReconciler
 
1486
        from breezy.reconcile import BranchReconciler
1486
1487
        reconciler = BranchReconciler(self, thorough=thorough)
1487
1488
        reconciler.reconcile()
1488
1489
        return reconciler
1538
1539
        :returns: One of: 'a_descends_from_b', 'b_descends_from_a', 'diverged'
1539
1540
        """
1540
1541
        heads = graph.heads([revision_a, revision_b])
1541
 
        if heads == set([revision_b]):
 
1542
        if heads == {revision_b}:
1542
1543
            return 'b_descends_from_a'
1543
 
        elif heads == set([revision_a, revision_b]):
 
1544
        elif heads == {revision_a, revision_b}:
1544
1545
            # These branches have diverged
1545
1546
            return 'diverged'
1546
 
        elif heads == set([revision_a]):
 
1547
        elif heads == {revision_a}:
1547
1548
            return 'a_descends_from_b'
1548
1549
        else:
1549
1550
            raise AssertionError("invalid heads: %r" % (heads,))
1559
1560
        """
1560
1561
        # For bzr native formats must_fetch is just the tip, and
1561
1562
        # if_present_fetch are the tags.
1562
 
        must_fetch = set([self.last_revision()])
 
1563
        must_fetch = {self.last_revision()}
1563
1564
        if_present_fetch = set()
1564
1565
        if self.get_config_stack().get('branch.fetch_tags'):
1565
1566
            try:
1720
1721
    """A factory for a BranchFormat object, permitting simple lazy registration.
1721
1722
    
1722
1723
    While none of the built in BranchFormats are lazy registered yet,
1723
 
    bzrlib.tests.test_branch.TestMetaDirBranchFormatFactory demonstrates how to
 
1724
    breezy.tests.test_branch.TestMetaDirBranchFormatFactory demonstrates how to
1724
1725
    use it, and the bzr-loom plugin uses it as well (see
1725
 
    bzrlib.plugins.loom.formats).
 
1726
    breezy.plugins.loom.formats).
1726
1727
    """
1727
1728
 
1728
1729
    def __init__(self, format_string, module_name, member_name):
1757
1758
        These are all empty initially, because by default nothing should get
1758
1759
        notified.
1759
1760
        """
1760
 
        Hooks.__init__(self, "bzrlib.branch", "Branch.hooks")
 
1761
        Hooks.__init__(self, "breezy.branch", "Branch.hooks")
1761
1762
        self.add_hook('open',
1762
1763
            "Called with the Branch object that has been opened after a "
1763
1764
            "branch is opened.", (1, 8))
1764
1765
        self.add_hook('post_push',
1765
1766
            "Called after a push operation completes. post_push is called "
1766
 
            "with a bzrlib.branch.BranchPushResult object and only runs in the "
 
1767
            "with a breezy.branch.BranchPushResult object and only runs in the "
1767
1768
            "bzr client.", (0, 15))
1768
1769
        self.add_hook('post_pull',
1769
1770
            "Called after a pull operation completes. post_pull is called "
1770
 
            "with a bzrlib.branch.PullResult object and only runs in the "
 
1771
            "with a breezy.branch.PullResult object and only runs in the "
1771
1772
            "bzr client.", (0, 15))
1772
1773
        self.add_hook('pre_commit',
1773
1774
            "Called after a commit is calculated but before it is "
1793
1794
        self.add_hook('pre_change_branch_tip',
1794
1795
            "Called in bzr client and server before a change to the tip of a "
1795
1796
            "branch is made. pre_change_branch_tip is called with a "
1796
 
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
 
1797
            "breezy.branch.ChangeBranchTipParams. Note that push, pull, "
1797
1798
            "commit, uncommit will all trigger this hook.", (1, 6))
1798
1799
        self.add_hook('post_change_branch_tip',
1799
1800
            "Called in bzr client and server after a change to the tip of a "
1800
1801
            "branch is made. post_change_branch_tip is called with a "
1801
 
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
 
1802
            "breezy.branch.ChangeBranchTipParams. Note that push, pull, "
1802
1803
            "commit, uncommit will all trigger this hook.", (1, 4))
1803
1804
        self.add_hook('transform_fallback_location',
1804
1805
            "Called when a stacked branch is activating its fallback "
1821
1822
        self.add_hook('post_branch_init',
1822
1823
            "Called after new branch initialization completes. "
1823
1824
            "post_branch_init is called with a "
1824
 
            "bzrlib.branch.BranchInitHookParams. "
 
1825
            "breezy.branch.BranchInitHookParams. "
1825
1826
            "Note that init, branch and checkout (both heavyweight and "
1826
1827
            "lightweight) will all trigger this hook.", (2, 2))
1827
1828
        self.add_hook('post_switch',
1828
1829
            "Called after a checkout switches branch. "
1829
1830
            "post_switch is called with a "
1830
 
            "bzrlib.branch.SwitchHookParams.", (2, 2))
 
1831
            "breezy.branch.SwitchHookParams.", (2, 2))
1831
1832
 
1832
1833
 
1833
1834
 
2091
2092
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2092
2093
 
2093
2094
    def make_tags(self, branch):
2094
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
 
2095
        """See breezy.branch.BranchFormat.make_tags()."""
2095
2096
        return _mod_tag.BasicTags(branch)
2096
2097
 
2097
2098
    def supports_set_append_revisions_only(self):
2125
2126
        return self._initialize_helper(a_bzrdir, utf8_files, name, repository)
2126
2127
 
2127
2128
    def make_tags(self, branch):
2128
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
 
2129
        """See breezy.branch.BranchFormat.make_tags()."""
2129
2130
        return _mod_tag.BasicTags(branch)
2130
2131
 
2131
2132
    def supports_set_append_revisions_only(self):
2175
2176
        return True
2176
2177
 
2177
2178
    def make_tags(self, branch):
2178
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
 
2179
        """See breezy.branch.BranchFormat.make_tags()."""
2179
2180
        return _mod_tag.BasicTags(branch)
2180
2181
 
2181
2182
    supports_reference_locations = False
2315
2316
__format7 = BzrBranchFormat7()
2316
2317
__format8 = BzrBranchFormat8()
2317
2318
format_registry.register_lazy(
2318
 
    "Bazaar-NG branch format 5\n", "bzrlib.branchfmt.fullhistory", "BzrBranchFormat5")
 
2319
    "Bazaar-NG branch format 5\n", "breezy.branchfmt.fullhistory", "BzrBranchFormat5")
2319
2320
format_registry.register(BranchReferenceFormat())
2320
2321
format_registry.register(__format6)
2321
2322
format_registry.register(__format7)
2425
2426
            return
2426
2427
        if branch._transport.has('stored-transform'):
2427
2428
            raise errors.ChangesAlreadyStored
2428
 
        transform = StringIO()
 
2429
        transform = BytesIO()
2429
2430
        creator.write_shelf(transform)
2430
2431
        transform.seek(0)
2431
2432
        branch._transport.put_file('stored-transform', transform)
2471
2472
    def lock_read(self):
2472
2473
        """Lock the branch for read operations.
2473
2474
 
2474
 
        :return: A bzrlib.lock.LogicalLockResult.
 
2475
        :return: A breezy.lock.LogicalLockResult.
2475
2476
        """
2476
2477
        if not self.is_locked():
2477
2478
            self._note_lock('r')
2612
2613
        try:
2613
2614
            return Branch.open(bound_loc,
2614
2615
                               possible_transports=possible_transports)
2615
 
        except (errors.NotBranchError, errors.ConnectionError), e:
 
2616
        except (errors.NotBranchError, errors.ConnectionError) as e:
2616
2617
            raise errors.BoundBranchConnectionFailure(
2617
2618
                    self, bound_loc, e)
2618
2619
 
2749
2750
 
2750
2751
        :param info_dict: A dict of {file_id: (tree_path, branch_location)}
2751
2752
        """
2752
 
        s = StringIO()
 
2753
        s = BytesIO()
2753
2754
        writer = rio.RioWriter(s)
2754
2755
        for key, (tree_path, branch_location) in info_dict.iteritems():
2755
2756
            stanza = rio.Stanza(file_id=key, tree_path=tree_path,
2900
2901
        except ValueError:
2901
2902
            try:
2902
2903
                self._extend_partial_history(stop_revision=revision_id)
2903
 
            except errors.RevisionNotPresent, e:
 
2904
            except errors.RevisionNotPresent as e:
2904
2905
                raise errors.GhostRevisionsHaveNoRevno(revision_id, e.revision_id)
2905
2906
            index = len(self._partial_revision_history_cache) - 1
2906
2907
            if index < 0:
3200
3201
        self.source._synchronize_history(self.target, revision_id)
3201
3202
        try:
3202
3203
            parent = self.source.get_parent()
3203
 
        except errors.InaccessibleParent, e:
 
3204
        except errors.InaccessibleParent as e:
3204
3205
            mutter('parent was not accessible to copy: %s', e)
3205
3206
        else:
3206
3207
            if parent: