← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: John Arbash Meinel
  • Date: 2009-02-23 15:29:35 UTC
  • mfrom: (3943.7.7 bzr.code_style_cleanup)
  • mto: This revision was merged to the branch mainline in revision 4033.
  • Revision ID: john@arbash-meinel.com-20090223152935-oel9m92mwcc6nb4h
Merge the removal of all trailing whitespace, and resolve conflicts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
134
134
    @staticmethod
135
135
    def open_containing(url, possible_transports=None):
136
136
        """Open an existing branch which contains url.
137
 
        
 
137
 
138
138
        This probes for a branch at url, and searches upwards from there.
139
139
 
140
140
        Basically we keep looking up until we find the control directory or
141
141
        run into the root.  If there isn't one, raises NotBranchError.
142
 
        If there is one and it is either an unrecognised format or an unsupported 
 
142
        If there is one and it is either an unrecognised format or an unsupported
143
143
        format, UnknownFormatError or UnsupportedFormatError are raised.
144
144
        If there is one, it is returned, along with the unused portion of url.
145
145
        """
255
255
    @needs_read_lock
256
256
    def revision_id_to_dotted_revno(self, revision_id):
257
257
        """Given a revision id, return its dotted revno.
258
 
        
 
258
 
259
259
        :return: a tuple like (1,) or (400,1,3).
260
260
        """
261
261
        return self._do_revision_id_to_dotted_revno(revision_id)
425
425
    def leave_lock_in_place(self):
426
426
        """Tell this branch object not to release the physical lock when this
427
427
        object is unlocked.
428
 
        
 
428
 
429
429
        If lock_write doesn't return a token, then this method is not supported.
430
430
        """
431
431
        self.control_files.leave_in_place()
487
487
        branch.
488
488
        """
489
489
        return None
490
 
    
 
490
 
491
491
    def get_old_bound_location(self):
492
492
        """Return the URL of the branch we used to be bound to
493
493
        """
494
494
        raise errors.UpgradeRequired(self.base)
495
495
 
496
 
    def get_commit_builder(self, parents, config=None, timestamp=None, 
497
 
                           timezone=None, committer=None, revprops=None, 
 
496
    def get_commit_builder(self, parents, config=None, timestamp=None,
 
497
                           timezone=None, committer=None, revprops=None,
498
498
                           revision_id=None):
499
499
        """Obtain a CommitBuilder for this branch.
500
 
        
 
500
 
501
501
        :param parents: Revision ids of the parents of the new revision.
502
502
        :param config: Optional configuration to use.
503
503
        :param timestamp: Optional timestamp recorded for commit.
509
509
 
510
510
        if config is None:
511
511
            config = self.get_config()
512
 
        
 
512
 
513
513
        return self.repository.get_commit_builder(self, parents, config,
514
514
            timestamp, timezone, committer, revprops, revision_id)
515
515
 
516
516
    def get_master_branch(self, possible_transports=None):
517
517
        """Return the branch we are bound to.
518
 
        
 
518
 
519
519
        :return: Either a Branch, or None
520
520
        """
521
521
        return None
592
592
 
593
593
    def _gen_revision_history(self):
594
594
        """Return sequence of revision hashes on to this branch.
595
 
        
 
595
 
596
596
        Unlike revision_history, this method always regenerates or rereads the
597
597
        revision history, i.e. it does not cache the result, so repeated calls
598
598
        may be expensive.
599
599
 
600
600
        Concrete subclasses should override this instead of revision_history so
601
601
        that subclasses do not need to deal with caching logic.
602
 
        
 
602
 
603
603
        This API is semi-public; it only for use by subclasses, all other code
604
604
        should consider it to be private.
605
605
        """
608
608
    @needs_read_lock
609
609
    def revision_history(self):
610
610
        """Return sequence of revision ids on this branch.
611
 
        
 
611
 
612
612
        This method will cache the revision history for as long as it is safe to
613
613
        do so.
614
614
        """
662
662
    @deprecated_method(deprecated_in((1, 6, 0)))
663
663
    def missing_revisions(self, other, stop_revision=None):
664
664
        """Return a list of new revisions that would perfectly fit.
665
 
        
 
665
 
666
666
        If self and other have not diverged, return a list of the revisions
667
667
        present in other, but missing from self.
668
668
        """
