/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

Implement GitRevisionTree.get_file_sha1.

Show diffs side-by-side

added added

removed removed

Lines of Context:
branch.py
17
17
 
18
18
"""An adapter between a Git Branch and a Bazaar Branch"""
19
19
 
 
20
from collections import defaultdict
 
21
 
20
22
from dulwich.objects import (
21
23
    Commit,
22
24
    Tag,
 
25
    ZERO_SHA,
23
26
    )
24
27
 
25
28
from bzrlib import (
27
30
    bzrdir,
28
31
    config,
29
32
    errors,
30
 
    repository,
 
33
    repository as _mod_repository,
31
34
    revision,
32
35
    tag,
33
36
    transport,
51
54
    NoSuchRef,
52
55
    )
53
56
from bzrlib.plugins.git.refs import (
 
57
    branch_name_to_ref,
 
58
    extract_tags,
 
59
    is_tag,
54
60
    ref_to_branch_name,
55
 
    extract_tags,
 
61
    ref_to_tag_name,
56
62
    tag_name_to_ref,
 
63
    UnpeelMap,
57
64
    )
58
65
 
59
66
from bzrlib.foreign import ForeignBranch
76
83
        return self._lookup_revno(self.new_revid)
77
84
 
78
85
 
79
 
class LocalGitTagDict(tag.BasicTags):
80
 
    """Dictionary with tags in a local repository."""
 
86
class GitTags(tag.BasicTags):
 
87
    """Ref-based tag dictionary."""
81
88
 
82
89
    def __init__(self, branch):
83
90
        self.branch = branch
84
91
        self.repository = branch.repository
85
92
 
 
93
    def get_refs(self):
 
94
        raise NotImplementedError(self.get_refs)
 
95
 
 
96
    def _iter_tag_refs(self, refs):
 
97
        raise NotImplementedError(self._iter_tag_refs)
 
98
 
 
99
    def _merge_to_git(self, to_tags, refs, overwrite=False):
 
100
        target_repo = to_tags.repository
 
101
        conflicts = []
 
102
        for k, v in refs.iteritems():
 
103
            if not is_tag(k):
 
104
                continue
 
105
            if overwrite or not k in target_repo._git.refs:
 
106
                target_repo._git.refs[k] = v
 
107
            elif target_repo._git.refs[k] == v:
 
108
                pass
 
109
            else:
 
110
                conflicts.append((ref_to_tag_name(k), v, target_repo.refs[k]))
 
111
        return conflicts
 
112
 
 
113
    def _merge_to_non_git(self, to_tags, refs, overwrite=False):
 
114
        unpeeled_map = defaultdict(set)
 
115
        conflicts = []
 
116
        result = dict(to_tags.get_tag_dict())
 
117
        for n, peeled, unpeeled, bzr_revid in self._iter_tag_refs(refs):
 
118
            if unpeeled is not None:
 
119
                unpeeled_map[peeled].add(unpeeled)
 
120
            if n not in result or overwrite:
 
121
                result[n] = bzr_revid
 
122
            elif result[n] == bzr_revid:
 
123
                pass
 
124
            else:
 
125
                conflicts.append((n, result[n], bzr_revid))
 
126
        to_tags._set_tag_dict(result)
 
127
        if len(unpeeled_map) > 0:
 
128
            map_file = UnpeelMap.from_repository(to_tags.branch.repository)
 
129
            map_file.update(unpeeled_map)
 
130
            map_file.save_in_repository(to_tags.branch.repository)
 
131
        return conflicts
 
132
 
 
133
    def merge_to(self, to_tags, overwrite=False, ignore_master=False,
 
134
                 source_refs=None):
 
135
        """See Tags.merge_to."""
 
136
        if source_refs is None:
 
137
            source_refs = self.get_refs()
 
138
        if self == to_tags:
 
139
            return
 
140
        if isinstance(to_tags, GitTags):
 
