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

  • Committer: Jelmer Vernooij
  • Date: 2020-03-22 20:02:36 UTC
  • mto: (7490.7.7 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200322200236-fsbl91ktcn6fcbdd
Fix tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/foreign.py
1
 
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2008-2012 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
 
18
17
"""Foreign branch utilities."""
19
18
 
20
 
 
21
 
from bzrlib.branch import (
 
19
from __future__ import absolute_import
 
20
 
 
21
 
 
22
from .branch import (
22
23
    Branch,
23
 
    InterBranch,
24
24
    )
25
 
from bzrlib.commands import Command, Option
26
 
from bzrlib.repository import Repository
27
 
from bzrlib.revision import Revision
28
 
from bzrlib.lazy_import import lazy_import
29
 
lazy_import(globals(), """
30
 
from bzrlib import (
 
25
from .repository import Repository
 
26
from .revision import Revision
 
27
from . import (
31
28
    errors,
32
 
    osutils,
33
29
    registry,
34
 
    transform,
35
30
    )
36
 
""")
 
31
 
37
32
 
38
33
class VcsMapping(object):
39
34
    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
85
80
        The factory must be a callable that takes one parameter: the key.
86
81
        It must produce an instance of VcsMapping when called.
87
82
        """
88
 
        if ":" in key:
 
83
        if b":" in key:
89
84
            raise ValueError("mapping name can not contain colon (:)")
90
85
        registry.Registry.register(self, key, factory, help)
91
86
 
112
107
    """
113
108
 
114
109
    def __init__(self, foreign_revid, mapping, *args, **kwargs):
115
 
        if not "inventory_sha1" in kwargs:
116
 
            kwargs["inventory_sha1"] = ""
 
110
        if "inventory_sha1" not in kwargs:
 
111
            kwargs["inventory_sha1"] = b""
117
112
        super(ForeignRevision, self).__init__(*args, **kwargs)
118
113
        self.foreign_revid = foreign_revid
119
114
        self.mapping = mapping
141
136
        :param foreign_revid: Foreign revision id.
142
137
        :return: Dictionary mapping string keys to string values.
143
138
        """
144
 
        return { }
 
139
        return {}
145
140
 
146
141
    def serialize_foreign_revid(self, foreign_revid):
147
142
        """Serialize a foreign revision id for this VCS.
148
143
 
149
144
        :param foreign_revid: Foreign revision id
150
 
        :return: Bytestring with serialized revid, will not contain any 
 
145
        :return: Bytestring with serialized revid, will not contain any
151
146
            newlines.
152
147
        """
153
148
        raise NotImplementedError(self.serialize_foreign_revid)
179
174
        :param revid: The bzr revision id
180
175
        :return: tuple with foreign revid and vcs mapping
181
176
        """
182
 
        if not ":" in revid or not "-" in revid:
 
177
        if b":" not in revid or b"-" not in revid:
183
178
            raise errors.InvalidRevisionId(revid, None)
184
179
        try:
185
 
            foreign_vcs = self.get(revid.split("-")[0])
 
180
            foreign_vcs = self.get(revid.split(b"-")[0].decode('ascii'))
186
181
        except KeyError:
187
182
            raise errors.InvalidRevisionId(revid, None)
188
183
        return foreign_vcs.mapping_registry.revision_id_bzr_to_foreign(revid)
232
227
    def __init__(self, mapping):
233
228
        self.mapping = mapping
234
229
        super(ForeignBranch, self).__init__()
235
 
 
236
 
 
237
 
def update_workingtree_fileids(wt, target_tree):
238
 
    """Update the file ids in a working tree based on another tree.
239
 
 
240
 
    :param wt: Working tree in which to update file ids
241
 
    :param target_tree: Tree to retrieve new file ids from, based on path
242
 
    """
243
 
    tt = transform.TreeTransform(wt)
244
 
    try:
245
 
        for f, p, c, v, d, n, k, e in target_tree.iter_changes(wt):
246
 
            if v == (True, False):
247
 
                trans_id = tt.trans_id_tree_path(p[0])
248
 
                tt.unversion_file(trans_id)
249
 
            elif v == (False, True):
250
 
                trans_id = tt.trans_id_tree_path(p[1])
251
 
                tt.version_file(f, trans_id)
252
 
        tt.apply()
253
 
    finally:
254
 
        tt.finalize()
255
 
    if len(wt.get_parent_ids()) == 1:
256
 
        wt.set_parent_trees([(target_tree.get_revision_id(), target_tree)])
257
 
    else:
258
 
        wt.set_last_revision(target_tree.get_revision_id())
259
 
 
260
 
 
261
 
class cmd_dpush(Command):
262
 
    __doc__ = """Push into a different VCS without any custom bzr metadata.
263
 
 
264
 
    This will afterwards rebase the local branch on the remote
265
 
    branch unless the --no-rebase option is used, in which case 
266
 
    the two branches will be out of sync after the push. 
267
 
    """
268
 
    hidden = True
269
 
    takes_args = ['location?']
270
 
    takes_options = [
271
 
        'remember',
272
 
        Option('directory',
273
 
               help='Branch to push from, '
274
 
               'rather than the one containing the working directory.',
275
 
               short_name='d',
276
 
               type=unicode,
277
 
               ),
278
 
        Option('no-rebase', help="Do not rebase after push."),
279
 
        Option('strict',
280
 
               help='Refuse to push if there are uncommitted changes in'
281
 
               ' the working tree, --no-strict disables the check.'),
282
 
        ]
283
 
 
284
 
    def run(self, location=None, remember=False, directory=None,
285
 
            no_rebase=False, strict=None):
286
 
        from bzrlib import urlutils
287
 
        from bzrlib.bzrdir import BzrDir
288
 
        from bzrlib.errors import BzrCommandError, NoWorkingTree
289
 
        from bzrlib.workingtree import WorkingTree
290
 
 
291
 
        if directory is None:
292
 
            directory = "."
293
 
        try:
294
 
            source_wt = WorkingTree.open_containing(directory)[0]
295
 
            source_branch = source_wt.branch
296
 
        except NoWorkingTree:
297
 
            source_branch = Branch.open(directory)
298
 
            source_wt = None
299
 
        if source_wt is not None:
300
 
            source_wt.check_changed_or_out_of_date(
301
 
                strict, 'dpush_strict',
302
 
                more_error='Use --no-strict to force the push.',
303
 
                more_warning='Uncommitted changes will not be pushed.')
304
 
        stored_loc = source_branch.get_push_location()
305
 
        if location is None:
306
 
            if stored_loc is None:
307
 
                raise BzrCommandError("No push location known or specified.")
308
 
            else:
309
 
                display_url = urlutils.unescape_for_display(stored_loc,
310
 
                        self.outf.encoding)
311
 
                self.outf.write("Using saved location: %s\n" % display_url)
312
 
                location = stored_loc
313
 
 
314
 
        bzrdir = BzrDir.open(location)
315
 
        target_branch = bzrdir.open_branch()
316
 
        target_branch.lock_write()
317
 
        try:
318
 
            try:
319
 
                push_result = source_branch.lossy_push(target_branch)
320
 
            except errors.LossyPushToSameVCS:
321
 
                raise BzrCommandError("%r and %r are in the same VCS, lossy "
322
 
                    "push not necessary. Please use regular push." %
323
 
                    (source_branch, target_branch))
324
 
            # We successfully created the target, remember it
325
 
            if source_branch.get_push_location() is None or remember:
326
 
                source_branch.set_push_location(target_branch.base)
327
 
            if not no_rebase:
328
 
                old_last_revid = source_branch.last_revision()
329
 
                source_branch.pull(target_branch, overwrite=True)
330
 
                new_last_revid = source_branch.last_revision()
331
 
                if source_wt is not None and old_last_revid != new_last_revid:
332
 
                    source_wt.lock_write()
333
 
                    try:
334
 
                        target = source_wt.branch.repository.revision_tree(
335
 
                            new_last_revid)
336
 
                        update_workingtree_fileids(source_wt, target)
337
 
                    finally:
338
 
                        source_wt.unlock()
339
 
            push_result.report(self.outf)
340
 
        finally:
341
 
            target_branch.unlock()
342
 
 
343
 
 
344
 
class InterToForeignBranch(InterBranch):
345
 
 
346
 
    def lossy_push(self, stop_revision=None):
347
 
        """Push deltas into another branch.
348
 
 
349
 
        :note: This does not, like push, retain the revision ids from 
350
 
            the source branch and will, rather than adding bzr-specific 
351
 
            metadata, push only those semantics of the revision that can be 
352
 
            natively represented by this branch' VCS.
353
 
 
354
 
        :param target: Target branch
355
 
        :param stop_revision: Revision to push, defaults to last revision.
356
 
        :return: BranchPushResult with an extra member revidmap: 
357
 
            A dictionary mapping revision ids from the target branch 
358
 
            to new revision ids in the target branch, for each 
359
 
            revision that was pushed.
360
 
        """
361
 
        raise NotImplementedError(self.lossy_push)