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

Fix tests, split up InterGitNonGitRepository.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fetch.py
304
304
 
305
305
 
306
306
class InterGitNonGitRepository(InterRepository):
307
 
    """InterRepository that copies revisions from a Git into a non-Git 
 
307
    """Base InterRepository that copies revisions from a Git into a non-Git 
308
308
    repository."""
309
309
 
310
310
    _matching_repo_format = GitRepositoryFormat()
317
317
        """See InterRepository.copy_content."""
318
318
        self.fetch(revision_id, pb, find_ghosts=False)
319
319
 
320
 
    def fetch_objects(self, determine_wants, mapping, pb=None):
321
 
        def progress(text):
322
 
            pb.update("git: %s" % text.rstrip("\r\n"), 0, 0)
323
 
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
324
 
        create_pb = None
325
 
        if pb is None:
326
 
            create_pb = pb = ui.ui_factory.nested_progress_bar()
327
 
        target_git_object_retriever = GitObjectConverter(self.target, mapping)
328
 
        recorded_wants = []
329
 
 
330
 
        def record_determine_wants(heads):
331
 
            wants = determine_wants(heads)
332
 
            recorded_wants.extend(wants)
333
 
            return wants
334
 
        
335
 
        try:
336
 
            self.target.lock_write()
337
 
            try:
338
 
                self.target.start_write_group()
339
 
                try:
340
 
                    objects_iter = self.source.fetch_objects(
341
 
                                record_determine_wants, 
342
 
                                graph_walker, 
343
 
                                target_git_object_retriever.__getitem__, 
344
 
                                progress)
345
 
                    import_git_objects(self.target, mapping, objects_iter, 
346
 
                            target_git_object_retriever, recorded_wants, pb)
347
 
                finally:
348
 
                    self.target.commit_write_group()
349
 
            finally:
350
 
                self.target.unlock()
351
 
        finally:
352
 
            if create_pb:
353
 
                create_pb.finished()
354
 
 
355
320
    def fetch(self, revision_id=None, pb=None, find_ghosts=False, mapping=None,
356
321
            fetch_spec=None):
357
322
        self.fetch_refs(revision_id=revision_id, pb=pb, find_ghosts=find_ghosts,
378
343
        self.fetch_objects(determine_wants, mapping, pb)
379
344
        return self._refs
380
345
 
381
 
    @staticmethod
382
 
    def is_compatible(source, target):
383
 
        """Be compatible with GitRepository."""
384
 
        # FIXME: Also check target uses VersionedFile
385
 
        return (isinstance(source, GitRepository) and 
 
346
 
 
347
 
 
348
class InterRemoteGitNonGitRepository(InterGitNonGitRepository):
 
349
    """InterRepository that copies revisions from a remote Git into a non-Git 
 
350
    repository."""
 
351
 
 
352
    def fetch_objects(self, determine_wants, mapping, pb=None):
 
353
        def progress(text):
 
354
            pb.update("git: %s" % text.rstrip("\r\n"), 0, 0)
 
355
        graph_walker = BzrFetchGraphWalker(self.target, mapping)
 
356
        create_pb = None
 
357
        if pb is None:
 
358
            create_pb = pb = ui.ui_factory.nested_progress_bar()
 
359
        target_git_object_retriever = GitObjectConverter(self.target, mapping)
 
360
        recorded_wants = []
 
361
 
 
362
        def record_determine_wants(heads):
 
363
            wants = determine_wants(heads)
 
364
            recorded_wants.extend(wants)
 
365
            return wants
 
366
        
 
367
        try:
 
368
            self.target.lock_write()
 
369
            try:
 
370
                self.target.start_write_group()
 
371
                try:
 
372
                    objects_iter = self.source.fetch_objects(
 
373
                                record_determine_wants, 
 
374
                                graph_walker, 
 
375
                                target_git_object_retriever.__getitem__, 
 
376
                                progress)
 
377
                    import_git_objects(self.target, mapping, objects_iter, 
 
378
                            target_git_object_retriever, recorded_wants, pb)
 
379
                finally:
 
380
                    self.target.commit_write_group()
 
381
            finally:
 
382
                self.target.unlock()
 
383
        finally:
 
384
            if create_pb:
 
385
                create_pb.finished()
 
386
 
 
387
    @staticmethod
 
388
    def is_compatible(source, target):
 
389
        """Be compatible with GitRepository."""
 
390
        # FIXME: Also check target uses VersionedFile
 
391
        return (isinstance(source, RemoteGitRepository) and 
 
392
                target.supports_rich_root() and
 
393
                not isinstance(target, GitRepository))
 
394
 
 
395
 
 
396
class InterLocalGitNonGitRepository(InterGitNonGitRepository):
 
397
    """InterRepository that copies revisions from a remote Git into a non-Git 
 
398
    repository."""
 
399
 
 
400
    def fetch_objects(self, determine_wants, mapping, pb=None):
 
401
        wants = determine_wants(self.source._git.get_refs())
 
402
        create_pb = None
 
403
        if pb is None:
 
404
            create_pb = pb = ui.ui_factory.nested_progress_bar()
 
405
        target_git_object_retriever = GitObjectConverter(self.target, mapping)
 
406
        try:
 
407
            self.target.lock_write()
 
408
            try:
 
409
                self.target.start_write_group()
 
410
                try:
 
411
                    import_git_objects(self.target, mapping, 
 
412
                            self.source._git.object_store, 
 
413
                            target_git_object_retriever, wants, pb)
 
414
                finally:
 
415
                    self.target.commit_write_group()
 
416
            finally:
 
417
                self.target.unlock()
 
418
        finally:
 
419
            if create_pb:
 
420
                create_pb.finished()
 
421
 
 
422
    @staticmethod
 
423
    def is_compatible(source, target):
 
424
        """Be compatible with GitRepository."""
 
425
        # FIXME: Also check target uses VersionedFile
 
426
        return (isinstance(source, LocalGitRepository) and 
386
427
                target.supports_rich_root() and
387
428
                not isinstance(target, GitRepository))
388
429