141
            return self._merge_to_git(to_tags, source_refs,
 
142
                                      overwrite=overwrite)
 
143
        else:
 
144
            if ignore_master:
 
145
                master = None
 
146
            else:
 
147
                master = to_tags.branch.get_master_branch()
 
148
            conflicts = self._merge_to_non_git(to_tags, source_refs,
 
149
                                              overwrite=overwrite)
 
150
            if master is not None:
 
151
                conflicts += self.merge_to(master.tags, overwrite=overwrite,
 
152
                                           source_refs=source_refs,
 
153
                                           ignore_master=ignore_master)
 
154
            return conflicts
 
155
 
86
156
    def get_tag_dict(self):
87
157
        ret = {}
88
 
        for k,v in extract_tags(self.repository._git.get_refs()).iteritems():
 
158
        refs = self.get_refs()
 
159
        for (name, peeled, unpeeled, bzr_revid) in self._iter_tag_refs(refs):
 
160
            ret[name] = bzr_revid
 
161
        return ret
 
162
 
 
163
 
 
164
class LocalGitTagDict(GitTags):
 
165
    """Dictionary with tags in a local repository."""
 
166
 
 
167
    def __init__(self, branch):
 
168
        super(LocalGitTagDict, self).__init__(branch)
 
169
        self.refs = self.repository._git.refs
 
170
 
 
171
    def get_refs(self):
 
172
        return self.repository._git.get_refs()
 
173
 
 
174
    def _iter_tag_refs(self, refs):
 
175
        """Iterate over the tag refs.
 
176
 
 
177
        :param refs: Refs dictionary (name -> git sha1)
 
178
        :return: iterator over (name, peeled_sha1, unpeeled_sha1, bzr_revid)
 
179
        """
 
180
        for k, (peeled, unpeeled) in extract_tags(refs).iteritems():
89
181
            try:
90
 
                obj = self.repository._git[v]
 
182
                obj = self.repository._git[peeled]
91
183
            except KeyError:
92
 
                mutter("Tag %s points at unknown object %s, ignoring", v, obj)
 
184
                mutter("Tag %s points at unknown object %s, ignoring", peeled,
 
185
                       obj)
93
186
                continue
 
187
            # FIXME: this shouldn't really be necessary, the repository
 
188
            # already should have these unpeeled.
94
189
            while isinstance(obj, Tag):
95
 
                v = obj.object[1]
96
 
                obj = self.repository._git[v]
 
190
                peeled = obj.object[1]
 
191
                obj = self.repository._git[peeled]
97
192
            if not isinstance(obj, Commit):
98
193
                mutter("Tag %s points at object %r that is not a commit, "
99
194
                       "ignoring", k, obj)
100
195
                continue
101
 
            ret[k] = self.branch.lookup_foreign_revision_id(v)
102
 
        return ret
 
196
            yield (k, peeled, unpeeled,
 
197
                   self.branch.lookup_foreign_revision_id(peeled))
103
198
 
104
199
    def _set_tag_dict(self, to_dict):
105
 
        extra = set(self.repository._git.get_refs().keys())
 
200
        extra = set(self.get_refs().keys())
106
201
        for k, revid in to_dict.iteritems():
107
202
            name = tag_name_to_ref(k)
108
203
            if name in extra:
109
204
                extra.remove(name)
110
205
            self.set_tag(k, revid)
111
206
        for name in extra:
112
 
            if name.startswith("refs/tags/"):
 
207
            if is_tag(name):
113
208
                del self.repository._git[name]
114
209
 
115
210
    def set_tag(self, name, revid):
116
 
        self.repository._git.refs[tag_name_to_ref(name)], _ = \
 
211
        self.refs[tag_name_to_ref(name)], _ = \
117
212
            self.branch.lookup_bzr_revision_id(revid)
118
213
 
119
214
 
120
 
class DictTagDict(LocalGitTagDict):
 
215
class DictTagDict(tag.BasicTags):
121
216
 
