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

  • Committer: Jelmer Vernooij
  • Date: 2018-11-17 00:47:52 UTC
  • mfrom: (7182 work)
  • mto: This revision was merged to the branch mainline in revision 7305.
  • Revision ID: jelmer@jelmer.uk-20181117004752-6ywampe5pfywlby4
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/branch.py
61
61
    )
62
62
from .errors import (
63
63
    NoPushSupport,
64
 
    NoSuchRef,
65
64
    )
66
65
from .push import (
67
66
    remote_divergence,
80
79
from .urls import git_url_to_bzr_url
81
80
 
82
81
 
83
 
 
84
82
class GitPullResult(branch.PullResult):
85
83
    """Result of a pull from a Git branch."""
86
84
 
107
105
        self.branch = branch
108
106
        self.repository = branch.repository
109
107
 
110
 
    def _merge_to_remote_git(self, target_repo, source_tag_refs, overwrite=False):
 
108
    def _merge_to_remote_git(self, target_repo, source_tag_refs,
 
109
                             overwrite=False):
111
110
        updates = {}
112
111
        conflicts = []
 
112
 
113
113
        def get_changed_refs(old_refs):
114
114
            ret = dict(old_refs)
115
 
            for ref_name, tag_name, peeled, unpeeled in source_tag_refs.iteritems():
 
115
            for ref_name, tag_name, peeled, unpeeled in (
 
116
                    source_tag_refs.iteritems()):
116
117
                if old_refs.get(ref_name) == unpeeled:
117
118
                    pass
118
 
                elif overwrite or not ref_name in old_refs:
 
119
                elif overwrite or ref_name not in old_refs:
119
120
                    ret[ref_name] = unpeeled
120
 
                    updates[tag_name] = target_repo.lookup_foreign_revision_id(peeled)
 
121
                    updates[tag_name] = target_repo.lookup_foreign_revision_id(
 
122
                        peeled)
121
123
                else:
122
124
                    conflicts.append(
123
125
                        (tag_name,
124
 
                        self.repository.lookup_foreign_revision_id(peeled),
125
 
                        target_repo.lookup_foreign_revision_id(old_refs[ref_name])))
 
126
                         self.repository.lookup_foreign_revision_id(peeled),
 
127
                         target_repo.lookup_foreign_revision_id(
 
128
                             old_refs[ref_name])))
126
129
            return ret
127
 
        target_repo.controldir.send_pack(get_changed_refs, lambda have, want: [])
 
130
        target_repo.controldir.send_pack(
 
131
            get_changed_refs, lambda have, want: [])
128
132
        return updates, conflicts
129
133
 
130
 
    def _merge_to_local_git(self, target_repo, source_tag_refs, overwrite=False):
 
134
    def _merge_to_local_git(self, target_repo, source_tag_refs,
 
135
                            overwrite=False):
131
136
        conflicts = []
132
137
        updates = {}
133
138
        for ref_name, tag_name, peeled, unpeeled in source_tag_refs:
134
139
            if target_repo._git.refs.get(ref_name) == unpeeled:
135
140
                pass
136
 
            elif overwrite or not ref_name in target_repo._git.refs:
 
141
            elif overwrite or ref_name not in target_repo._git.refs:
137
142
                target_repo._git.refs[ref_name] = unpeeled or peeled
138
 
                updates[tag_name] = self.repository.lookup_foreign_revision_id(peeled)
 
143
                try:
 
144
                    updates[tag_name] = (
 
145
                        self.repository.lookup_foreign_revision_id(peeled))
 
146
                except KeyError:
 
147
                    trace.warning('%s does not point to a valid object',
 
148
                                  tag_name)
 
149
                    continue
139
150
            else:
140
 
                source_revid = self.repository.lookup_foreign_revision_id(peeled)
141
151
                try:
 
152
                    source_revid = self.repository.lookup_foreign_revision_id(
 
153
                        peeled)
142
154
                    target_revid = target_repo.lookup_foreign_revision_id(
143
 
                            target_repo._git.refs[ref_name])
 
155
                        target_repo._git.refs[ref_name])
144
156
                except KeyError:
145
157
                    trace.warning('%s does not point to a valid object',
146
158
                                  ref_name)
