← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/foreign.py

  • Committer: Patch Queue Manager
  • Date: 2011-10-14 16:54:26 UTC
  • mfrom: (6216.1.1 remove-this-file)
  • Revision ID: pqm@pqm.ubuntu.com-20111014165426-tjix4e6idryf1r2z
(jelmer) Remove an accidentally committed .THIS file. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/foreign.py
1
 
# Copyright (C) 2008 Canonical Ltd
 
1
# Copyright (C) 2008-2011 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
20
20
 
21
21
from bzrlib.branch import (
22
22
    Branch,
23
 
    InterBranch,
24
23
    )
25
24
from bzrlib.commands import Command, Option
26
25
from bzrlib.repository import Repository
29
28
lazy_import(globals(), """
30
29
from bzrlib import (
31
30
    errors,
32
 
    osutils,
33
31
    registry,
34
32
    transform,
35
33
    )
 
34
from bzrlib.i18n import gettext
36
35
""")
37
36
 
38
37
class VcsMapping(object):
39
 
    """Describes the mapping between the semantics of Bazaar and a foreign vcs.
 
38
    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
40
39
 
41
40
    """
42
41
    # Whether this is an experimental mapping that is still open to changes.
122
121
class ForeignVcs(object):
123
122
    """A foreign version control system."""
124
123
 
125
 
    def __init__(self, mapping_registry):
 
124
    branch_format = None
 
125
 
 
126
    repository_format = None
 
127
 
 
128
    def __init__(self, mapping_registry, abbreviation=None):
 
129
        """Create a new foreign vcs instance.
 
130
 
 
131
        :param mapping_registry: Registry with mappings for this VCS.
 
132
        :param abbreviation: Optional abbreviation ('bzr', 'svn', 'git', etc)
 
133
        """
 
134
        self.abbreviation = abbreviation
126
135
        self.mapping_registry = mapping_registry
127
136
 
128
137
    def show_foreign_revid(self, foreign_revid):
133
142
        """
134
143
        return { }
135
144
 
 
145
    def serialize_foreign_revid(self, foreign_revid):
 
146
        """Serialize a foreign revision id for this VCS.
 
147
 
 
148
        :param foreign_revid: Foreign revision id
 
149
        :return: Bytestring with serialized revid, will not contain any 
 
150
            newlines.
 
151
        """
 
152
        raise NotImplementedError(self.serialize_foreign_revid)
 
153
 
136
154
 
137
155
class ForeignVcsRegistry(registry.Registry):
138
156
    """Registry for Foreign VCSes.
206
224
        """Get the default mapping for this repository."""
207
225
        raise NotImplementedError(self.get_default_mapping)
208
226
 
209
 
    def get_inventory_xml(self, revision_id):
210
 
        """See Repository.get_inventory_xml()."""
211
 
        return self.serialise_inventory(self.get_inventory(revision_id))
212
 
 
213
 
    def get_inventory_sha1(self, revision_id):
214
 
        """Get the sha1 for the XML representation of an inventory.
215
 
 
216
 
        :param revision_id: Revision id of the inventory for which to return
217
 
         the SHA1.
218
 
        :return: XML string
219
 
        """
220
 
 
221
 
        return osutils.sha_string(self.get_inventory_xml(revision_id))
222
 
 
223
 
    def get_revision_xml(self, revision_id):
224
 
        """Return the XML representation of a revision.
225
 
 
226
 
        :param revision_id: Revision for which to return the XML.
227
 
        :return: XML string
228
 
        """
229
 
        return self._serializer.write_revision_to_string(
230
 
            self.get_revision(revision_id))
231
 
 
232
227
 
233
228
class ForeignBranch(Branch):
234
229
    """Branch that exists in a foreign version control system."""
263
258
 
264
259
 
265
260
class cmd_dpush(Command):
266
 
    """Push into a different VCS without any custom bzr metadata.
 
261
    __doc__ = """Push into a different VCS without any custom bzr metadata.
267
262
 
268
263
    This will afterwards rebase the local branch on the remote
269
264
    branch unless the --no-rebase option is used, in which case 