122
217
    def __init__(self, branch, tags):
123
218
        super(DictTagDict, self).__init__(branch)
138
233
    def supports_tags(self):
139
234
        return True
140
235
 
 
236
    def supports_leaving_lock(self):
 
237
        return False
 
238
 
 
239
    @property
 
240
    def _matchingbzrdir(self):
 
241
        from bzrlib.plugins.git.dir import LocalGitControlDirFormat
 
242
        return LocalGitControlDirFormat()
 
243
 
141
244
    def get_foreign_tests_branch_factory(self):
142
245
        from bzrlib.plugins.git.tests.test_branch import ForeignTestsBranchFactory
143
246
        return ForeignTestsBranchFactory()
149
252
        else:
150
253
            return LocalGitTagDict(branch)
151
254
 
 
255
    def initialize(self, a_bzrdir, name=None, repository=None):
 
256
        from bzrlib.plugins.git.dir import LocalGitDir
 
257
        if not isinstance(a_bzrdir, LocalGitDir):
 
258
            raise errors.IncompatibleFormat(self, a_bzrdir._format)
 
259
        if repository is None:
 
260
            repository = a_bzrdir.open_repository()
 
261
        ref = branch_name_to_ref(name, "HEAD")
 
262
        repository._git[ref] = ZERO_SHA
 
263
        return LocalGitBranch(a_bzrdir, repository, ref, a_bzrdir._lockfiles)
 
264
 
152
265
 
153
266
class GitReadLock(object):
154
267
 
159
272
class GitWriteLock(object):
160
273
 
161
274
    def __init__(self, unlock):
 
275
        self.branch_token = None
162
276
        self.unlock = unlock
163
277
 
164
278
 
165
279
class GitBranch(ForeignBranch):
166
280
    """An adapter to git repositories for bzr Branch objects."""
167
281
 
 
282
    @property
 
283
    def control_transport(self):
 
284
        return self.bzrdir.control_transport
 
285
 
168
286
    def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
169
287
        self.repository = repository
170
288
        self._format = GitBranchFormat()
171
289
        self.control_files = lockfiles
172
290
        self.bzrdir = bzrdir
 
291
        self._lock_mode = None
 
292
        self._lock_count = 0
173
293
        super(GitBranch, self).__init__(repository.get_mapping())
174
294
        if tagsdict is not None:
175
295
            self.tags = DictTagDict(self, tagsdict)
208
328
            self.ref or "HEAD")
209
329
 
210
330
    def generate_revision_history(self, revid, old_revid=None):
211
 
        # FIXME: Check that old_revid is in the ancestry of revid
212
 
        newhead, self.mapping = self.mapping.revision_id_bzr_to_foreign(revid)
 
331
        if revid == NULL_REVISION:
 
332
            newhead = ZERO_SHA
 
333
        else:
 
334
            # FIXME: Check that old_revid is in the ancestry of revid
 
335
            newhead, self.mapping = self.mapping.revision_id_bzr_to_foreign(revid)
 
336
            if self.mapping is None:
 
337
                raise AssertionError
213
338
        self._set_head(newhead)
214
339
 
215
 
    def lock_write(self):
216
 
        self.control_files.lock_write()
 
340
    def lock_write(self, token=None):
 
341
        if token is not None:
 
342
            raise errors.TokenLockingNotSupported(self)
 
343
        if self._lock_mode:
 
344
            assert self._lock_mode == 'w'
 
345
            self._lock_count += 1
 
346
        else:
 
347
            self._lock_mode = 'w'
 
348
            self._lock_count = 1
 
349
        self.repository.lock_write()
217
350
        return GitWriteLock(self.unlock)
218
351
 
219
352
    def get_stacked_on_url(self):
230
363
        pass
231
364
 
232
365
    def lock_read(self):
233
 
        self.control_files.lock_read()
 
366
        if self._lock_mode:
 
367
            assert self._lock_mode in ('r', 'w')
 
