~bzr-pqm/bzr/bzr.dev

#!/usr/bin/env python

"""\

This is an attempt to take the internal delta object, and represent

it as a single-file text-only changeset.

This should have commands for both generating a changeset,

and for applying a changeset.

"""

import sys

from bzrlib.branch import Branch

from bzrlib.commands import Command, register_command

import bzrlib.errors as errors

from bzrlib.option import Option

from bzrlib.revision import (common_ancestor, MultipleRevisionSources,

                             NULL_REVISION)

from bzrlib.revisionspec import RevisionSpec

class cmd_send_changeset(Command):

    """Send a bundled up changset via mail.

    If no revision has been specified, the last commited change will

    be sent.

    Subject of the mail can be specified by the --message option,

    otherwise information from the changeset log will be used.

    A editor will be spawned where the user may enter a description

    of the changeset.  The description can be read from a file with

    the --file FILE option.

    """

    takes_options = ['revision', 'message', 'file']

    takes_args = ['to?']

    def run(self, to=None, message=None, revision=None, file=None):

        from bzrlib.errors import BzrCommandError

        from send_changeset import send_changeset

        if isinstance(revision, (list, tuple)):

            if len(revision) > 1:

                raise BzrCommandError('We do not support rollup-changesets yet.')

            revision = revision[0]

        b = Branch.open_containing('.')

        if not to:

            try:

                to = b.controlfile('x-send-address', 'rb').read().strip('\n')

            except:

                raise BzrCommandError('destination address is not known')

        if not isinstance(revision, (list, tuple)):

            revision = [revision]

        send_changeset(b, revision, to, message, file)

class cmd_bundle_revisions(Command):

    """Generate a revision bundle.

    This bundle contains all of the meta-information of a

    diff, rather than just containing the patch information.

    You can apply it to another tree using 'bzr merge'.

    bzr bundle

        - Bundle for the last commit

    bzr bundle BASE

        - Bundle to apply the current tree into BASE

    bzr bundle --revision A

        - Bundle for revision A

    bzr bundle --revision A..B

        - Bundle to transform A into B

    bzr bundle --revision A..B BASE

        - Bundle to transform revision A of BASE into revision B

          of the local tree

    """

    takes_options = ['verbose', 'revision']

    takes_args = ['base?']

    aliases = ['bundle']

    def run(self, base=None, revision=None):

        from bzrlib import user_encoding

        from bzrlib.bundle.serializer import write_bundle

        if base is None:

            base_branch = None

        else:

            base_branch = Branch.open(base)

        # We don't want to lock the same branch across

        # 2 different branches

        target_branch = Branch.open_containing(u'.')[0]

        if base_branch is not None and target_branch.base == base_branch.base:

            base_branch = None

        base_revision = None

        if revision is None:

            target_revision = target_branch.last_revision()

        elif len(revision) == 1:

            target_revision = revision[0].in_history(target_branch).rev_id

            if base_branch is not None:

                base_revision = base_branch.last_revision()

        elif len(revision) == 2:

            target_revision = revision[1].in_history(target_branch).rev_id

            if base_branch is not None:

                base_revision = revision[0].in_history(base_branch).rev_id

            else:

                base_revision = revision[0].in_history(target_branch).rev_id

        else:

            raise errors.BzrCommandError('--revision takes 1 or 2 parameters')

        if revision is None or len(revision) == 1:

            if base_branch is not None:

                target_branch.repository.fetch(base_branch.repository, 

                                               base_branch.last_revision())

                base_revision = common_ancestor(base_branch.last_revision(),

                                                target_revision,

                                                target_branch.repository)

                if base_revision is None:

                    base_revision = NULL_REVISION

        if base_revision is None:

            rev = target_branch.repository.get_revision(target_revision)

            if rev.parent_ids:

                base_revision = rev.parent_ids[0]

            else:

                base_revision = NULL_REVISION

        if base_branch is not None:

            target_branch.repository.fetch(base_branch.repository, 

                                           revision_id=base_revision)

            del base_branch

        write_bundle(target_branch.repository, target_revision, base_revision,

                     sys.stdout)

class cmd_verify_changeset(Command):

    """Read a written changeset, and make sure it is valid.

    """

    takes_args = ['filename?']

    def run(self, filename=None):

        from read_changeset import read_changeset

        #from bzrlib.xml import serializer_v4

        b, relpath = Branch.open_containing('.')

        if filename is None or filename == '-':

            f = sys.stdin

        else:

            f = open(filename, 'U')

        cset_info, cset_tree = read_changeset(f, b)

        # print cset_info

        # print cset_tree

        #serializer_v4.write(cset_tree.inventory, sys.stdout)