154
166
            return {}, []
155
167
        try:
156
168
            if getattr(target_repo, "_git", None):
157
 
                return self._merge_to_local_git(target_repo, source_tag_refs, overwrite)
 
169
                return self._merge_to_local_git(
 
170
                    target_repo, source_tag_refs, overwrite)
158
171
            else:
159
 
                return self._merge_to_remote_git(target_repo, source_tag_refs, overwrite)
 
172
                return self._merge_to_remote_git(
 
173
                    target_repo, source_tag_refs, overwrite)
160
174
        finally:
161
175
            to_tags.branch._tag_refs = None
162
176
 
178
192
                result[tag_name] = bzr_revid
179
193
                updates[tag_name] = bzr_revid
180
194
            else:
181
 
                conflicts.append((tag_name, bzr_revid, result[n]))
 
195
                conflicts.append((tag_name, bzr_revid, result[tag_name]))
182
196
        to_tags._set_tag_dict(result)
183
197
        if len(unpeeled_map) > 0:
184
198
            map_file = UnpeelMap.from_repository(to_tags.branch.repository)
204
218
            if master is not None:
205
219
                master.lock_write()
206
220
            try:
207
 
                updates, conflicts = self._merge_to_non_git(to_tags, source_tag_refs,
208
 
                                                  overwrite=overwrite)
 
221
                updates, conflicts = self._merge_to_non_git(
 
222
                    to_tags, source_tag_refs, overwrite=overwrite)
209
223
                if master is not None:
210
224
                    extra_updates, extra_conflicts = self.merge_to(
211
225
                        master.tags, overwrite=overwrite,
212
 
                                               source_tag_refs=source_tag_refs,
213
 
                                               ignore_master=ignore_master)
 
226
                        source_tag_refs=source_tag_refs,
 
227
                        ignore_master=ignore_master)
214
228
                    updates.update(extra_updates)
215
229
                    conflicts += extra_conflicts
216
230
                return updates, conflicts
220
234
 
221
235
    def get_tag_dict(self):
222
236
        ret = {}
223
 
        for (ref_name, tag_name, peeled, unpeeled) in self.branch.get_tag_refs():
 
237
        for (ref_name, tag_name, peeled, unpeeled) in (
 
238
                self.branch.get_tag_refs()):
224
239
            try:
225
240
                bzr_revid = self.branch.lookup_foreign_revision_id(peeled)
226
241
            except NotCommitError:
258
273
 
259
274
    def delete_tag(self, name):
260
275
        ref = tag_name_to_ref(name)
261
 
        if not ref in self.refs:
 
276
        if ref not in self.refs:
262
277
            raise errors.NoSuchTag(name)
263
278
        del self.refs[ref]
264
279
        self.branch._tag_refs = None
301
316
        raise NotImplementedError(self.initialize)
302
317
 
303
318
    def get_reference(self, controldir, name=None):
304
 
        return controldir.get_branch_reference(name)
 
319
        return controldir.get_branch_reference(name=name)
305
320
 
306
321
    def set_reference(self, controldir, name, target):
307
322
        return controldir.set_branch_reference(target, name)
322
337
        from .dir import LocalGitDir
323
338
        if not isinstance(a_controldir, LocalGitDir):
324
339
            raise errors.IncompatibleFormat(self, a_controldir._format)
