/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

Fix unpeel map.

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