← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/foreign.py

  • Committer: Andrew Bennetts
  • Date: 2009-04-02 05:53:12 UTC
  • mto: This revision was merged to the branch mainline in revision 4242.
  • Revision ID: andrew.bennetts@canonical.com-20090402055312-h7mvgumvm7e620mj
Fix nits in spelling and naming.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/foreign.py
1
 
# Copyright (C) 2008-2011 Canonical Ltd
 
1
# Copyright (C) 2008 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
18
18
"""Foreign branch utilities."""
19
19
 
20
20
 
21
 
from bzrlib.branch import (
22
 
    Branch,
23
 
    )
 
21
from bzrlib.branch import Branch
24
22
from bzrlib.commands import Command, Option
25
23
from bzrlib.repository import Repository
26
24
from bzrlib.revision import Revision
28
26
lazy_import(globals(), """
29
27
from bzrlib import (
30
28
    errors,
 
29
    osutils,
31
30
    registry,
32
 
    transform,
33
31
    )
34
32
""")
35
33
 
36
34
class VcsMapping(object):
37
 
    """Describes the mapping between the semantics of Bazaar and a foreign VCS.
 
35
    """Describes the mapping between the semantics of Bazaar and a foreign vcs.
38
36
 
39
37
    """
40
38
    # Whether this is an experimental mapping that is still open to changes.
43
41
    # Whether this mapping supports exporting and importing all bzr semantics.
44
42
    roundtripping = False
45
43
 
46
 
    # Prefix used when importing revisions native to the foreign VCS (as
47
 
    # opposed to roundtripping bzr-native revisions) using this mapping.
 
44
    # Prefix used when importing native foreign revisions (not roundtripped)
 
45
    # using this mapping.
48
46
    revid_prefix = None
49
47
 
50
48
    def __init__(self, vcs):
117
115
        self.mapping = mapping
118
116
 
119
117
 
 
118
def show_foreign_properties(rev):
 
119
    """Custom log displayer for foreign revision identifiers.
 
120
 
 
121
    :param rev: Revision object.
 
122
    """
 
123
    # Revision comes directly from a foreign repository
 
124
    if isinstance(rev, ForeignRevision):
 
125
        return rev.mapping.vcs.show_foreign_revid(rev.foreign_revid)
 
126
 
 
127
    # Revision was once imported from a foreign repository
 
128
    try:
 
129
        foreign_revid, mapping = \
 
130
            foreign_vcs_registry.parse_revision_id(rev.revision_id)
 
131
    except errors.InvalidRevisionId:
 
132
        return {}
 
133
 
 
134
    return mapping.vcs.show_foreign_revid(foreign_revid)
 
135
 
 
136
 
120
137
class ForeignVcs(object):
121
138
    """A foreign version control system."""
122
139
 
123
 
    branch_format = None
124
 
 
125
 
    repository_format = None
126
 
 
127
 
    def __init__(self, mapping_registry, abbreviation=None):
128
 
        """Create a new foreign vcs instance.
129
 
 
130
 
        :param mapping_registry: Registry with mappings for this VCS.
131
 
        :param abbreviation: Optional abbreviation ('bzr', 'svn', 'git', etc)
132
 
        """
133
 
        self.abbreviation = abbreviation
 
140
    def __init__(self, mapping_registry):
134
141
        self.mapping_registry = mapping_registry
135
142
 
136
143
    def show_foreign_revid(self, foreign_revid):
141
148
        """
142
149
        return { }
143
150
 
144
 
    def serialize_foreign_revid(self, foreign_revid):
145
 
        """Serialize a foreign revision id for this VCS.
146
 
 
147
 
        :param foreign_revid: Foreign revision id
148
 
        :return: Bytestring with serialized revid, will not contain any 
149
 
            newlines.
150
 
        """
151
 
        raise NotImplementedError(self.serialize_foreign_revid)
152
 
 
153
151
 
154
152
class ForeignVcsRegistry(registry.Registry):
155
153
    """Registry for Foreign VCSes.
177
175
        :param revid: The bzr revision id
178
176
        :return: tuple with foreign revid and vcs mapping
179
177
        """
180
 
        if not ":" in revid or not "-" in revid:
 
178
        if not "-" in revid:
181
179
            raise errors.InvalidRevisionId(revid, None)
182
180
        try:
183
181
            foreign_vcs = self.get(revid.split("-")[0])
223
221
        """Get the default mapping for this repository."""
224
222
        raise NotImplementedError(self.get_default_mapping)
225
223
 
226
 
 
227
 
class ForeignBranch(Branch):
228
 
    """Branch that exists in a foreign version control system."""
229
 
 
230
 
    def __init__(self, mapping):
231
 
        self.mapping = mapping
232
 
        super(ForeignBranch, self).__init__()
233
 
 
234
 
 
235
 
def update_workingtree_fileids(wt, target_tree):
236
 
    """Update the file ids in a working tree based on another tree.
237
 
 
238
 
    :param wt: Working tree in which to update file ids
239
 
    :param target_tree: Tree to retrieve new file ids from, based on path
240
 
    """
241
 
    tt = transform.TreeTransform(wt)
242
 
    try:
243
 
        for f, p, c, v, d, n, k, e in target_tree.iter_changes(wt):