368
            self._lock_count += 1
 
369
        else:
 
370
            self._lock_mode = 'r'
 
371
            self._lock_count = 1
 
372
        self.repository.lock_read()
234
373
        return GitReadLock(self.unlock)
235
374
 
 
375
    def peek_lock_mode(self):
 
376
        return self._lock_mode
 
377
 
236
378
    def is_locked(self):
237
 
        return self.control_files.is_locked()
 
379
        return (self._lock_mode is not None)
238
380
 
239
381
    def unlock(self):
240
 
        self.control_files.unlock()
 
382
        """See Branch.unlock()."""
 
383
        self._lock_count -= 1
 
384
        if self._lock_count == 0:
 
385
            self._lock_mode = None
 
386
            self._clear_cached_state()
 
387
        self.repository.unlock()
241
388
 
242
389
    def get_physical_lock_status(self):
243
390
        return False
265
412
class LocalGitBranch(GitBranch):
266
413
    """A local Git branch."""
267
414
 
268
 
    def __init__(self, bzrdir, repository, name, lockfiles, tagsdict=None):
269
 
        super(LocalGitBranch, self).__init__(bzrdir, repository, name,
 
415
    def __init__(self, bzrdir, repository, ref, lockfiles, tagsdict=None):
 
416
        super(LocalGitBranch, self).__init__(bzrdir, repository, ref,
270
417
              lockfiles, tagsdict)
271
418
        refs = repository._git.get_refs()
272
 
        if not (name in refs.keys() or "HEAD" in refs.keys()):
 
419
        if not (ref in refs.keys() or "HEAD" in refs.keys()):
273
420
            raise errors.NotBranchError(self.base)
274
421
 
275
422
    def create_checkout(self, to_location, revision_id=None, lightweight=False,
320
467
        except KeyError:
321
468
            return None
322
469
 
323
 
    def set_last_revision_info(self, revno, revid):
324
 
        self.set_last_revision(revid)
 
470
    def _read_last_revision_info(self):
 
471
        last_revid = self.last_revision()
 
472
        graph = self.repository.get_graph()
 
473
        revno = graph.find_distance_to_null(last_revid,
 
474
            [(revision.NULL_REVISION, 0)])
 
475
        return revno, last_revid
 
476
 
 
477
    def set_last_revision_info(self, revno, revision_id):
 
478
        self.set_last_revision(revision_id)
 
479
        self._last_revision_info_cache = revno, revision_id
325
480
 
326
481
    def set_last_revision(self, revid):
327
 
        (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
328
 
        self.head = newhead
 
482
        if not revid or not isinstance(revid, basestring):
 
483
            raise errors.InvalidRevisionId(revision_id=revid, branch=self)
 
484
        if revid == NULL_REVISION:
 
485
            newhead = ZERO_SHA
 
486
        else:
 
487
            (newhead, self.mapping) = self.repository.lookup_bzr_revision_id(revid)
 
488
            if self.mapping is None:
 
489
                raise AssertionError
 
490
        self._set_head(newhead)
329
491
 
330
492
    def _set_head(self, value):
331
493
        self._head = value
351
513
        return True
352
514
 
353
515
 
 
516
def _quick_lookup_revno(local_branch, remote_branch, revid):
 
517
    assert isinstance(revid, str), "was %r" % revid
 
518
    # Try in source branch first, it'll be faster
 
519
    try:
 
520
        return local_branch.revision_id_to_revno(revid)
 
521
    except errors.NoSuchRevision:
 
522
        graph = local_branch.repository.get_graph()
 
523
        try:
 
524
            return graph.find_distance_to_null(revid)
 
525
        except errors.GhostRevisionsHaveNoRevno:
 
526
            # FIXME: Check using graph.find_distance_to_null() ?
 
527
            return remote_branch.revision_id_to_revno(revid)
 
528
 
 
529
 
354
530
class GitBranchPullResult(branch.PullResult):
355
531
 
356
532
    def __init__(self):
371
547
        self._show_tag_conficts(to_file)
372
548
 
373
549
    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)
 
550
        return _quick_lookup_revno(self.target_branch, self.source_branch,
 
551
                revid)
381
552
 
382
553
    def _get_old_revno(self):
383
554
        if self._old_revno is not None:
403
574
class GitBranchPushResult(branch.BranchPushResult):
404
575
 
405
576
    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)
 
577
        return _quick_lookup_revno(self.source_branch, self.target_branch,
 
578
            revid)
413
579
 
414
580
    @property
415
581
    def old_revno(self):
417
583
 
418
584
    @property
419
585
    def new_revno(self):
 
586
        new_original_revno = getattr(self, "new_original_revno", None)
 
587
        if new_original_revno:
 
588
            return new_original_revno
 
589
        if getattr(self, "new_original_revid", None) is not None:
 
590
            return self._lookup_revno(self.new_original_revid)
420
591
        return self._lookup_revno(self.new_revid)
421
592
 
422
593
 
425
596
 
426
597
    @staticmethod
427
598
    def _get_branch_formats_to_test():
428
 
        return []
 
599
        try:
 
600
            default_format = branch.format_registry.get_default()
 
601
        except AttributeError:
 
602
            default_format = branch.BranchFormat._default_format
 
603
        return [
 
604
            (GitBranchFormat(), GitBranchFormat()),
 
605
            (GitBranchFormat(), default_format)]
429
606
 
430
607
    @classmethod
431
608
    def _get_interrepo(self, source, target):
432
 
        return repository.InterRepository.get(source.repository,
433
 
            target.repository)
 
609
        return _mod_repository.InterRepository.get(source.repository, target.repository)
434
610
 
435
611
    @classmethod
436
612
    def is_compatible(cls, source, target):
437
 
        return (isinstance(source, GitBranch) and
438
 
                not isinstance(target, GitBranch) and
439
 
                (getattr(cls._get_interrepo(source, target), "fetch_objects", None) is not None))
440
 
 
441
 
    def _update_revisions(self, stop_revision=None, overwrite=False,
442
 
        graph=None, limit=None):
443
 
        """Like InterBranch.update_revisions(), but with additions.
444
 
 
445
 
        Compared to the `update_revisions()` below, this function takes a
446
 
        `limit` argument that limits how many git commits will be converted
447
 
        and returns the new git head.
448
 
        """
 
613
        if not isinstance(source, GitBranch):
 
614
            return False
 
615
        if isinstance(target, GitBranch):
 
616
            # InterLocalGitRemoteGitBranch or InterToGitBranch should be used
 
617
            return False
 
618
        if getattr(cls._get_interrepo(source, target), "fetch_objects", None) is None:
 
619
            # fetch_objects is necessary for this to work
 
620
            return False
 
621
        return True
 
622
 
 
623
    def fetch(self, stop_revision=None, fetch_tags=True):
 
624
        self.fetch_objects(stop_revision, fetch_tags=fetch_tags)
 
625
 
 
626
    def fetch_objects(self, stop_revision, fetch_tags):
449
627
        interrepo = self._get_interrepo(self.source, self.target)
450
628
        def determine_wants(heads):
451
629
            if self.source.ref is not None and not self.source.ref in heads:
452
630
                raise NoSuchRef(self.source.ref, heads.keys())
453
 
            if stop_revision is not None:
454
 
                self._last_revid = stop_revision
455
 
                head, mapping = self.source.repository.lookup_bzr_revision_id(
456
 
                    stop_revision)
457
 
            else:
 
631
 
 
632
            if stop_revision is None:
458
633
                if self.source.ref is not None:
459
634
                    head = heads[self.source.ref]
460
635
                else:
461
636
                    head = heads["HEAD"]
462
637
                self._last_revid = self.source.lookup_foreign_revision_id(head)
463
 
            if self.target.repository.has_revision(self._last_revid):
464
 
                return []
465
 
            return [head]
 
638
            else:
 
639
                self._last_revid = stop_revision
 
640
            real = interrepo.get_determine_wants_revids(
 
641
                [self._last_revid], include_tags=fetch_tags)
 
642
            return real(heads)
466
643
        pack_hint, head, refs = interrepo.fetch_objects(
467
 
            determine_wants, self.source.mapping, limit=limit)
 
644
            determine_wants, self.source.mapping)
