← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/foreign.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-10-06 20:45:48 UTC
  • mfrom: (4728.1.2 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20091006204548-bjnc3z4k256ppimz
MutableTree.has_changes() does not require a tree parameter anymore

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/foreign.py
18
18
"""Foreign branch utilities."""
19
19
 
20
20
 
21
 
from bzrlib.branch import Branch
 
21
from bzrlib.branch import (
 
22
    Branch,
 
23
    InterBranch,
 
24
    )
22
25
from bzrlib.commands import Command, Option
23
26
from bzrlib.repository import Repository
24
27
from bzrlib.revision import Revision
28
31
    errors,
29
32
    osutils,
30
33
    registry,
 
34
    transform,
31
35
    )
32
36
""")
33
37
 
41
45
    # Whether this mapping supports exporting and importing all bzr semantics.
42
46
    roundtripping = False
43
47
 
44
 
    # Prefix used when importing native foreign revisions (not roundtripped)
45
 
    # using this mapping.
 
48
    # Prefix used when importing revisions native to the foreign VCS (as
 
49
    # opposed to roundtripping bzr-native revisions) using this mapping.
46
50
    revid_prefix = None
47
51
 
48
52
    def __init__(self, vcs):
115
119
        self.mapping = mapping
116
120
 
117
121
 
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
 
 
137
122
class ForeignVcs(object):
138
123
    """A foreign version control system."""
139
124
 
175
160
        :param revid: The bzr revision id
176
161
        :return: tuple with foreign revid and vcs mapping
177
162
        """
178
 
        if not "-" in revid:
 
163
        if not ":" in revid or not "-" in revid:
179
164
            raise errors.InvalidRevisionId(revid, None)
180
165
        try:
181
166
            foreign_vcs = self.get(revid.split("-")[0])
245
230
            self.get_revision(revision_id))
246
231
 
247
232
 
 
233
class ForeignBranch(Branch):
 
234
    """Branch that exists in a foreign version control system."""
 
235
 
 
236
    def __init__(self, mapping):
 
237
        self.mapping = mapping
 
238
        super(ForeignBranch, self).__init__()
 
239
 
 
240
 
 
241
def update_workingtree_fileids(wt, target_tree):
 
242
    """Update the file ids in a working tree based on another tree.
 
243
 
 
244
    :param wt: Working tree in which to update file ids
 
245
    :param target_tree: Tree to retrieve new file ids from, based on path
 
246
    """
 
247
    tt = transform.TreeTransform(wt)
 
248
    try:
 
249
        for f, p, c, v, d, n, k, e in target_tree.iter_changes(wt):
 
250
            if v == (True, False):
 
251
                trans_id = tt.trans_id_tree_path(p[0])
 
252
                tt.unversion_file(trans_id)
 
253
            elif v == (False, True):
 
254
                trans_id = tt.trans_id_tree_path(p[1])
 
255
                tt.version_file(f, trans_id)
 
256
        tt.apply()
 
257
    finally:
 
258
        tt.finalize()
 
259
    if len(wt.get_parent_ids()) == 1:
 
260
        wt.set_parent_trees([(target_tree.get_revision_id(), target_tree)])
 
261
    else:
 
262
        wt.set_last_revision(target_tree.get_revision_id())
 
263
 
 
264
 
 
265
class cmd_dpush(Command):
 
266
    """Push into a different VCS without any custom bzr metadata.
 
267
 
 
268
    This will afterwards rebase the local branch on the remote
 
269
    branch unless the --no-rebase option is used, in which case 
 
270
    the two branches will be out of sync after the push. 
 
271
    """
 
272
    hidden = True
 
273
    takes_args = ['location?']
 
274
    takes_options = [
 
275
        'remember',
 
276
        Option('directory',
 
277
               help='Branch to push from, '
 
278
               'rather than the one containing the working directory.',
 
279
               short_name='d',
 
280
               type=unicode,
 
281
               ),
 
282
        Option('no-rebase', help="Do not rebase after push."),
 
283
        Option('strict',
 
284
               help='Refuse to push if there are uncommitted changes in'
 
285
               ' the working tree, --no-strict disables the check.'),
 
286
        ]
 