325
 
        return a_controldir.create_branch(repository=repository, name=name,
 
340
        return a_controldir.create_branch(
 
341
            repository=repository, name=name,
326
342
            append_revisions_only=append_revisions_only)
327
343
 
328
344
 
391
407
 
392
408
        :return: Branch nick
393
409
        """
394
 
        cs = self.repository._git.get_config_stack()
395
 
        try:
396
 
            return cs.get((b"branch", self.name.encode('utf-8')), b"nick").decode("utf-8")
397
 
        except KeyError:
398
 
            pass
 
410
        if getattr(self.repository, '_git', None):
 
411
            cs = self.repository._git.get_config_stack()
 
412
            try:
 
413
                return cs.get((b"branch", self.name.encode('utf-8')),
 
414
                              b"nick").decode("utf-8")
 
415
            except KeyError:
 
416
                pass
399
417
        return self.name or u"HEAD"
400
418
 
401
419
    def _set_nick(self, nick):
402
420
        cf = self.repository._git.get_config()
403
 
        cf.set((b"branch", self.name.encode('utf-8')), b"nick", nick.encode("utf-8"))
 
421
        cf.set((b"branch", self.name.encode('utf-8')),
 
422
               b"nick", nick.encode("utf-8"))
404
423
        f = BytesIO()
405
424
        cf.write_to_file(f)
406
425
        self.repository._git._put_named_file('config', f.getvalue())
409
428
 
410
429
    def __repr__(self):
411
430
        return "<%s(%r, %r)>" % (self.__class__.__name__, self.repository.base,
412
 
            self.name)
 
431
                                 self.name)
413
432
 
414
 
    def generate_revision_history(self, revid, last_rev=None, other_branch=None):
 
433
    def generate_revision_history(self, revid, last_rev=None,
 
434
                                  other_branch=None):
415
435
        if last_rev is not None:
416
436
            graph = self.repository.get_graph()
417
437
            if not graph.is_ancestor(last_rev, revid):
545
565
    def lookup_foreign_revision_id(self, foreign_revid):
546
566
        try:
547
567
            return self.repository.lookup_foreign_revision_id(foreign_revid,
548
 
                self.mapping)
 
568
                                                              self.mapping)
549
569
        except KeyError:
550
570
            # Let's try..
551
571
            return self.mapping.revision_id_foreign_to_bzr(foreign_revid)
581
601
 
582
602
    def __init__(self, controldir, repository, ref):
583
603
        super(LocalGitBranch, self).__init__(controldir, repository, ref,
584
 
                LocalGitBranchFormat())
 
604
                                             LocalGitBranchFormat())
585
605
 
586
606
    def create_checkout(self, to_location, revision_id=None, lightweight=False,
587
 
        accelerator_tree=None, hardlink=False):
 
607
                        accelerator_tree=None, hardlink=False):
588
608
        t = transport.get_transport(to_location)
589
609
        t.ensure_base()
590
610
        format = self._get_checkout_format(lightweight=lightweight)
593
613
            from_branch = checkout.set_branch_reference(target_branch=self)
594
614
        else:
595
615
            policy = checkout.determine_repository_policy()
596
 
            repo = policy.acquire_repository()[0]
597
 
 
 
616
            policy.acquire_repository()
598
617
            checkout_branch = checkout.create_branch()
599
618
            checkout_branch.bind(self)
600
619
            checkout_branch.pull(self, stop_revision=revision_id)
601
620
            from_branch = None
602
 
        return checkout.create_workingtree(revision_id,
603
 
                from_branch=from_branch, hardlink=hardlink)
 
621
        return checkout.create_workingtree(
 
622
            revision_id, from_branch=from_branch, hardlink=hardlink)
604
623
 
605
624
    def _lock_ref(self):
606
625
        self._ref_lock = self.repository._git.refs.lock_ref(self.ref)
621
640
        last_revid = self.last_revision()
622
641
        graph = self.repository.get_graph()
623
642
        try:
624
 
            ret = list(graph.iter_lefthand_ancestry(last_revid,
625
 
                (revision.NULL_REVISION, )))
 
643
            ret = list(graph.iter_lefthand_ancestry(
 
644
                last_revid, (revision.NULL_REVISION, )))
626
645
        except errors.RevisionNotPresent as e:
627
646
            raise errors.GhostRevisionsHaveNoRevno(last_revid, e.revision_id)
628
647
        ret.reverse()
637
656
    def _read_last_revision_info(self):
638
657
        last_revid = self.last_revision()
639
658
        graph = self.repository.get_graph()
640
 
        revno = graph.find_distance_to_null(last_revid,
641
 
            [(revision.NULL_REVISION, 0)])
 
659
        try:
 
660
            revno = graph.find_distance_to_null(
 
661
                last_revid, [(revision.NULL_REVISION, 0)])
 
662
        except errors.GhostRevisionsHaveNoRevno:
 
663
            revno = None
642
664
        return revno, last_revid
643
665
 
644
666
    def set_last_revision_info(self, revno, revision_id):
651
673
        if revid == NULL_REVISION:
652
674
            newhead = None
653
675
        else:
654
 
            (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
 
676
            (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(
 
677
                revid)
655
678
            if self.mapping is None:
656
679
                raise AssertionError
657
680
        self._set_head(newhead)
705
728
 
706
729
    def create_memorytree(self):
707
730
        from .memorytree import GitMemoryTree
708
 
        return GitMemoryTree(self, self.repository._git.object_store, self.head)
 
731
        return GitMemoryTree(self, self.repository._git.object_store,
 
732
                             self.head)
709
733
 
710
734
    def reference_parent(self, path, file_id=None, possible_transports=None):
711
735
        """Return the parent branch for a tree-reference file_id
717
741
        # FIXME should provide multiple branches, based on config
718
742
        url = urlutils.join(self.user_url, path)
719
743
        return branch.Branch.open(
720
 
                url,
721
 
                possible_transports=possible_transports)
722
 
 
 
744
            url,
 
745
            possible_transports=possible_transports)