468
645
        if (pack_hint is not None and
469
646
            self.target.repository._format.pack_compresses):
470
647
            self.target.repository.pack(hint=pack_hint)
471
 
        if head is not None:
472
 
            self._last_revid = self.source.lookup_foreign_revision_id(head)
 
648
        return head, refs
 
649
 
 
650
    def _update_revisions(self, stop_revision=None, overwrite=False):
 
651
        head, refs = self.fetch_objects(stop_revision, fetch_tags=True)
473
652
        if overwrite:
474
653
            prev_last_revid = None
475
654
        else:
476
655
            prev_last_revid = self.target.last_revision()
477
656
        self.target.generate_revision_history(self._last_revid,
478
 
            prev_last_revid)
479
 
        return head
480
 
 
481
 
    def update_revisions(self, stop_revision=None, overwrite=False,
482
 
                         graph=None):
483
 
        """See InterBranch.update_revisions()."""
484
 
        self._update_revisions(stop_revision, overwrite, graph)
 
657
            prev_last_revid, self.source)
 
658
        return head, refs
485
659
 
486
660
    def pull(self, overwrite=False, stop_revision=None,
487
661
             possible_transports=None, _hook_master=None, run_hooks=True,
488
 
             _override_hook_target=None, local=False, limit=None):
 