271
266
    """
272
267
    hidden = True
273
268
    takes_args = ['location?']
274
 
    takes_options = ['remember', Option('directory',
275
 
            help='Branch to push from, '
276
 
                 'rather than the one containing the working directory.',
277
 
            short_name='d',
278
 
            type=unicode,
279
 
            ),
280
 
            Option('no-rebase', help="Do not rebase after push.")]
 
269
    takes_options = [
 
270
        'remember',
 
271
        Option('directory',
 
272
               help='Branch to push from, '
 
273
               'rather than the one containing the working directory.',
 
274
               short_name='d',
 
275
               type=unicode,
 
276
               ),
 
277
        Option('no-rebase', help="Do not rebase after push."),
 
278
        Option('strict',
 
279
               help='Refuse to push if there are uncommitted changes in'
 
280
               ' the working tree, --no-strict disables the check.'),
 
281
        ]
281
282
 
282
 
    def run(self, location=None, remember=False, directory=None, 
283
 
            no_rebase=False):
 
283
    def run(self, location=None, remember=False, directory=None,
 
284
            no_rebase=False, strict=None):
284
285
        from bzrlib import urlutils
285
 
        from bzrlib.bzrdir import BzrDir
 
286
        from bzrlib.controldir import ControlDir
286
287
        from bzrlib.errors import BzrCommandError, NoWorkingTree
287
 
        from bzrlib.trace import info
288
288
        from bzrlib.workingtree import WorkingTree
289
289
 
290
290
        if directory is None:
295
295
        except NoWorkingTree:
296
296
            source_branch = Branch.open(directory)
297
297
            source_wt = None
 
298
        if source_wt is not None:
 
299
            source_wt.check_changed_or_out_of_date(
 
300
                strict, 'dpush_strict',
 
301
                more_error='Use --no-strict to force the push.',
 
302
                more_warning='Uncommitted changes will not be pushed.')
298
303
        stored_loc = source_branch.get_push_location()
299
304
        if location is None:
300
305
            if stored_loc is None:
301
 
                raise BzrCommandError("No push location known or specified.")
 
306
                raise BzrCommandError(gettext("No push location known or specified."))
302
307
            else:
303
308
                display_url = urlutils.unescape_for_display(stored_loc,
304
309
                        self.outf.encoding)
305
 
                self.outf.write("Using saved location: %s\n" % display_url)
 
310
                self.outf.write(
 
311
                       gettext("Using saved location: %s\n") % display_url)
306
312
                location = stored_loc
307
313
 
308
 
        bzrdir = BzrDir.open(location)
309
 
        target_branch = bzrdir.open_branch()
 
314
        controldir = ControlDir.open(location)
 
315
        target_branch = controldir.open_branch()
310
316
        target_branch.lock_write()
311
317
        try:
312
318
            try:
313
 
                push_result = source_branch.lossy_push(target_branch)
 
319
                push_result = source_branch.push(target_branch, lossy=True)
314
320
            except errors.LossyPushToSameVCS:
315
 
                raise BzrCommandError("%r and %r are in the same VCS, lossy "
316
 
                    "push not necessary. Please use regular push." %
317
 
                    (source_branch, target_branch))
 
321
                raise BzrCommandError(gettext("{0!r} and {1!r} are in the same VCS, lossy "
 
322
                    "push not necessary. Please use regular push.").format(
 
323
                    source_branch, target_branch))
318
324
            # We successfully created the target, remember it
319
325
            if source_branch.get_push_location() is None or remember:
320
326
                source_branch.set_push_location(target_branch.base)
333
339
            push_result.report(self.outf)
334
340
        finally:
335
341
            target_branch.unlock()
336
 
 
337
 
 
338
 
class InterToForeignBranch(InterBranch):
339
 
 
340
 
    def lossy_push(self, stop_revision=None):
341
 
        """Push deltas into another branch.
342
 
 
343
 
        :note: This does not, like push, retain the revision ids from 
344
 
            the source branch and will, rather than adding bzr-specific 
345
 
            metadata, push only those semantics of the revision that can be 
346
 
            natively represented by this branch' VCS.
347
 
 
348
 
        :param target: Target branch
349
 
        :param stop_revision: Revision to push, defaults to last revision.
350
 
        :return: BranchPushResult with an extra member revidmap: 
351
 
            A dictionary mapping revision ids from the target branch 
352
 
            to new revision ids in the target branch, for each 
353
 
            revision that was pushed.
354
 
        """
355
 
        raise NotImplementedError(self.lossy_push)