244
 
            if v == (True, False):
245
 
                trans_id = tt.trans_id_tree_path(p[0])
246
 
                tt.unversion_file(trans_id)
247
 
            elif v == (False, True):
248
 
                trans_id = tt.trans_id_tree_path(p[1])
249
 
                tt.version_file(f, trans_id)
250
 
        tt.apply()
251
 
    finally:
252
 
        tt.finalize()
253
 
    if len(wt.get_parent_ids()) == 1:
254
 
        wt.set_parent_trees([(target_tree.get_revision_id(), target_tree)])
255
 
    else:
256
 
        wt.set_last_revision(target_tree.get_revision_id())
257
 
 
258
 
 
259
 
class cmd_dpush(Command):
260
 
    __doc__ = """Push into a different VCS without any custom bzr metadata.
261
 
 
262
 
    This will afterwards rebase the local branch on the remote
263
 
    branch unless the --no-rebase option is used, in which case 
264
 
    the two branches will be out of sync after the push. 
265
 
    """
266
 
    hidden = True
267
 
    takes_args = ['location?']
268
 
    takes_options = [
269
 
        'remember',
270
 
        Option('directory',
271
 
               help='Branch to push from, '
272
 
               'rather than the one containing the working directory.',
273
 
               short_name='d',
274
 
               type=unicode,
275
 
               ),
276
 
        Option('no-rebase', help="Do not rebase after push."),
277
 
        Option('strict',
278
 
               help='Refuse to push if there are uncommitted changes in'
279
 
               ' the working tree, --no-strict disables the check.'),
280
 
        ]
281
 
 
282
 
    def run(self, location=None, remember=False, directory=None,
283
 
            no_rebase=False, strict=None):
284
 
        from bzrlib import urlutils
285
 
        from bzrlib.bzrdir import BzrDir
286
 
        from bzrlib.errors import BzrCommandError, NoWorkingTree
287
 
        from bzrlib.workingtree import WorkingTree
288
 
 
289
 
        if directory is None:
290
 
            directory = "."
291
 
        try:
292
 
            source_wt = WorkingTree.open_containing(directory)[0]
293
 
            source_branch = source_wt.branch
294
 
        except NoWorkingTree:
295
 
            source_branch = Branch.open(directory)
296
 
            source_wt = None
297
 
        if source_wt is not None:
298
 
            source_wt.check_changed_or_out_of_date(
299
 
                strict, 'dpush_strict',
300
 
                more_error='Use --no-strict to force the push.',
301
 
                more_warning='Uncommitted changes will not be pushed.')
302
 
        stored_loc = source_branch.get_push_location()
303
 
        if location is None:
304
 
            if stored_loc is None:
305
 
                raise BzrCommandError("No push location known or specified.")
306
 
            else:
307
 
                display_url = urlutils.unescape_for_display(stored_loc,
308
 
                        self.outf.encoding)
309
 
                self.outf.write("Using saved location: %s\n" % display_url)
310
 
                location = stored_loc
311
 
 
312
 
        bzrdir = BzrDir.open(location)
313
 
        target_branch = bzrdir.open_branch()
314
 
        target_branch.lock_write()
315
 
        try:
316
 
            try:
317
 
                push_result = source_branch.push(target_branch, lossy=True)
318
 
            except errors.LossyPushToSameVCS:
319
 
                raise BzrCommandError("%r and %r are in the same VCS, lossy "
320
 
                    "push not necessary. Please use regular push." %
321
 
                    (source_branch, target_branch))
322
 
            # We successfully created the target, remember it
323
 
            if source_branch.get_push_location() is None or remember:
324
 
                source_branch.set_push_location(target_branch.base)
325
 
            if not no_rebase:
326
 
                old_last_revid = source_branch.last_revision()
327
 
                source_branch.pull(target_branch, overwrite=True)
328
 
                new_last_revid = source_branch.last_revision()
329
 
                if source_wt is not None and old_last_revid != new_last_revid:
330
 
                    source_wt.lock_write()
331
 
                    try:
332
 
                        target = source_wt.branch.repository.revision_tree(
333
 
                            new_last_revid)
334
 
                        update_workingtree_fileids(source_wt, target)
335
 
                    finally:
336
 
                        source_wt.unlock()
337
 
            push_result.report(self.outf)
338
 
        finally:
339
 
            target_branch.unlock()
 
224
    def get_inventory_xml(self, revision_id):
 
225
        """See Repository.get_inventory_xml()."""
 
226
        return self.serialise_inventory(self.get_inventory(revision_id))
 
227
 
 
228
    def get_inventory_sha1(self, revision_id):
 
229
        """Get the sha1 for the XML representation of an inventory.
 
230
 
 
231
        :param revision_id: Revision id of the inventory for which to return
 
232
         the SHA1.
 
233
        :return: XML string
 
234
        """
 
235
 
 
236
        return osutils.sha_string(self.get_inventory_xml(revision_id))
 
237
 
 
238
    def get_revision_xml(self, revision_id):
 
239
        """Return the XML representation of a revision.
 
240
 
 
241
        :param revision_id: Revision for which to return the XML.
 
242
        :return: XML string
 
243
        """
 
244
        return self._serializer.write_revision_to_string(
 
245
            self.get_revision(revision_id))
 
246
 
 
247