662
             _override_hook_target=None, local=False):
489
663
        """See Branch.pull.
490
664
 
491
665
        :param _hook_master: Private parameter - set the branch to
495
669
            so it should not run its hooks.
496
670
        :param _override_hook_target: Private parameter - set the branch to be
497
671
            supplied as the target_branch to pull hooks.
498
 
        :param limit: Only import this many revisons.  `None`, the default,
499
 
            means import all revisions.
500
672
        """
501
673
        # This type of branch can't be bound.
502
674
        if local:
511
683
        try:
512
684
            # We assume that during 'pull' the target repository is closer than
513
685
            # the source one.
514
 
            graph = self.target.repository.get_graph(self.source.repository)
515
686
            (result.old_revno, result.old_revid) = \
516
687
                self.target.last_revision_info()
517
 
            result.new_git_head = self._update_revisions(
518
 
                stop_revision, overwrite=overwrite, graph=graph, limit=limit)
 
688
            result.new_git_head, remote_refs = self._update_revisions(
 
689
                stop_revision, overwrite=overwrite)
519
690
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
520
691
                overwrite)
521
692
            (result.new_revno, result.new_revid) = \
537
708
        result = branch.BranchPushResult()
538
709
        result.source_branch = self.source
539
710
        result.target_branch = self.target
540
 
        graph = self.target.repository.get_graph(self.source.repository)
541
711
        result.old_revno, result.old_revid = self.target.last_revision_info()
542
 
        result.new_git_head = self._update_revisions(
543
 
            stop_revision, overwrite=overwrite, graph=graph)
 
712
        result.new_git_head, remote_refs = self._update_revisions(
 
713
            stop_revision, overwrite=overwrite)
544
714
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
545
715
            overwrite)
546
716
        result.new_revno, result.new_revid = self.target.last_revision_info()
551
721
    """InterBranch implementation that pulls between Git branches."""
552
722
 
553
723
 
554
 
class InterGitLocalRemoteBranch(InterGitBranch):
 
724
class InterLocalGitRemoteGitBranch(InterGitBranch):
555
725
    """InterBranch that copies from a local to a remote git branch."""
556
726
 
