~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

• browse files at revision 5158.6.9
• compare with another revision
• download diff
• download tarball
• view history from revision 5158.6.9

• reverse the comparison (5158.6.9 to 5200.1.2)
• stop comparing with revision 5200.1.2

Show diffs side-by-side

added

removed

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,

 

1408

        return Branch.open(self.user_transport.clone(path).base,

1422

1409

                           possible_transports=possible_transports)

1423

1410

 

1424

1411

    def supports_tags(self):

1554

1541

        """Return the short format description for this format."""

1555

1542

        raise NotImplementedError(self.get_format_description)

1556

1543

 

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

1544

    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,

1566

1545

                           lock_type='metadir', set_format=True):

1567

1546

        """Initialize a branch in a bzrdir, with specified files

1603

1582

        finally:

1604

1583

            if lock_taken:

1605

1584

                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

 

1585

        return self.open(a_bzrdir, name, _found=True)

1609

1586

 

1610

1587

    def initialize(self, a_bzrdir, name=None):

1611

1588

        """Create a branch of this format in a_bzrdir.

1771

1748

            "should return a tag name or None if no tag name could be "

1772

1749

            "determined. The first non-None tag name returned will be used.",

1773

1750

            (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

1751

 

1785

1752

 

1786

1753

 

1826

1793

            self.old_revno, self.old_revid, self.new_revno, self.new_revid)

1827

1794

 

1828

1795

 

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

1796

class BzrBranchFormat4(BranchFormat):

1908

1797

    """Bzr branch format 4.

1909

1798

 

2178

2067

        branch_transport.put_bytes('location',

2179

2068

            target_branch.bzrdir.user_url)

2180

2069

        branch_transport.put_bytes('format', self.get_format_string())

2181

 

        branch = self.open(

 

2070

        return self.open(

2182

2071

            a_bzrdir, name, _found=True,

2183

2072

            possible_transports=[target_branch.bzrdir.root_transport])

2184

 

        self._run_post_branch_init_hooks(a_bzrdir, name, branch)

2185

 

        return branch

2186

2073

 

2187

2074

    def __init__(self):

2188

2075

        super(BranchReferenceFormat, self).__init__()

2882

2769

        return stacked_url

2883

2770

 

2884

2771

    def _get_append_revisions_only(self):

2885

 

        return self.get_config(

2886

 

            ).get_user_option_as_bool('append_revisions_only')

 

2772

        value = self.get_config().get_user_option('append_revisions_only')

 

2773

        return value == 'True'

2887

2774

 

2888

2775

    @needs_write_lock

2889

2776

    def generate_revision_history(self, revision_id, last_rev=None,

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1