← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

(jelmer) Skip tests that require an inventory when run against a WorkingTree
 that is not inventory based. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
994
994
        else:
995
995
            return (0, _mod_revision.NULL_REVISION)
996
996
 
 
997
    def update_revisions(self, other, stop_revision=None, overwrite=False,
 
998
            graph=None):
 
999
        """Pull in new perfect-fit revisions.
 
1000
 
 
1001
        :param other: Another Branch to pull from
 
1002
        :param stop_revision: Updated until the given revision
 
1003
        :param overwrite: Always set the branch pointer, rather than checking
 
1004
            to see if it is a proper descendant.
 
1005
        :param graph: A Graph object that can be used to query history
 
1006
            information. This can be None.
 
1007
        :return: None
 
1008
        """
 
1009
        return InterBranch.get(other, self).update_revisions(stop_revision,
 
1010
            overwrite, graph)
 
1011
 
997
1012
    @deprecated_method(deprecated_in((2, 4, 0)))
998
1013
    def import_last_revision_info(self, source_repo, revno, revid):
999
1014
        """Set the last revision info, importing from another repo if necessary.
2596
2611
                pass
2597
2612
        return None
2598
2613
 
 
2614
    def _basic_push(self, target, overwrite, stop_revision):
 
2615
        """Basic implementation of push without bound branches or hooks.
 
2616
 
 
2617
        Must be called with source read locked and target write locked.
 
2618
        """
 
2619
        result = BranchPushResult()
 
2620
        result.source_branch = self
 
2621
        result.target_branch = target
 
2622
        result.old_revno, result.old_revid = target.last_revision_info()
 
2623
        self.update_references(target)
 
2624
        if result.old_revid != stop_revision:
 
2625
            # We assume that during 'push' this repository is closer than
 
2626
            # the target.
 
2627
            graph = self.repository.get_graph(target.repository)
 
2628
            target.update_revisions(self, stop_revision,
 
2629
                overwrite=overwrite, graph=graph)
 
2630
        if self._push_should_merge_tags():
 
2631
            result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
 
2632
        result.new_revno, result.new_revid = target.last_revision_info()
 
2633
        return result
 
2634
 
2599
2635
    def get_stacked_on_url(self):
2600
2636
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2601
2637
 
3251
3287
        raise NotImplementedError(self.pull)
3252
3288
 
3253
3289
    @needs_write_lock
 
3290
    def update_revisions(self, stop_revision=None, overwrite=False,
 
3291
            graph=None):
 
3292
        """Pull in new perfect-fit revisions.
 
3293
 
 
3294
        :param stop_revision: Updated until the given revision
 
3295
        :param overwrite: Always set the branch pointer, rather than checking
 
3296
            to see if it is a proper descendant.
 
3297
        :param graph: A Graph object that can be used to query history
 
3298
            information. This can be None.
 
3299
        :return: None
 
3300
        """
 
3301
        raise NotImplementedError(self.update_revisions)
 
3302
 
 
3303
    @needs_write_lock
3254
3304
    def push(self, overwrite=False, stop_revision=None,
3255
3305
             _override_hook_source_branch=None):
3256
3306
        """Mirror the source branch into the target branch.
3334
3384
            self.source.unlock()
3335
3385
 
3336
3386
    @needs_write_lock
3337
 
    def _update_revisions(self, stop_revision=None, overwrite=False,
 
3387
    def update_revisions(self, stop_revision=None, overwrite=False,
3338
3388
            graph=None):
 
3389
        """See InterBranch.update_revisions()."""
3339
3390
        other_revno, other_last_revision = self.source.last_revision_info()
3340
3391
        stop_revno = None # unknown
3341
3392
        if stop_revision is None:
3427
3478
        finally:
3428
3479
            self.source.unlock()
3429
3480
 
3430
 
    def _basic_push(self, overwrite, stop_revision):
3431
 
        """Basic implementation of push without bound branches or hooks.
3432
 
 
3433
 
        Must be called with source read locked and target write locked.
3434
 
        """
3435
 
        result = BranchPushResult()
3436
 
        result.source_branch = self.source
3437
 
        result.target_branch = self.target
3438
 
        result.old_revno, result.old_revid = self.target.last_revision_info()
3439
 
        self.source.update_references(self.target)
3440
 
        if result.old_revid != stop_revision:
3441
 
            # We assume that during 'push' this repository is closer than
3442
 
            # the target.
3443
 
            graph = self.source.repository.get_graph(self.target.repository)
3444
 
            self._update_revisions(stop_revision, overwrite=overwrite,
3445
 
                    graph=graph)
3446
 
        if self.source._push_should_merge_tags():
3447
 
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3448
 
                overwrite)
3449
 
        result.new_revno, result.new_revid = self.target.last_revision_info()
3450
 
        return result
3451
 
 
3452
3481
    def _push_with_bound_branches(self, overwrite, stop_revision,
3453
3482
            _override_hook_source_branch=None):
3454
3483
        """Push from source into target, and into target's master if any.
3469
3498
            master_branch.lock_write()
3470
3499
            try:
3471
3500
                # push into the master from the source branch.
3472
 
                master_inter = InterBranch.get(self.source, master_branch)
3473
 
                master_inter._basic_push(overwrite, stop_revision)
3474
 
                # and push into the target branch from the source. Note that
3475
 
                # we push from the source branch again, because it's considered
3476
 
                # the highest bandwidth repository.
3477
 
                result = self._basic_push(overwrite, stop_revision)
 
3501
                self.source._basic_push(master_branch, overwrite, stop_revision)
 
3502
                # and push into the target branch from the source. Note that we
 
3503
                # push from the source branch again, because it's considered the
 
3504
                # highest bandwidth repository.
 
3505
                result = self.source._basic_push(self.target, overwrite,
 
3506
                    stop_revision)
3478
3507
                result.master_branch = master_branch
3479
3508
                result.local_branch = self.target
3480
3509
                _run_hooks()
3483
3512
                master_branch.unlock()
3484
3513
        else:
3485
3514
            # no master branch
3486
 
            result = self._basic_push(overwrite, stop_revision)
 
3515
            result = self.source._basic_push(self.target, overwrite,
 
3516
                stop_revision)
3487
3517
            # TODO: Why set master_branch and local_branch if there's no
3488
3518
            # binding?  Maybe cleaner to just leave them unset? -- mbp
3489
3519
            # 20070504
3532
3562
            # -- JRV20090506
3533
3563
            result.old_revno, result.old_revid = \
3534
3564
                self.target.last_revision_info()
3535
 
            self._update_revisions(stop_revision, overwrite=overwrite,
3536
 
                graph=graph)
 
3565
            self.target.update_revisions(self.source, stop_revision,
 
3566
                overwrite=overwrite, graph=graph)
3537
3567
            # TODO: The old revid should be specified when merging tags, 
3538
3568
            # so a tags implementation that versions tags can only 
3539
3569
            # pull in the most recent changes. -- JRV20090506