723
746
 
724
747
 
725
748
def _quick_lookup_revno(local_branch, remote_branch, revid):
732
755
        except errors.NoSuchRevision:
733
756
            graph = local_branch.repository.get_graph()
734
757
            try:
735
 
                return graph.find_distance_to_null(revid,
736
 
                    [(revision.NULL_REVISION, 0)])
 
758
                return graph.find_distance_to_null(
 
759
                    revid, [(revision.NULL_REVISION, 0)])
737
760
            except errors.GhostRevisionsHaveNoRevno:
738
761
                # FIXME: Check using graph.find_distance_to_null() ?
739
762
                with remote_branch.lock_read():
754
777
                to_file.write('No revisions to pull.\n')
755
778
            elif self.new_git_head is not None:
756
779
                to_file.write('Now on revision %d (git sha: %s).\n' %
757
 
                        (self.new_revno, self.new_git_head))
 
780
                              (self.new_revno, self.new_git_head))
758
781
            else:
759
782
                to_file.write('Now on revision %d.\n' % (self.new_revno,))
760
783
        self._show_tag_conficts(to_file)
761
784
 
762
785
    def _lookup_revno(self, revid):
763
786
        return _quick_lookup_revno(self.target_branch, self.source_branch,
764
 
            revid)
 
787
                                   revid)
765
788
 
766
789
    def _get_old_revno(self):
767
790
        if self._old_revno is not None:
788
811
 
789
812
    def _lookup_revno(self, revid):
790
813
        return _quick_lookup_revno(self.source_branch, self.target_branch,
791
 
            revid)
 
814
                                   revid)
792
815
 
793
816
    @property
794
817
    def old_revno(self):
820
843
 
821
844
    @classmethod
822
845
    def _get_interrepo(self, source, target):
823
 
        return _mod_repository.InterRepository.get(source.repository, target.repository)
 
846
        return _mod_repository.InterRepository.get(
 
847
            source.repository, target.repository)
824
848
 
825
849
    @classmethod
826
850
    def is_compatible(cls, source, target):
829
853
        if isinstance(target, GitBranch):
830
854
            # InterLocalGitRemoteGitBranch or InterToGitBranch should be used
831
855
            return False
832
 
        if getattr(cls._get_interrepo(source, target), "fetch_objects", None) is None:
 
856
        if (getattr(cls._get_interrepo(source, target), "fetch_objects", None)
 
857
                is None):
833
858
            # fetch_objects is necessary for this to work
834
859
            return False
835
860
        return True
842
867
        if fetch_tags is None:
843
868
            c = self.source.get_config_stack()
844
869
            fetch_tags = c.get('branch.fetch_tags')
 
870
 
845
871
        def determine_wants(heads):
846
872
            if stop_revision is None:
847
873
                try:
849
875
                except KeyError:
850
876
                    self._last_revid = revision.NULL_REVISION
851
877
                else:
852
 
                    self._last_revid = self.source.lookup_foreign_revision_id(head)
 
878
                    self._last_revid = self.source.lookup_foreign_revision_id(
 
879
                        head)
853
880
            else:
