/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 branch.py

Return unpeeled tags in extract_tags.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branch.py
85
85
 
86
86
    def get_tag_dict(self):
87
87
        ret = {}
88
 
        for k,v in extract_tags(self.repository._git.get_refs()).iteritems():
 
88
        refs = self.repository._git.get_refs()
 
89
        for k, (peeled, unpeeled) in extract_tags(refs).iteritems():
89
90
            try:
90
 
                obj = self.repository._git[v]
 
91
                obj = self.repository._git[peeled]
91
92
            except KeyError:
92
 
                mutter("Tag %s points at unknown object %s, ignoring", v, obj)
 
93
                mutter("Tag %s points at unknown object %s, ignoring", peeled,
 
94
                       obj)
93
95
                continue
 
96
            # FIXME: this shouldn't really be necessary, the repository
 
97
            # already should have these unpeeled.
94
98
            while isinstance(obj, Tag):
95
 
                v = obj.object[1]
96
 
                obj = self.repository._git[v]
 
99
                peeled = obj.object[1]
 
100
                obj = self.repository._git[peeled]
97
101
            if not isinstance(obj, Commit):
98
102
                mutter("Tag %s points at object %r that is not a commit, "
99
103
                       "ignoring", k, obj)
100
104
                continue
101
 
            ret[k] = self.branch.lookup_foreign_revision_id(v)
 
105
            ret[k] = self.branch.lookup_foreign_revision_id(peeled)
102
106
        return ret
103
107
 
104
108
    def _set_tag_dict(self, to_dict):
351
355
        return True
352
356
 
353
357
 
 
358
def _quick_lookup_revno(local_branch, remote_branch, revid):
 
359
    assert isinstance(revid, str), "was %r" % revid
 
360
    # Try in source branch first, it'll be faster
 
361
    try:
 
362
        return local_branch.revision_id_to_revno(revid)
 
363
    except errors.NoSuchRevision:
 
364
        graph = local_branch.repository.get_graph()
 
365
        try:
 
366
            return graph.find_distance_to_null(revid)
 
367
        except errors.GhostRevisionsHaveNoRevno:
 
368
            # FIXME: Check using graph.find_distance_to_null() ?
 
369
            return remote_branch.revision_id_to_revno(revid)
 
370
 
 
371
 
354
372
class GitBranchPullResult(branch.PullResult):
355
373
 
356
374
    def __init__(self):
371
389
        self._show_tag_conficts(to_file)
372
390
 
373
391
    def _lookup_revno(self, revid):
374
 
        assert isinstance(revid, str), "was %r" % revid
375
 
        # Try in source branch first, it'll be faster
376
 
        try:
377
 
            return self.source_branch.revision_id_to_revno(revid)
378
 
        except errors.NoSuchRevision:
379
 
            # FIXME: Check using graph.find_distance_to_null() ?
380
 
            return self.target_branch.revision_id_to_revno(revid)
 
392
        return _quick_lookup_revno(self.target_branch, self.source_branch, revid)
381
393
 
382
394
    def _get_old_revno(self):
383
395
        if self._old_revno is not None:
403
415
class GitBranchPushResult(branch.BranchPushResult):
404
416
 
405
417
    def _lookup_revno(self, revid):
406
 
        assert isinstance(revid, str), "was %r" % revid
407
 
        # Try in source branch first, it'll be faster
408
 
        try:
409
 
            return self.source_branch.revision_id_to_revno(revid)
410
 
        except errors.NoSuchRevision:
411
 
            # FIXME: Check using graph.find_distance_to_null() ?
412
 
            return self.target_branch.revision_id_to_revno(revid)
 
418
        return _quick_lookup_revno(self.source_branch, self.target_branch, revid)
413
419
 
414
420
    @property
415
421
    def old_revno(self):
417
423
 
418
424
    @property
419
425
    def new_revno(self):
 
426
        new_original_revno = getattr(self, "new_original_revno", None)
 
427
        if new_original_revno:
 
428
            return new_original_revno
 
429
        if getattr(self, "new_original_revid", None) is not None:
 
430
            return self._lookup_revno(self.new_original_revid)
420
431
        return self._lookup_revno(self.new_revid)
421
432
 
422
433
 
609
620
        return result
610
621
 
611
622
    def update_tags(self, refs):
612
 
        for name, v in extract_tags(refs).iteritems():
613
 
            revid = self.target.lookup_foreign_revision_id(v)
 
623
        for name, (peeled, unpeeled) in extract_tags(refs).iteritems():
 
624
            revid = self.target.lookup_foreign_revision_id(peeled)
614
625
            self.target.tags.set_tag(name, revid)
 
626
            if unpeeled is not None:
 
627
                pass # FIXME: Store unpeeled info
615
628
 
616
629
    def update_refs(self, stop_revision=None):
617
630
        interrepo = repository.InterRepository.get(self.source.repository,
661
674
 
662
675
    def _get_new_refs(self, stop_revision=None):
663
676
        if stop_revision is None:
664
 
            stop_revision = self.source.last_revision()
 
677
            (stop_revno, stop_revision) = self.source.last_revision_info()
665
678
        assert type(stop_revision) is str
666
679
        main_ref = self.target.ref or "refs/heads/master"
667
680
        refs = { main_ref: (None, stop_revision) }
668
681
        for name, revid in self.source.tags.get_tag_dict().iteritems():
669
682
            if self.source.repository.has_revision(revid):
670
683
                refs[tag_name_to_ref(name)] = (None, revid)
671
 
        return refs, main_ref
 
684
        return refs, main_ref, (stop_revno, stop_revision)
672
685
 
673
686
    def pull(self, overwrite=False, stop_revision=None, local=False,
674
687
             possible_transports=None):
676
689
        result = GitBranchPullResult()
677
690
        result.source_branch = self.source
678
691
        result.target_branch = self.target
679
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
692
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
680
693
        def update_refs(old_refs):
681
694
            refs = dict(old_refs)
682
695
            # FIXME: Check for diverged branches
683
696
            refs.update(new_refs)
684
697
            return refs
685
698
        old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
686
 
        result.old_revid = self.target.lookup_foreign_revision_id(
687
 
            old_refs.get(main_ref, ZERO_SHA))
688
 
        result.new_revid = new_refs[main_ref]
 
699
        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
 
700
        if result.old_revid is None:
 
701
            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
 
702
        result.new_revid = new_refs[main_ref][1]
689
703
        return result
690
704
 
691
705
    def push(self, overwrite=False, stop_revision=None,
694
708
        result = GitBranchPushResult()
695
709
        result.source_branch = self.source
696
710
        result.target_branch = self.target
697
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
711
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
698
712
        def update_refs(old_refs):
699
713
            refs = dict(old_refs)
700
714
            # FIXME: Check for diverged branches
704
718
        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
705
719
        if result.old_revid is None:
706
720
            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
707
 
        result.new_revid = new_refs[main_ref]
 
721
        result.new_revid = new_refs[main_ref][1]
708
722
        return result
709
723
 
710
724
    def lossy_push(self, stop_revision=None):
711
725
        result = GitBranchPushResult()
712
726
        result.source_branch = self.source
713
727
        result.target_branch = self.target
714
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
728
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
715
729
        def update_refs(old_refs):
716
730
            refs = dict(old_refs)
717
731
            # FIXME: Check for diverged branches
721
735
            update_refs)
722
736
        result.old_revid = old_refs.get(self.target.ref, (None, NULL_REVISION))[1]
723
737
        result.new_revid = new_refs[main_ref][1]
 
738
        (result.new_original_revno, result.new_original_revid) = stop_revinfo
724
739
        return result
725
740
 
726
741