/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: 2018-02-18 21:42:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6859.
  • Revision ID: jelmer@jelmer.uk-20180218214257-jpevutp1wa30tz3v
Update TODO to reference Breezy, not Bazaar.

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
 
19
22
from .branch import (
20
23
    Branch,
21
24
    )
 
25
from .commands import Command, Option
22
26
from .repository import Repository
23
27
from .revision import Revision
24
 
from . import (
 
28
from .sixish import (
 
29
    text_type,
 
30
    )
 
31
from .lazy_import import lazy_import
 
32
lazy_import(globals(), """
 
33
from breezy import (
25
34
    errors,
26
35
    registry,
 
36
    transform,
27
37
    )
28
 
 
 
38
from breezy.i18n import gettext
 
39
""")
29
40
 
30
41
class VcsMapping(object):
31
42
    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
77
88
        The factory must be a callable that takes one parameter: the key.
78
89
        It must produce an instance of VcsMapping when called.
79
90
        """
80
 
        if b":" in key:
 
91
        if ":" in key:
81
92
            raise ValueError("mapping name can not contain colon (:)")
82
93
        registry.Registry.register(self, key, factory, help)
83
94
 
104
115
    """
105
116
 
106
117
    def __init__(self, foreign_revid, mapping, *args, **kwargs):
107
 
        if "inventory_sha1" not in kwargs:
108
 
            kwargs["inventory_sha1"] = b""
 
118
        if not "inventory_sha1" in kwargs:
 
119
            kwargs["inventory_sha1"] = ""
109
120
        super(ForeignRevision, self).__init__(*args, **kwargs)
110
121
        self.foreign_revid = foreign_revid
111
122
        self.mapping = mapping
133
144
        :param foreign_revid: Foreign revision id.
134
145
        :return: Dictionary mapping string keys to string values.
135
146
        """
136
 
        return {}
 
147
        return { }
137
148
 
138
149
    def serialize_foreign_revid(self, foreign_revid):
139
150
        """Serialize a foreign revision id for this VCS.
140
151
 
141
152
        :param foreign_revid: Foreign revision id
142
 
        :return: Bytestring with serialized revid, will not contain any
 
153
        :return: Bytestring with serialized revid, will not contain any 
143
154
            newlines.
144
155
        """
145
156
        raise NotImplementedError(self.serialize_foreign_revid)
171
182
        :param revid: The bzr revision id
172
183
        :return: tuple with foreign revid and vcs mapping
173
184
        """
174
 
        if b":" not in revid or b"-" not in revid:
 
185
        if not ":" in revid or not "-" in revid:
175
186
            raise errors.InvalidRevisionId(revid, None)
176
187
        try:
177
 
            foreign_vcs = self.get(revid.split(b"-")[0].decode('ascii'))
 
188
            foreign_vcs = self.get(revid.split("-")[0])
178
189
        except KeyError:
179
190
            raise errors.InvalidRevisionId(revid, None)
180
191
        return foreign_vcs.mapping_registry.revision_id_bzr_to_foreign(revid)
224
235
    def __init__(self, mapping):
225
236
        self.mapping = mapping
226
237
        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()