854
881
                self._last_revid = stop_revision
855
882
            real = interrepo.get_determine_wants_revids(
858
885
        pack_hint, head, refs = interrepo.fetch_objects(
859
886
            determine_wants, self.source.mapping, limit=limit)
860
887
        if (pack_hint is not None and
861
 
            self.target.repository._format.pack_compresses):
 
888
                self.target.repository._format.pack_compresses):
862
889
            self.target.repository.pack(hint=pack_hint)
863
890
        return head, refs
864
891
 
868
895
            prev_last_revid = None
869
896
        else:
870
897
            prev_last_revid = self.target.last_revision()
871
 
        self.target.generate_revision_history(self._last_revid,
872
 
            last_rev=prev_last_revid, other_branch=self.source)
 
898
        self.target.generate_revision_history(
 
899
            self._last_revid, last_rev=prev_last_revid,
 
900
            other_branch=self.source)
873
901
        return head, refs
874
902
 
875
903
    def _basic_pull(self, stop_revision, overwrite, run_hooks,
876
 
              _override_hook_target, _hook_master):
 
904
                    _override_hook_target, _hook_master):
877
905
        if overwrite is True:
878
906
            overwrite = set(["history", "tags"])
879
 
        else:
 
907
        elif not overwrite:
880
908
            overwrite = set()
881
909
        result = GitBranchPullResult()
882
910
        result.source_branch = self.source
891
919
                self.target.last_revision_info()
892
920
            result.new_git_head, remote_refs = self._update_revisions(
893
921
                stop_revision, overwrite=("history" in overwrite))
894
 
            tags_ret  = self.source.tags.merge_to(
895
 
                    self.target.tags, ("tags" in overwrite), ignore_master=True)
 
922
            tags_ret = self.source.tags.merge_to(
 
923
                self.target.tags, ("tags" in overwrite), ignore_master=True)
896
924
            if isinstance(tags_ret, tuple):
897
925
                result.tag_updates, result.tag_conflicts = tags_ret
898
926
            else:
948
976
                if master_branch:
949
977
                    # pull from source into master.
950
978
                    master_branch.pull(self.source, overwrite, stop_revision,
951
 
                        run_hooks=False)
 
979
                                       run_hooks=False)
952
980
                result = self._basic_pull(stop_revision, overwrite, run_hooks,
953
 
                    _override_hook_target, _hook_master=master_branch)
 
981
                                          _override_hook_target,
 
982
                                          _hook_master=master_branch)
954
983
            finally:
955
984
                self.source.unlock()
956
985
        finally:
961
990
    def _basic_push(self, overwrite, stop_revision):
962
991
        if overwrite is True:
963
992
            overwrite = set(["history", "tags"])
964
 
        else:
 
993
        elif not overwrite:
965
994
            overwrite = set()
966
995
        result = branch.BranchPushResult()
967
996
        result.source_branch = self.source
969
998
        result.old_revno, result.old_revid = self.target.last_revision_info()
970
999
        result.new_git_head, remote_refs = self._update_revisions(
971
1000
            stop_revision, overwrite=("history" in overwrite))
972
 
        tags_ret = self.source.tags.merge_to(self.target.tags,
973
 
            "tags" in overwrite, ignore_master=True)
 
1001
        tags_ret = self.source.tags.merge_to(
 
1002
            self.target.tags, "tags" in overwrite, ignore_master=True)
974
1003
        (result.tag_updates, result.tag_conflicts) = tags_ret
975
1004
        result.new_revno, result.new_revid = self.target.last_revision_info()
976
1005
        return result
1004
1033
        result.target_branch = self.target
1005
1034
        if stop_revision is None:
1006
1035
            stop_revision = self.source.last_revision()
 
1036
 
1007
1037
        def get_changed_refs(old_refs):
1008
1038
            old_ref = old_refs.get(self.target.ref, None)
1009
1039
            if old_ref is None:
1010
1040
                result.old_revid = revision.NULL_REVISION
1011
1041
            else:
1012
 
                result.old_revid = self.target.lookup_foreign_revision_id(old_ref)
1013
 
            new_ref = self.source.repository.lookup_bzr_revision_id(stop_revision)[0]
 
