/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-05-06 02:13:25 UTC
  • mfrom: (7490.7.21 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200506021325-awbmmqu1zyorz7sj
Merge 3.1 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/foreign.py
16
16
 
17
17
"""Foreign branch utilities."""
18
18
 
19
 
from __future__ import absolute_import
20
 
 
21
 
 
22
19
from .branch import (
23
20
    Branch,
24
21
    )
25
 
from .commands import Command, Option
26
22
from .repository import Repository
27
23
from .revision import Revision
28
 
from .sixish import (
29
 
    text_type,
30
 
    )
31
 
from .lazy_import import lazy_import
32
 
lazy_import(globals(), """
33
 
from breezy import (
 
24
from . import (
34
25
    errors,
35
26
    registry,
36
 
    transform,
37
27
    )
38
 
from breezy.i18n import gettext
39
 
""")
 
28
 
40
29
 
41
30
class VcsMapping(object):
42
31
    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
88
77
        The factory must be a callable that takes one parameter: the key.
89
78
        It must produce an instance of VcsMapping when called.
90
79
        """
91
 
        if ":" in key:
 
80
        if b":" in key:
92
81
            raise ValueError("mapping name can not contain colon (:)")
93
82
        registry.Registry.register(self, key, factory, help)
94
83
 
115
104
    """
116
105
 
117
106
    def __init__(self, foreign_revid, mapping, *args, **kwargs):
118
 
        if not "inventory_sha1" in kwargs:
119
 
            kwargs["inventory_sha1"] = ""
 
107
        if "inventory_sha1" not in kwargs:
 
108
            kwargs["inventory_sha1"] = b""
120
109
        super(ForeignRevision, self).__init__(*args, **kwargs)
121
110
        self.foreign_revid = foreign_revid
122
111
        self.mapping = mapping
144
133
        :param foreign_revid: Foreign revision id.
145
134
        :return: Dictionary mapping string keys to string values.
146
135
        """
147
 
        return { }
 
136
        return {}
148
137
 
149
138
    def serialize_foreign_revid(self, foreign_revid):
150
139
        """Serialize a foreign revision id for this VCS.
151
140
 
152
141
        :param foreign_revid: Foreign revision id
153
 
        :return: Bytestring with serialized revid, will not contain any 
 
142
        :return: Bytestring with serialized revid, will not contain any
154
143
            newlines.
155
144
        """
156
145
        raise NotImplementedError(self.serialize_foreign_revid)
182
171
        :param revid: The bzr revision id
183
172
        :return: tuple with foreign revid and vcs mapping
184
173
        """
185
 
        if not ":" in revid or not "-" in revid:
 
174
        if b":" not in revid or b"-" not in revid:
186
175
            raise errors.InvalidRevisionId(revid, None)
187
176
        try:
188
 
            foreign_vcs = self.get(revid.split("-")[0])
 
177
            foreign_vcs = self.get(revid.split(b"-")[0].decode('ascii'))
189
178
        except KeyError:
190
179
            raise errors.InvalidRevisionId(revid, None)
191
180
        return foreign_vcs.mapping_registry.revision_id_bzr_to_foreign(revid)
235
224
    def __init__(self, mapping):
236
225
        self.mapping = mapping
237
226
        super(ForeignBranch, self).__init__()
238
 
 
239
 
 
240
 
def update_workingtree_fileids(wt, target_tree):
241
 
    """Update the file ids in a working tree based on another tree.
242
 
 
243
 
    :param wt: Working tree in which to update file ids
244
 
    :param target_tree: Tree to retrieve new file ids from, based on path
245
 
    """
246
 
    tt = transform.TreeTransform(wt)
247
 
    try:
248
 
        for f, p, c, v, d, n, k, e in target_tree.iter_changes(wt):
249
 
            if v == (True, False):
250
 
                trans_id = tt.trans_id_tree_path(p[0])
251
 
                tt.unversion_file(trans_id)
252
 
            elif v == (False, True):
253
 
                trans_id = tt.trans_id_tree_path(p[1])
254
 
                tt.version_file(f, trans_id)
255
 
        tt.apply()
256
 
    finally:
257
 
        tt.finalize()
258
 
    if len(wt.get_parent_ids()) == 1:
259
 
        wt.set_parent_trees([(target_tree.get_revision_id(), target_tree)])
260
 
    else:
261
 
        wt.set_last_revision(target_tree.get_revision_id())
262
 
 
263
 
 
264
 
class cmd_dpush(Command):
265
 
    __doc__ = """Push into a different VCS without any custom bzr metadata.
266
 
 
267
 
    This will afterwards rebase the local branch on the remote
268
 
    branch unless the --no-rebase option is used, in which case 
269
 
    the two branches will be out of sync after the push. 
270
 
    """
271
 
    takes_args = ['location?']
272
 
    takes_options = [
273
 
        'remember',
274
 
        Option('directory',
275
 
               help='Branch to push from, '
276
 
               'rather than the one containing the working directory.',
277
 
               short_name='d',
278
 
               type=text_type,
279
 
               ),
280
 
        Option('no-rebase', help="Do not rebase after push."),
281
 
        Option('strict',
282
 
               help='Refuse to push if there are uncommitted changes in'
283
 
               ' the working tree, --no-strict disables the check.'),
284
 
        ]
285
 
 
286
 
    def run(self, location=None, remember=False, directory=None,
287
 
            no_rebase=False, strict=None):
288
 
        from breezy import urlutils
289
 
        from breezy.controldir import ControlDir
290
 
        from breezy.errors import BzrCommandError, NoWorkingTree
291
 
        from breezy.workingtree import WorkingTree
292
 
 
293
 
        if directory is None:
294
 
            directory = "."
295
 
        try:
296
 
            source_wt = WorkingTree.open_containing(directory)[0]
297
 
            source_branch = source_wt.branch
298
 
        except NoWorkingTree:
299
 
            source_branch = Branch.open(directory)
300
 
            source_wt = None
301
 
        if source_wt is not None:
302
 
            source_wt.check_changed_or_out_of_date(
303
 
                strict, 'dpush_strict',
304
 
                more_error='Use --no-strict to force the push.',
305
 
                more_warning='Uncommitted changes will not be pushed.')
306
 
        stored_loc = source_branch.get_push_location()
307
 
        if location is None:
308
 
            if stored_loc is None:
309
 
                raise BzrCommandError(gettext("No push location known or specified."))
310
 
            else:
311
 
                display_url = urlutils.unescape_for_display(stored_loc,
312
 
                        self.outf.encoding)
313
 
                self.outf.write(
314
 
                       gettext("Using saved location: %s\n") % display_url)
315
 
                location = stored_loc
316
 
 
317
 
        controldir = ControlDir.open(location)
318
 
        target_branch = controldir.open_branch()
319
 
        target_branch.lock_write()
320
 
        try:
321
 
            try:
322
 
                push_result = source_branch.push(target_branch, lossy=True)
323
 
            except errors.LossyPushToSameVCS:
324
 
                raise BzrCommandError(gettext("{0!r} and {1!r} are in the same VCS, lossy "
325
 
                    "push not necessary. Please use regular push.").format(
326
 
                    source_branch, target_branch))
327
 
            # We successfully created the target, remember it
328
 
            if source_branch.get_push_location() is None or remember:
329
 
                # FIXME: Should be done only if we succeed ? -- vila 2012-01-18
330
 
                source_branch.set_push_location(target_branch.base)
331
 
            if not no_rebase:
332
 
                old_last_revid = source_branch.last_revision()
333
 
                source_branch.pull(target_branch, overwrite=True)
334
 
                new_last_revid = source_branch.last_revision()
335
 
                if source_wt is not None and old_last_revid != new_last_revid:
336
 
                    source_wt.lock_write()
337
 
                    try:
338
 
                        target = source_wt.branch.repository.revision_tree(
339
 
                            new_last_revid)
340
 
                        update_workingtree_fileids(source_wt, target)
341
 
                    finally:
342
 
                        source_wt.unlock()
343
 
            push_result.report(self.outf)
344
 
        finally:
345
 
            target_branch.unlock()