557
727
    @staticmethod
558
728
    def _get_branch_formats_to_test():
 
729
        # FIXME
559
730
        return []
560
731
 
561
732
    @classmethod
565
736
                isinstance(target, RemoteGitBranch))
566
737
 
567
738
    def _basic_push(self, overwrite=False, stop_revision=None):
568
 
        from dulwich.protocol import ZERO_SHA
569
739
        result = GitBranchPushResult()
570
740
        result.source_branch = self.source
571
741
        result.target_branch = self.target
584
754
        return result
585
755
 
586
756
 
587
 
class InterGitRemoteLocalBranch(InterGitBranch):
 
757
class InterGitLocalGitBranch(InterGitBranch):
588
758
    """InterBranch that copies from a remote to a local git branch."""
589
759
 
590
760
    @staticmethod
591
761
    def _get_branch_formats_to_test():
 
762
        # FIXME
592
763
        return []
593
764
 
594
765
    @classmethod
595
766
    def is_compatible(self, source, target):
596
 
        from bzrlib.plugins.git.remote import RemoteGitBranch
597
 
        return (isinstance(source, RemoteGitBranch) and
 
767
        return (isinstance(source, GitBranch) and
598
768
                isinstance(target, LocalGitBranch))
599
769
 
600
770
    def _basic_push(self, overwrite=False, stop_revision=None):
604
774
        result.old_revid = self.target.last_revision()
605
775
        refs, stop_revision = self.update_refs(stop_revision)
606
776
        self.target.generate_revision_history(stop_revision, result.old_revid)
607
 
        self.update_tags(refs)
 
777
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
778
            source_refs=refs, overwrite=overwrite)
608
779
        result.new_revid = self.target.last_revision()
609
780
        return result
610
781
 
611
 
    def update_tags(self, refs):
612
 
        for name, v in extract_tags(refs).iteritems():
613
 
            revid = self.target.lookup_foreign_revision_id(v)
614
 
            self.target.tags.set_tag(name, revid)
615
 
 
616
782
    def update_refs(self, stop_revision=None):
617
 
        interrepo = repository.InterRepository.get(self.source.repository,
 
783
        interrepo = _mod_repository.InterRepository.get(self.source.repository,
618
784
            self.target.repository)
619
785
        if stop_revision is None:
620
786
            refs = interrepo.fetch(branches=["HEAD"])
634
800
        result.old_revid = self.target.last_revision()
635
801
        refs, stop_revision = self.update_refs(stop_revision)
636
802
        self.target.generate_revision_history(stop_revision, result.old_revid)
637
 
        self.update_tags(refs)
 
803
        result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
804
            overwrite=overwrite, source_refs=refs)
638
805
        result.new_revid = self.target.last_revision()
639
806
        return result
640
807
 
641
808
 
642
809
class InterToGitBranch(branch.GenericInterBranch):
643
 
    """InterBranch implementation that pulls from Git into bzr."""
 
810
    """InterBranch implementation that pulls into a Git branch."""
644
811
 
645
812
    def __init__(self, source, target):
646
813
        super(InterToGitBranch, self).__init__(source, target)