1042
                result.old_revid = self.target.lookup_foreign_revision_id(
 
1043
                    old_ref)
 
1044
            new_ref = self.source.repository.lookup_bzr_revision_id(
 
1045
                stop_revision)[0]
1014
1046
            if not overwrite:
1015
 
                if remote_divergence(old_ref, new_ref, self.source.repository._git.object_store):
 
1047
                if remote_divergence(
 
1048
                        old_ref, new_ref,
 
1049
                        self.source.repository._git.object_store):
1016
1050
                    raise errors.DivergedBranches(self.source, self.target)
1017
 
            refs = { self.target.ref: new_ref }
 
1051
            refs = {self.target.ref: new_ref}
1018
1052
            result.new_revid = stop_revision
1019
 
            for name, sha in viewitems(self.source.repository._git.refs.as_dict(b"refs/tags")):
 
1053
            for name, sha in viewitems(
 
1054
                    self.source.repository._git.refs.as_dict(b"refs/tags")):
1020
1055
                refs[tag_name_to_ref(name)] = sha
1021
1056
            return refs
1022
 
        self.target.repository.send_pack(get_changed_refs,
 
1057
        self.target.repository.send_pack(
 
1058
            get_changed_refs,
1023
1059
            self.source.repository._git.object_store.generate_pack_data)
1024
1060
        return result
1025
1061
 
1041
1077
 
1042
1078
    def fetch(self, stop_revision=None, fetch_tags=None, limit=None):
1043
1079
        interrepo = _mod_repository.InterRepository.get(self.source.repository,
1044
 
            self.target.repository)
 
1080
                                                        self.target.repository)
1045
1081
        if stop_revision is None:
1046
1082
            stop_revision = self.source.last_revision()
