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

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2020-07-28 02:47:10 UTC
  • mfrom: (7519.1.1 merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200728024710-a2ylds219f1lsl62
Merge lp:brz/3.1.

Merged from https://code.launchpad.net/~jelmer/brz/merge-3.1/+merge/388173

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/repository.py
17
17
 
18
18
"""An adapter between a Git Repository and a Bazaar Branch"""
19
19
 
20
 
from __future__ import absolute_import
21
 
 
22
20
from .. import (
23
21
    check,
24
22
    errors,
34
32
from ..foreign import (
35
33
    ForeignRepository,
36
34
    )
37
 
from ..sixish import (
38
 
    viewitems,
39
 
    viewvalues,
40
 
    )
41
35
 
42
 
from .commit import (
43
 
    GitCommitBuilder,
44
 
    )
45
36
from .filegraph import (
46
37
    GitFileLastChangeScanner,
47
38
    GitFileParentProvider,
48
39
    )
49
40
from .mapping import (
50
41
    default_mapping,
 
42
    encode_git_path,
51
43
    foreign_vcs_git,
52
44
    mapping_registry,
53
45
    )
106
98
            self._report_repo_results(verbose)
107
99
 
108
100
 
109
 
_optimisers_loaded = False
110
 
 
111
 
 
112
 
def lazy_load_optimisers():
113
 
    global _optimisers_loaded
114
 
    if _optimisers_loaded:
115
 
        return
116
 
    from . import interrepo
117
 
    for optimiser in [interrepo.InterRemoteGitNonGitRepository,
118
 
                      interrepo.InterLocalGitNonGitRepository,
119
 
                      interrepo.InterLocalGitLocalGitRepository,
120
 
                      interrepo.InterRemoteGitLocalGitRepository,
121
 
                      interrepo.InterToLocalGitRepository,
122
 
                      interrepo.InterToRemoteGitRepository,
123
 
                      ]:
124
 
        repository.InterRepository.register_optimiser(optimiser)
125
 
    _optimisers_loaded = True
 
101
for optimiser in ['InterRemoteGitNonGitRepository',
 
102
                  'InterLocalGitNonGitRepository',
 
103
                  'InterLocalGitLocalGitRepository',
 
104
                  'InterRemoteGitLocalGitRepository',
 
105
                  'InterToLocalGitRepository',
 
106
                  'InterToRemoteGitRepository',
 
107
                  ]:
 
108
    repository.InterRepository.register_lazy_optimiser(
 
109
        'breezy.git.interrepo', optimiser)
126
110
 
127
111
 
128
112
class GitRepository(ForeignRepository):
137
121
        super(GitRepository, self).__init__(GitRepositoryFormat(),
138
122
                                            gitdir, control_files=None)
139
123
        self.base = gitdir.root_transport.base
140
 
        lazy_load_optimisers()
141
124
        self._lock_mode = None
142
125
        self._lock_count = 0
143
126
 
265
248
        :param lossy: Whether to discard data that can not be natively
266
249
            represented, when pushing to a foreign VCS
267
250
        """
 
251
        from .commit import (
 
252
            GitCommitBuilder,
 
253
            )
268
254
        builder = GitCommitBuilder(
269
255
            self, parents, config, timestamp, timezone, committer, revprops,
270
256
            revision_id, lossy)
298
284
        for (file_id, revision_id, identifier) in desired_files:
299
285
            per_revision.setdefault(revision_id, []).append(
300
286
                (file_id, identifier))
301
 
        for revid, files in viewitems(per_revision):
 
287
        for revid, files in per_revision.items():
302
288
            try:
303
289
                (commit_id, mapping) = self.lookup_bzr_revision_id(revid)
304
290
            except errors.NoSuchRevision:
316
302
                try:
317
303
                    obj = tree_lookup_path(
318
304
                        self._git.object_store.__getitem__, root_tree,
319
 
                        path.encode('utf-8'))
 
305
                        encode_git_path(path))
320
306
                    if isinstance(obj, tuple):
321
307
                        (mode, item_id) = obj
322
308
                        obj = self._git.object_store[item_id]
410
396
                    this_parent_map[revid] = parents
411
397
            parent_map.update(this_parent_map)
412
398
            pending = set()
413
 
            for values in viewvalues(this_parent_map):
 
399
            for values in this_parent_map.values():
414
400
                pending.update(values)
415
401
            pending = pending.difference(parent_map)
416
402
        return _mod_graph.KnownGraph(parent_map)
559
545
            raise ValueError('invalid revision id %s' % revision_id)
560
546
        return GitRevisionTree(self, revision_id)
561
547
 
562
 
    def get_deltas_for_revisions(self, revisions, specific_fileids=None):
563
 
        """Produce a generator of revision deltas.
564
 
 
565
 
        Note that the input is a sequence of REVISIONS, not revision_ids.
566
 
        Trees will be held in memory until the generator exits.
567
 
        Each delta is relative to the revision's lefthand predecessor.
568
 
 
569
 
        :param specific_fileids: if not None, the result is filtered
570
 
          so that only those file-ids, their parents and their
571
 
          children are included.
572
 
        """
573
 
        # Get the revision-ids of interest
574
 
        required_trees = set()
575
 
        for revision in revisions:
576
 
            required_trees.add(revision.revision_id)
577
 
            required_trees.update(revision.parent_ids[:1])
578
 
 
579
 
        trees = dict((t.get_revision_id(), t) for
580
 
                     t in self.revision_trees(required_trees))
581
 
 
582
 
        # Calculate the deltas
583
 
        for revision in revisions:
584
 
            if not revision.parent_ids:
585
 
                old_tree = self.revision_tree(_mod_revision.NULL_REVISION)
586
 
            else:
587
 
                old_tree = trees[revision.parent_ids[0]]
588
 
            new_tree = trees[revision.revision_id]
589
 
            if specific_fileids is not None:
590
 
                specific_files = [new_tree.id2path(
591
 
                    fid) for fid in specific_fileids]
592
 
            else:
593
 
                specific_files = None
594
 
            yield new_tree.changes_from(
595
 
                old_tree, specific_files=specific_files)
596
 
 
597
548
    def set_make_working_trees(self, trees):
598
549
        raise errors.UnsupportedOperation(self.set_make_working_trees, self)
599
550