287
 
 
288
    def run(self, location=None, remember=False, directory=None,
 
289
            no_rebase=False, strict=None):
 
290
        from bzrlib import urlutils
 
291
        from bzrlib.bzrdir import BzrDir
 
292
        from bzrlib.errors import BzrCommandError, NoWorkingTree
 
293
        from bzrlib.workingtree import WorkingTree
 
294
 
 
295
        if directory is None:
 
296
            directory = "."
 
297
        try:
 
298
            source_wt = WorkingTree.open_containing(directory)[0]
 
299
            source_branch = source_wt.branch
 
300
        except NoWorkingTree:
 
301
            source_branch = Branch.open(directory)
 
302
            source_wt = None
 
303
        if strict is None:
 
304
            strict = source_branch.get_config(
 
305
                ).get_user_option_as_bool('dpush_strict')
 
306
        if strict is None: strict = True # default value
 
307
        if strict and source_wt is not None:
 
308
            if (source_wt.has_changes()):
 
309
                raise errors.UncommittedChanges(
 
310
                    source_wt, more='Use --no-strict to force the push.')
 
311
            if source_wt.last_revision() != source_wt.branch.last_revision():
 
312
                # The tree has lost sync with its branch, there is little
 
313
                # chance that the user is aware of it but he can still force
 
314
                # the push with --no-strict
 
315
                raise errors.OutOfDateTree(
 
316
                    source_wt, more='Use --no-strict to force the push.')
 
317
        stored_loc = source_branch.get_push_location()
 
318
        if location is None:
 
319
            if stored_loc is None:
 
320
                raise BzrCommandError("No push location known or specified.")
 
321
            else:
 
322
                display_url = urlutils.unescape_for_display(stored_loc,
 
323
                        self.outf.encoding)
 
324
                self.outf.write("Using saved location: %s\n" % display_url)
 
325
                location = stored_loc
 
326
 
 
327
        bzrdir = BzrDir.open(location)
 
328
        target_branch = bzrdir.open_branch()
 
329
        target_branch.lock_write()
 
330
        try:
 
331
            try:
 
332
                push_result = source_branch.lossy_push(target_branch)
 
333
            except errors.LossyPushToSameVCS:
 
334
                raise BzrCommandError("%r and %r are in the same VCS, lossy "
 
335
                    "push not necessary. Please use regular push." %
 
336
                    (source_branch, target_branch))
 
337
            # We successfully created the target, remember it
 
338
            if source_branch.get_push_location() is None or remember:
 
339
                source_branch.set_push_location(target_branch.base)
 
340
            if not no_rebase:
 
341
                old_last_revid = source_branch.last_revision()
 
342
                source_branch.pull(target_branch, overwrite=True)
 
343
                new_last_revid = source_branch.last_revision()
 
344
                if source_wt is not None and old_last_revid != new_last_revid:
 
345
                    source_wt.lock_write()
 
346
                    try:
 
347
                        target = source_wt.branch.repository.revision_tree(
 
348
                            new_last_revid)
 
349
                        update_workingtree_fileids(source_wt, target)
 
350
                    finally:
 
351
                        source_wt.unlock()
 
352
            push_result.report(self.outf)
 
353
        finally:
 
354
            target_branch.unlock()
 
355
 
 
356
 
 
357
class InterToForeignBranch(InterBranch):
 
358
 
 
359
    def lossy_push(self, stop_revision=None):
 
360
        """Push deltas into another branch.
 
361
 
 
362
        :note: This does not, like push, retain the revision ids from 
 
363
            the source branch and will, rather than adding bzr-specific 
 
364
            metadata, push only those semantics of the revision that can be 
 
365
            natively represented by this branch' VCS.
 
366
 
 
367
        :param target: Target branch
 
368
        :param stop_revision: Revision to push, defaults to last revision.
 
369
        :return: BranchPushResult with an extra member revidmap: 
 
370
            A dictionary mapping revision ids from the target branch 
 
371
            to new revision ids in the target branch, for each 
 
372
            revision that was pushed.
 
373
        """
 
374
        raise NotImplementedError(self.lossy_push)