1047
1083
        determine_wants = interrepo.get_determine_wants_revids(
1051
1087
    def _basic_push(self, overwrite=False, stop_revision=None):
1052
1088
        if overwrite is True:
1053
1089
            overwrite = set(["history", "tags"])
1054
 
        else:
 
1090
        elif not overwrite:
1055
1091
            overwrite = set()
1056
1092
        result = GitBranchPushResult()
1057
1093
        result.source_branch = self.source
1058
1094
        result.target_branch = self.target
1059
1095
        result.old_revid = self.target.last_revision()
1060
1096
        refs, stop_revision = self.update_refs(stop_revision)
1061
 
        self.target.generate_revision_history(stop_revision,
1062
 
                (result.old_revid if ("history" not in overwrite) else None),
1063
 
                other_branch=self.source)
1064
 
        tags_ret = self.source.tags.merge_to(self.target.tags,
 
1097
        self.target.generate_revision_history(
 
1098
            stop_revision,
 
1099
            (result.old_revid if ("history" not in overwrite) else None),
 
1100
            other_branch=self.source)
 
1101
        tags_ret = self.source.tags.merge_to(
 
1102
            self.target.tags,
1065
1103
            source_tag_refs=remote_refs_dict_to_tag_refs(refs),
1066
1104
            overwrite=("tags" in overwrite))
1067
1105
        if isinstance(tags_ret, tuple):
1073
1111
 
1074
1112
    def update_refs(self, stop_revision=None):
1075
1113
        interrepo = _mod_repository.InterRepository.get(
1076
 
                self.source.repository, self.target.repository)
 
1114
            self.source.repository, self.target.repository)
1077
1115
        c = self.source.get_config_stack()
1078
1116
        fetch_tags = c.get('branch.fetch_tags')
1079
1117
 
1080
1118
        if stop_revision is None:
1081
 
            refs = interrepo.fetch(branches=[b"HEAD"], include_tags=fetch_tags)
 
1119
            refs = interrepo.fetch(branches=[self.source.ref], include_tags=fetch_tags)
1082
1120
            try:
1083
 
                head = refs[b"HEAD"]
 
1121
                head = refs[self.source.ref]
1084
1122
            except KeyError:
1085
1123
                stop_revision = revision.NULL_REVISION
1086
1124
            else:
1087
1125
                stop_revision = self.target.lookup_foreign_revision_id(head)
1088
1126
        else:
1089
 
            refs = interrepo.fetch(revision_id=stop_revision, include_tags=fetch_tags)
 
1127
            refs = interrepo.fetch(
 
1128
                revision_id=stop_revision, include_tags=fetch_tags)
1090
1129
        return refs, stop_revision
1091
1130
 
1092
1131
    def pull(self, stop_revision=None, overwrite=False,
1096
1135
            raise errors.LocalRequiresBoundBranch()
1097
1136
        if overwrite is True:
1098
1137
            overwrite = set(["history", "tags"])
1099
 
        else:
 
1138
        elif not overwrite:
1100
1139
            overwrite = set()
1101
1140
 
1102
1141
        result = GitPullResult()
1105
1144
        with self.target.lock_write(), self.source.lock_read():
1106
1145
            result.old_revid = self.target.last_revision()
1107
1146
            refs, stop_revision = self.update_refs(stop_revision)
1108
 
            self.target.generate_revision_history(stop_revision,
1109
 
                    (result.old_revid if ("history" not in overwrite) else None),
1110
 
                    other_branch=self.source)
1111
 
            tags_ret = self.source.tags.merge_to(self.target.tags,
1112
 
                overwrite=("tags" in overwrite),
 
1147
            self.target.generate_revision_history(
 
1148
                stop_revision,
 
1149
                (result.old_revid if ("history" not in overwrite) else None),
 
1150
                other_branch=self.source)
 
1151
            tags_ret = self.source.tags.merge_to(
 
1152
                self.target.tags, overwrite=("tags" in overwrite),
1113
1153
                source_tag_refs=remote_refs_dict_to_tag_refs(refs))
1114
1154
            if isinstance(tags_ret, tuple):
1115
1155
                (result.tag_updates, result.tag_conflicts) = tags_ret
1125
1165
 
1126
1166
 
1127
1167
class InterToGitBranch(branch.GenericInterBranch):
1128
 
    """InterBranch implementation that pulls from a non-bzr into a Git branch."""
 
1168
    """InterBranch implementation that pulls into a Git branch."""
1129
1169
 
1130
1170
    def __init__(self, source, target):
1131
1171
        super(InterToGitBranch, self).__init__(source, target)
1132
1172
        self.interrepo = _mod_repository.InterRepository.get(source.repository,
1133
 
                                           target.repository)
 
1173
                                                             target.repository)
1134
1174
 
1135
1175
    @staticmethod
1136
1176
    def _get_branch_formats_to_test():
1158
1198
        if not isinstance(stop_revision, bytes):
1159
1199
            raise TypeError(stop_revision)
1160
1200
        main_ref = self.target.ref
1161
 
        refs = { main_ref: (None, stop_revision) }
 
1201
        refs = {main_ref: (None, stop_revision)}
1162
1202
        if fetch_tags is None:
1163
1203
            c = self.source.get_config_stack()
1164
1204
            fetch_tags = c.get('branch.fetch_tags')
1167
1207
                ref = tag_name_to_ref(name)
1168
1208
                if not check_ref_format(ref):
1169
1209
                    warning("skipping tag with invalid characters %s (%s)",
1170
 
                        name, ref)
 
1210
                            name, ref)
1171
1211
                    continue
1172
1212
                if fetch_tags:
1173
1213
                    # FIXME: Skip tags that are not in the ancestry
1180
1220
        result.tag_updates = {}
1181
1221
        result.tag_conflicts = []
1182
1222
        ret = dict(old_refs)
 
1223
 
1183
1224
        def ref_equals(refs, ref, git_sha, revid):
1184
1225
            try:
1185
1226
                value = refs[ref]
1187
1228
                return False
1188
1229
            if (value[0] is not None and
1189
1230
                git_sha is not None and
1190
 
                value[0] == git_sha):
 
1231
                    value[0] == git_sha):
1191
1232
                return True
1192
1233
            if (value[1] is not None and
1193
1234
                revid is not None and
1194
 
                value[1] == revid):
 
1235
                    value[1] == revid):
1195
1236
                return True
1196
 
            # FIXME: If one side only has the git sha available and the other only
1197
 
            # has the bzr revid, then this will cause us to show a tag as updated