710
710
            # possibly]
711
711
            last_rev = _mod_revision.ensure_null(self.last_revision())
712
712
            # we fetch here so that we don't process data twice in the common
713
 
            # case of having something to pull, and so that the check for 
 
713
            # case of having something to pull, and so that the check for
714
714
            # already merged can operate on the just fetched graph, which will
715
715
            # be cached in memory.
716
716
            self.fetch(other, stop_revision)
881
881
 
882
882
    @needs_write_lock
883
883
    def update(self):
884
 
        """Synchronise this branch with the master branch if any. 
 
884
        """Synchronise this branch with the master branch if any.
885
885
 
886
886
        :return: None or the last_revision pivoted out during the update.
887
887
        """
894
894
        """
895
895
        if revno != 0:
896
896
            self.check_real_revno(revno)
897
 
            
 
897
 
898
898
    def check_real_revno(self, revno):
899
899
        """\
900
900
        Check whether a revno corresponds to a real revision.
906
906
    @needs_read_lock
907
907
    def clone(self, to_bzrdir, revision_id=None):
908
908
        """Clone this branch into to_bzrdir preserving all semantic values.
909
 
        
 
909
 
910
910
        revision_id: if not None, the revision history in the new branch will
911
911
                     be truncated to end with revision_id.
912
912
        """
956
956
            revno = len(list(self.repository.iter_reverse_revision_history(
957
957
                                                                revision_id)))
958
958
        destination.set_last_revision_info(revno, revision_id)
959
 
    
 
959
 
960
960
    @needs_read_lock
961
961
    def copy_content_into(self, destination, revision_id=None):
962
962
        """Copy the content of self into destination.
979
979
        """Check consistency of the branch.
980
980
 
981
981
        In particular this checks that revisions given in the revision-history
982
 
        do actually match up in the revision graph, and that they're all 
 
982
        do actually match up in the revision graph, and that they're all
983
983
        present in the repository.
984
 
        
 
984
 
985
985
        Callers will typically also want to check the repository.
986
986
 
987
987
        :return: A BranchCheckResult.
1030
1030
                        lightweight=False, accelerator_tree=None,
1031
1031
                        hardlink=False):
1032
1032
        """Create a checkout of a branch.
1033
 
        
 
1033
 
1034
1034
        :param to_location: The url to produce the checkout at
1035
1035
        :param revision_id: The revision to check out
1036
1036
        :param lightweight: If True, produce a lightweight checkout, otherwise,
1055
1055
                to_location, force_new_tree=False, format=format)
1056
1056
            checkout = checkout_branch.bzrdir
1057
1057
            checkout_branch.bind(self)
1058
 
            # pull up to the specified revision_id to set the initial 
 
1058
            # pull up to the specified revision_id to set the initial
1059
1059
            # branch tip correctly, and seed it with history.
1060
1060
            checkout_branch.pull(self, stop_revision=revision_id)
1061
1061
            from_branch=None
1100
1100
        """Ensure that revision_b is a descendant of revision_a.
1101
1101
 
1102
1102
        This is a helper function for update_revisions.
1103
 
        
 
1103
 
1104
1104
        :raises: DivergedBranches if revision_b has diverged from revision_a.
1105
1105
        :returns: True if revision_b is a descendant of revision_a.
1106
1106
        """
1116
1116
 
1117
1117
    def _revision_relations(self, revision_a, revision_b, graph):
1118
1118
        """Determine the relationship between two revisions.
1119
 
        
 
1119
 
1120
1120
        :returns: One of: 'a_descends_from_b', 'b_descends_from_a', 'diverged'
1121
1121
        """
1122
1122
        heads = graph.heads([revision_a, revision_b])
1139
1139
     * a format string,
1140
1140
     * an open routine.
1141
1141
 
1142
 
    Formats are placed in an dict by their format string for reference 
 
1142
    Formats are placed in an dict by their format string for reference
1143
1143
    during branch opening. Its not required that these be instances, they
1144
 
    can be classes themselves with class methods - it simply depends on 
 
1144
    can be classes themselves with class methods - it simply depends on
1145
1145
    whether state is needed for a given format or not.
1146
1146
 
1147
1147
    Once a format is deprecated, just deprecate the initialize and open
