/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Martin Pool
  • Date: 2010-04-21 09:57:18 UTC
  • mto: This revision was merged to the branch mainline in revision 5189.
  • Revision ID: mbp@canonical.com-20100421095718-u3c4w7k1crba29fq
Change info code to use user_url etc

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
417
417
            * 'include' - the stop revision is the last item in the result
418
418
            * 'with-merges' - include the stop revision and all of its
419
419
              merged revisions in the result
420
 
            * 'with-merges-without-common-ancestry' - filter out revisions 
421
 
              that are in both ancestries
422
420
        :param direction: either 'reverse' or 'forward':
423
421
            * reverse means return the start_revision_id first, i.e.
424
422
              start at the most recent revision and go backwards in history
455
453
            stop_revision_id, stop_rule)
456
454
        # Make sure we don't return revisions that are not part of the
457
455
        # start_revision_id ancestry.
458
 
        filtered = self._filter_start_non_ancestors(filtered)
 
456
        filtered = self._filter_non_ancestors(filtered)
459
457
        if direction == 'reverse':
460
458
            return filtered
461
459
        if direction == 'forward':
498
496
                       node.end_of_merge)
499
497
                if rev_id == stop_revision_id:
500
498
                    return
501
 
        elif stop_rule == 'with-merges-without-common-ancestry':
502
 
            # We want to exclude all revisions that are already part of the
503
 
            # stop_revision_id ancestry.
504
 
            graph = self.repository.get_graph()
505
 
            ancestors = graph.find_unique_ancestors(start_revision_id,
506
 
                                                    [stop_revision_id])
507
 
            for node in rev_iter:
508
 
                rev_id = node.key[-1]
509
 
                if rev_id not in ancestors:
510
 
                    continue
511
 
                yield (rev_id, node.merge_depth, node.revno,
512
 
                       node.end_of_merge)
513
499
        elif stop_rule == 'with-merges':
514
500
            stop_rev = self.repository.get_revision(stop_revision_id)
515
501
            if stop_rev.parent_ids:
538
524
        else:
539
525
            raise ValueError('invalid stop_rule %r' % stop_rule)
540
526
 
541
 
    def _filter_start_non_ancestors(self, rev_iter):
 
527
    def _filter_non_ancestors(self, rev_iter):
542
528
        # If we started from a dotted revno, we want to consider it as a tip
543
529
        # and don't want to yield revisions that are not part of its
544
530
        # ancestry. Given the order guaranteed by the merge sort, we will see
635
621
        :param pb: An optional progress bar to use.
636
622
        :return: None
637
623
        """
638
 
        if self.base == from_branch.base:
 
624
        if self.control_url == from_branch.control_url:
639
625
            return (0, [])
640
626
        if pb is not None:
641
627
            symbol_versioning.warn(
794
780
                # stream from one of them to the other.  This does mean doing
795
781
                # separate SSH connection setup, but unstacking is not a
796
782
                # common operation so it's tolerable.
797
 
                new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
 
783
                new_bzrdir = bzrdir.BzrDir.open_from_transport(
 
784
                    self.bzrdir.user_transport)
798
785
                new_repository = new_bzrdir.find_repository()
799
786
                self.repository = new_repository
800
787
                if self.repository._fallback_repositories:
1225
1212
            if repository_policy is not None:
1226
1213
                repository_policy.configure_branch(result)
1227
1214
            self.copy_content_into(result, revision_id=revision_id)
1228
 
            result.set_parent(self.bzrdir.root_transport.base)
 
1215
            result.set_parent(self.bzrdir.user_url)
1229
1216
        finally:
1230
1217
            result.unlock()
1231
1218
        return result
1418
1405
        :return: A branch associated with the file_id
1419
1406
        """
1420
1407
        # FIXME should provide multiple branches, based on config
1421
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base,
1422
 
                           possible_transports=possible_transports)
 
1408
        return Branch.open_from_transport(
 
1409
            self.bzrdir.root_transport.clone(path),
 
1410
            possible_transports=possible_transports)
1423
1411
 
1424
1412
    def supports_tags(self):
1425
1413
        return self._format.supports_tags()
1554
1542
        """Return the short format description for this format."""
1555
1543
        raise NotImplementedError(self.get_format_description)
1556
1544
 
1557
 
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1558
 
        hooks = Branch.hooks['post_branch_init']
1559
 
        if not hooks:
1560
 
            return
1561
 
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
1562
 
        for hook in hooks:
1563
 
            hook(params)
1564
 
 
1565
1545
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1566
1546
                           lock_type='metadir', set_format=True):
1567
1547
        """Initialize a branch in a bzrdir, with specified files
1603
1583
        finally:
1604
1584
            if lock_taken:
1605
1585
                control_files.unlock()
1606
 
        branch = self.open(a_bzrdir, name, _found=True)
1607
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1608
 
        return branch
 
1586
        return self.open(a_bzrdir, name, _found=True)
1609
1587
 
1610
1588
    def initialize(self, a_bzrdir, name=None):
1611
1589
        """Create a branch of this format in a_bzrdir.
1771
1749
            "should return a tag name or None if no tag name could be "
1772
1750
            "determined. The first non-None tag name returned will be used.",
1773
1751
            (2, 2), None))
1774
 
        self.create_hook(HookPoint('post_branch_init',
1775
 
            "Called after new branch initialization completes. "
1776
 
            "post_branch_init is called with a "
1777
 
            "bzrlib.branch.BranchInitHookParams. "
1778
 
            "Note that init, branch and checkout (both heavyweight and "
1779
 
            "lightweight) will all trigger this hook.", (2, 2), None))