1198
 
            # that hasn't actually been updated.
 
1237
            # FIXME: If one side only has the git sha available and the other
 
1238
            # only has the bzr revid, then this will cause us to show a tag as
 
1239
            # updated that hasn't actually been updated.
1199
1240
            return False
1200
1241
        # FIXME: Check for diverged branches
1201
1242
        for ref, (git_sha, revid) in viewitems(new_refs):
1223
1264
                    except ValueError:
1224
1265
                        pass
1225
1266
                    else:
1226
 
                        result.tag_conflicts.append((name, revid, ret[name][1]))
 
1267
                        result.tag_conflicts.append(
 
1268
                            (name, revid, ret[name][1]))
1227
1269
                else:
1228
1270
                    ret[ref] = (git_sha, revid)
1229
1271
        return ret
1230
1272
 
1231
 
    def fetch(self, stop_revision=None, fetch_tags=None, lossy=False, limit=None):
 
1273
    def fetch(self, stop_revision=None, fetch_tags=None, lossy=False,
 
1274
              limit=None):
1232
1275
        if stop_revision is None:
1233
1276
            stop_revision = self.source.last_revision()
1234
1277
        ret = []
1249
1292
        with self.source.lock_read(), self.target.lock_write():
1250
1293
            new_refs, main_ref, stop_revinfo = self._get_new_refs(
1251
1294
                stop_revision)
 
1295
 
1252
1296
            def update_refs(old_refs):
1253
1297
                return self._update_refs(result, old_refs, new_refs, overwrite)
1254
1298
            try:
1255
 
                result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
1256
 
                    update_refs, lossy=False)
 
1299
                result.revidmap, old_refs, new_refs = (
 
1300
                    self.interrepo.fetch_refs(update_refs, lossy=False))
1257
1301
            except NoPushSupport:
1258
1302
                raise errors.NoRoundtrippingSupport(self.source, self.target)
1259
 
            (old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
 
1303
            (old_sha1, result.old_revid) = old_refs.get(
 
1304
                main_ref, (ZERO_SHA, NULL_REVISION))
1260
1305
            if result.old_revid is None:
1261
 
                result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
 
1306
                result.old_revid = self.target.lookup_foreign_revision_id(
 
1307
                    old_sha1)
1262
1308
            result.new_revid = new_refs[main_ref][1]
1263
1309
            result.local_branch = None
1264
1310
            result.master_branch = self.target
1275
1321
        result.local_branch = None
1276
1322
        result.master_branch = result.target_branch
1277
1323
        with self.source.lock_read(), self.target.lock_write():
1278
 
            new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
 
1324
            new_refs, main_ref, stop_revinfo = self._get_new_refs(
 
1325
                stop_revision)
 
1326
 
1279
1327
            def update_refs(old_refs):
1280
1328
                return self._update_refs(result, old_refs, new_refs, overwrite)
1281
1329
            try:
1282
 
                result.revidmap, old_refs, new_refs = self.interrepo.fetch_refs(
1283
 
                    update_refs, lossy=lossy, overwrite=overwrite)
 
1330
                result.revidmap, old_refs, new_refs = (
 
1331
                    self.interrepo.fetch_refs(
 
1332
                        update_refs, lossy=lossy, overwrite=overwrite))
1284
1333
            except NoPushSupport:
1285
1334
                raise errors.NoRoundtrippingSupport(self.source, self.target)
1286
 
            (old_sha1, result.old_revid) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
 
1335
            (old_sha1, result.old_revid) = old_refs.get(
 
1336
                main_ref, (ZERO_SHA, NULL_REVISION))
1287
1337
            if result.old_revid is None:
1288
 
                result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
 
1338
                result.old_revid = self.target.lookup_foreign_revision_id(
 
1339
                    old_sha1)
1289
1340
            result.new_revid = new_refs[main_ref][1]
1290
 
            (result.new_original_revno, result.new_original_revid) = stop_revinfo
 
1341
            (result.new_original_revno,
 
1342
                result.new_original_revid) = stop_revinfo
1291
1343
            for hook in branch.Branch.hooks['post_push']:
1292
1344
                hook(result)
1293
1345
        return result