647
 
        self.interrepo = repository.InterRepository.get(source.repository,
 
814
        self.interrepo = _mod_repository.InterRepository.get(source.repository,
648
815
                                           target.repository)
649
816
 
650
817
    @staticmethod
651
818
    def _get_branch_formats_to_test():
652
 
        return []
 
819
        try:
 
820
            default_format = branch.format_registry.get_default()
 
821
        except AttributeError:
 
822
            default_format = branch.BranchFormat._default_format
 
823
        return [(default_format, GitBranchFormat())]
653
824
 
654
825
    @classmethod
655
826
    def is_compatible(self, source, target):
656
827
        return (not isinstance(source, GitBranch) and
657
828
                isinstance(target, GitBranch))
658
829
 
659
 
    def update_revisions(self, *args, **kwargs):
660
 
        raise NoPushSupport()
661
 
 
662
830
    def _get_new_refs(self, stop_revision=None):
663
831
        if stop_revision is None:
664
 
            stop_revision = self.source.last_revision()
 
832
            (stop_revno, stop_revision) = self.source.last_revision_info()
 
833
        else:
 
834
            stop_revno = self.source.revision_id_to_revno(stop_revision)
665
835
        assert type(stop_revision) is str
666
836
        main_ref = self.target.ref or "refs/heads/master"
667
837
        refs = { main_ref: (None, stop_revision) }
668
838
        for name, revid in self.source.tags.get_tag_dict().iteritems():
669
839
            if self.source.repository.has_revision(revid):
670
840
                refs[tag_name_to_ref(name)] = (None, revid)
671
 
        return refs, main_ref
 
841
        return refs, main_ref, (stop_revno, stop_revision)
672
842
 
673
843
    def pull(self, overwrite=False, stop_revision=None, local=False,
674
 
             possible_transports=None):
675
 
        from dulwich.protocol import ZERO_SHA
 
844
             possible_transports=None, run_hooks=True):
676
845
        result = GitBranchPullResult()
677
846
        result.source_branch = self.source
678
847
        result.target_branch = self.target
679
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
848
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
680
849
        def update_refs(old_refs):
681
850
            refs = dict(old_refs)
682
851
            # FIXME: Check for diverged branches
683
852
            refs.update(new_refs)
684
853
            return refs
685
 
        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]
 
854
        try:
 
855
            old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
 
856
        except NoPushSupport:
 
857
            raise errors.NoRoundtrippingSupport(self.source, self.target)
 
858
        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
 
859
        if result.old_revid is None:
 
860
            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
 
861
        result.new_revid = new_refs[main_ref][1]
689
862
        return result
690
863
 
691
864
    def push(self, overwrite=False, stop_revision=None,
692
865
             _override_hook_source_branch=None):
693
 
        from dulwich.protocol import ZERO_SHA
694
866
        result = GitBranchPushResult()
695
867
        result.source_branch = self.source
696
868
        result.target_branch = self.target
697
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
869
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
698
870
        def update_refs(old_refs):
699
871
            refs = dict(old_refs)
700
872
            # FIXME: Check for diverged branches
701
873
            refs.update(new_refs)
702
874
            return refs
703
 
        old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
 
875
        try:
 
876
            old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
 
877
        except NoPushSupport:
 
878
            raise errors.NoRoundtrippingSupport(self.source, self.target)
704
879
        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
705
880
        if result.old_revid is None:
706
881
            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
707
 
        result.new_revid = new_refs[main_ref]
 
882
        result.new_revid = new_refs[main_ref][1]
708
883
        return result
709
884
 
710
885
    def lossy_push(self, stop_revision=None):
711
886
        result = GitBranchPushResult()
712
887
        result.source_branch = self.source
713
888
        result.target_branch = self.target
714
 
        new_refs, main_ref = self._get_new_refs(stop_revision)
 
889
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
715
890
        def update_refs(old_refs):
716
891
            refs = dict(old_refs)
717
892
            # FIXME: Check for diverged branches
721
896
            update_refs)
722
897
        result.old_revid = old_refs.get(self.target.ref, (None, NULL_REVISION))[1]
723
898
        result.new_revid = new_refs[main_ref][1]
 
899
        (result.new_original_revno, result.new_original_revid) = stop_revinfo
724
900
        return result
725
901
 
726
902
 
727
 
branch.InterBranch.register_optimiser(InterGitRemoteLocalBranch)
 
903
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)
728
904
branch.InterBranch.register_optimiser(InterFromGitBranch)
729
905
branch.InterBranch.register_optimiser(InterToGitBranch)
730
 
branch.InterBranch.register_optimiser(InterGitLocalRemoteBranch)
 
906
branch.InterBranch.register_optimiser(InterLocalGitRemoteGitBranch)