1780
 
        self.create_hook(HookPoint('post_switch',
1781
 
            "Called after a checkout switches branch. "
1782
 
            "post_switch is called with a "
1783
 
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
1784
1752
 
1785
1753
 
1786
1754
 
1826
1794
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1827
1795
 
1828
1796
 
1829
 
class BranchInitHookParams(object):
1830
 
    """Object holding parameters passed to *_branch_init hooks.
1831
 
 
1832
 
    There are 4 fields that hooks may wish to access:
1833
 
 
1834
 
    :ivar format: the branch format
1835
 
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
1836
 
    :ivar name: name of colocated branch, if any (or None)
1837
 
    :ivar branch: the branch created
1838
 
 
1839
 
    Note that for lightweight checkouts, the bzrdir and format fields refer to
1840
 
    the checkout, hence they are different from the corresponding fields in
1841
 
    branch, which refer to the original branch.
1842
 
    """
1843
 
 
1844
 
    def __init__(self, format, a_bzrdir, name, branch):
1845
 
        """Create a group of BranchInitHook parameters.
1846
 
 
1847
 
        :param format: the branch format
1848
 
        :param a_bzrdir: the BzrDir where the branch will be/has been
1849
 
            initialized
1850
 
        :param name: name of colocated branch, if any (or None)
1851
 
        :param branch: the branch created
1852
 
 
1853
 
        Note that for lightweight checkouts, the bzrdir and format fields refer
1854
 
        to the checkout, hence they are different from the corresponding fields
1855
 
        in branch, which refer to the original branch.
1856
 
        """
1857
 
        self.format = format
1858
 
        self.bzrdir = a_bzrdir
1859
 
        self.name = name
1860
 
        self.branch = branch
1861
 
 
1862
 
    def __eq__(self, other):
1863
 
        return self.__dict__ == other.__dict__
1864
 
 
1865
 
    def __repr__(self):
1866
 
        if self.branch:
1867
 
            return "<%s of %s>" % (self.__class__.__name__, self.branch)
1868
 
        else:
1869
 
            return "<%s of format:%s bzrdir:%s>" % (
1870
 
                self.__class__.__name__, self.branch,
1871
 
                self.format, self.bzrdir)
1872
 
 
1873
 
 
1874
 
class SwitchHookParams(object):
1875
 
    """Object holding parameters passed to *_switch hooks.
1876
 
 
1877
 
    There are 4 fields that hooks may wish to access:
1878
 
 
1879
 
    :ivar control_dir: BzrDir of the checkout to change
1880
 
    :ivar to_branch: branch that the checkout is to reference
1881
 
    :ivar force: skip the check for local commits in a heavy checkout
1882
 
    :ivar revision_id: revision ID to switch to (or None)
1883
 
    """
1884
 
 
1885
 
    def __init__(self, control_dir, to_branch, force, revision_id):
1886
 
        """Create a group of SwitchHook parameters.
1887
 
 
1888
 
        :param control_dir: BzrDir of the checkout to change
1889
 
        :param to_branch: branch that the checkout is to reference
1890
 
        :param force: skip the check for local commits in a heavy checkout
1891
 
        :param revision_id: revision ID to switch to (or None)
1892
 
        """
1893
 
        self.control_dir = control_dir
1894
 
        self.to_branch = to_branch
1895
 
        self.force = force
1896
 
        self.revision_id = revision_id
1897
 
 
1898
 
    def __eq__(self, other):
1899
 
        return self.__dict__ == other.__dict__
1900
 
 
1901
 
    def __repr__(self):
1902
 
        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
1903
 
            self.control_dir, self.to_branch,
1904
 
            self.revision_id)
1905
 
 
1906
 
 
1907
1797
class BzrBranchFormat4(BranchFormat):
1908
1798
    """Bzr branch format 4.
1909
1799
 
2178
2068
        branch_transport.put_bytes('location',
2179
2069
            target_branch.bzrdir.user_url)
2180
2070
        branch_transport.put_bytes('format', self.get_format_string())
2181
 
        branch = self.open(
 
2071
        return self.open(
2182
2072
            a_bzrdir, name, _found=True,
2183
2073
            possible_transports=[target_branch.bzrdir.root_transport])
2184
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2185
 
        return branch
2186
2074
 
2187
2075
    def __init__(self):
2188
2076
        super(BranchReferenceFormat, self).__init__()
2882
2770
        return stacked_url
2883
2771
 
2884
2772
    def _get_append_revisions_only(self):
2885
 
        return self.get_config(
2886
 
            ).get_user_option_as_bool('append_revisions_only')
 
2773
        value = self.get_config().get_user_option('append_revisions_only')
 
2774
        return value == 'True'
2887
2775
 
2888
2776
    @needs_write_lock
2889
2777
    def generate_revision_history(self, revision_id, last_rev=None,
3379
3267
        if local and not bound_location:
3380
3268
            raise errors.LocalRequiresBoundBranch()
3381
3269
        master_branch = None
3382
 
        if not local and bound_location and self.source.user_url != bound_location:
 
3270
        if not local and bound_location and self.source.base != bound_location:
3383
3271
            # not pulling from master, so we need to update master.
3384
3272
            master_branch = self.target.get_master_branch(possible_transports)
3385
3273
            master_branch.lock_write()