1148
 
    methods on the format class. Do not deprecate the object, as the 
 
1148
    methods on the format class. Do not deprecate the object, as the
1149
1149
    object will be created every time regardless.
1150
1150
    """
1151
1151
 
1253
1253
        """Is this format supported?
1254
1254
 
1255
1255
        Supported formats can be initialized and opened.
1256
 
        Unsupported formats may not support initialization or committing or 
 
1256
        Unsupported formats may not support initialization or committing or
1257
1257
        some other features depending on the reason for not being supported.
1258
1258
        """
1259
1259
        return True
1292
1292
 
1293
1293
class BranchHooks(Hooks):
1294
1294
    """A dictionary mapping hook name to a list of callables for branch hooks.
1295
 
    
 
1295
 
1296
1296
    e.g. ['set_rh'] Is the list of items to be called when the
1297
1297
    set_revision_history function is invoked.
1298
1298
    """
1317
1317
        # (push_result)
1318
1318
        # containing the members
1319
1319
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
1320
 
        # where local is the local target branch or None, master is the target 
 
1320
        # where local is the local target branch or None, master is the target
1321
1321
        # master branch, and the rest should be self explanatory. The source
1322
1322
        # is read locked and the target branches write locked. Source will
1323
1323
        # be the local low-latency branch.
1327
1327
        # (pull_result)
1328
1328
        # containing the members
1329
1329
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
1330
 
        # where local is the local branch or None, master is the target 
 
1330
        # where local is the local branch or None, master is the target
1331
1331
        # master branch, and the rest should be self explanatory. The source
1332
1332
        # is read locked and the target branches write locked. The local
1333
1333
        # branch is the low-latency branch.
1343
1343
        # CommitBuilder.revision_tree() and hooks MUST NOT modify this tree
1344
1344
        self['pre_commit'] = []
1345
1345
        # invoked after a commit operation completes.
1346
 
        # the api signature is 
 
1346
        # the api signature is
1347
1347
        # (local, master, old_revno, old_revid, new_revno, new_revid)
1348
1348
        # old_revid is NULL_REVISION for the first commit to a branch.
1349
1349
        self['post_commit'] = []
1410
1410
 
1411
1411
    def __eq__(self, other):
1412
1412
        return self.__dict__ == other.__dict__
1413
 
    
 
1413
 
1414
1414
    def __repr__(self):
1415
1415
        return "<%s of %s from (%s, %s) to (%s, %s)>" % (
1416
 
            self.__class__.__name__, self.branch, 
 
1416
            self.__class__.__name__, self.branch,
1417
1417
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1418
1418
 
1419
1419
 
1520
1520
    def get_format_description(self):
1521
1521
        """See BranchFormat.get_format_description()."""
1522
1522
        return "Branch format 5"
1523
 
        
 
1523
 
1524
1524
    def initialize(self, a_bzrdir):
1525
1525
        """Create a branch of this format in a_bzrdir."""
1526
1526
        utf8_files = [('revision-history', ''),
1708
1708
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
1709
1709
    it's writable, and can be accessed via the normal filesystem API.
1710
1710
 
1711
 
    :ivar _transport: Transport for file operations on this branch's 
 
1711
    :ivar _transport: Transport for file operations on this branch's
1712
1712
        control files, typically pointing to the .bzr/branch directory.
1713
1713
    :ivar repository: Repository for this branch.
1714
 
    :ivar base: The url of the base directory for this branch; the one 
 
1714
    :ivar base: The url of the base directory for this branch; the one
1715
1715
        containing the .bzr directory.
1716
1716
    """
1717
 
    
 
1717
 
1718
1718
    def __init__(self, _format=None,
1719
1719
                 _control_files=None, a_bzrdir=None, _repository=None):
1720
1720
        """Create new branch object at a particular location."""
1774
1774
        if not self.control_files.is_locked():
1775
1775
            # we just released the lock
1776
1776
            self._clear_cached_state()
1777
 
        
 
1777
 
1778
1778
    def peek_lock_mode(self):
1779
1779
        if self.control_files._lock_count == 0:
1780
1780
            return None
1860
1860
        for this revision id.
1861
1861
 
1862
1862
        It may be possible to set the branch last revision to an id not
1863
 
        present in the repository.  However, branches can also be 
 
1863
        present in the repository.  However, branches can also be
1864
1864
        configured to check constraints on history, in which case this may not
1865
1865
        be permitted.
1866
1866
        """
1904
1904
             _override_hook_target=None):
1905
1905
        """See Branch.pull.
1906
1906
 
1907
 
        :param _hook_master: Private parameter - set the branch to 
 
1907
        :param _hook_master: Private parameter - set the branch to
1908
1908
            be supplied as the master to pull hooks.
1909
1909
        :param run_hooks: Private parameter - if false, this branch
1910
1910
            is being called because it's the master of the primary branch,
1958
1958
        This is the basic concrete implementation of push()
1959
1959
 
1960
1960
        :param _override_hook_source_branch: If specified, run
1961
 
        the hooks passing this Branch as the source, rather than self.  
 
1961
        the hooks passing this Branch as the source, rather than self.
1962
1962
        This is for use of RemoteBranch, where push is delegated to the
1963
 
        underlying vfs-based Branch. 
 
1963
        underlying vfs-based Branch.
1964
1964
        """
1965
1965
        # TODO: Public option to disable running hooks - should be trivial but
1966
1966
        # needs tests.
1973
1973
            stop_revision,
1974
1974
            _override_hook_source_branch=None):
1975
1975
        """Push from self into target, and into target's master if any.
1976
 
        
1977
 
        This is on the base BzrBranch class even though it doesn't support 
 
1976
 
 
1977
        This is on the base BzrBranch class even though it doesn't support
1978
1978
        bound branches because the *target* might be bound.
1979
1979
        """
1980
1980
        def _run_hooks():
2037
2037
 
2038
2038
    def _push_should_merge_tags(self):
2039
2039
        """Should _basic_push merge this branch's tags into the target?
2040
 
        
 
2040
 
2041
2041
        The default implementation returns False if this branch has no tags,
2042
2042
        and True the rest of the time.  Subclasses may override this.
2043
2043
        """
2106
2106
             run_hooks=True, possible_transports=None,
2107
2107
             _override_hook_target=None):
2108
2108
        """Pull from source into self, updating my master if any.
2109
 
        
 
2109
 
2110
2110
        :param run_hooks: Private parameter - if false, this branch
2111
2111
            is being called because it's the master of the primary branch,
2112
2112
            so it should not run its hooks.
2139
2139
    @needs_read_lock
2140
2140
    def get_master_branch(self, possible_transports=None):
2141
2141
        """Return the branch we are bound to.
2142
 
        
 
2142
 
2143
2143
        :return: Either a Branch, or None
2144
2144
 
2145
2145
        This could memoise the branch, but if thats done
2181
2181
        check for divergence to raise an error when the branches are not
2182
2182
        either the same, or one a prefix of the other. That behaviour may not
2183
2183
        be useful, so that check may be removed in future.
2184
 
        
 
2184
 
2185
2185
        :param other: The branch to bind to
2186
2186
        :type other: Branch
2187
2187
        """
2206
2206
 
2207
2207
    @needs_write_lock
2208
2208
    def update(self, possible_transports=None):
2209
 
        """Synchronise this branch with the master branch if any. 
 
2209
        """Synchronise this branch with the master branch if any.
2210
2210
 
2211
2211
        :return: None or the last_revision that was pivoted out during the
2212
2212
                 update.
2303
2303
 
2304
2304
    def _synchronize_history(self, destination, revision_id):
2305
2305
        """Synchronize last revision and revision history between branches.
2306
 
        
 
2306
 
2307
2307
        :see: Branch._synchronize_history
2308
2308
        """
2309
2309
        # XXX: The base Branch has a fast implementation of this method based
2606
2606
 
2607
2607
    def report_results(self, verbose):
2608
2608
        """Report the check results via trace.note.
2609
 
        
 
2609
 
2610
2610
        :param verbose: Requests more detailed display of what was checked,
2611
2611
            if any.
2612
2612
        """
2672
2672
            return callable(*args, **kwargs)
2673
2673
        finally:
2674
2674
            target.unlock()
2675
 
    
 
2675
 
2676
2676
    """
2677
2677
    # This is very similar to bzrlib.decorators.needs_write_lock.  Perhaps they
2678
2678
    # should share code?