~abentley/bzrtools/bzrtools.dev

from bzrlib.errors import (BzrError,

                           NotBranchError,

                           NoWorkingTree,

                           NoSuchRevision,

                           NoRepositoryPresent,

                          )

from bzrlib.commands import Command

from bzrlib.option import _global_option, Option

from bzrlib.merge import merge_inner

import bzrlib.ui

from bzrlib.workingtree import WorkingTree

from errors import NoPyBaz

try:

    from pybaz.backends.baz import null_cmd

except ImportError:

    raise NoPyBaz

import tempfile

import os

import os.path

import email.Utils

from progress import *

 

class ImportCommitReporter(NullCommitReporter):

 

    def escaped(self, escape_count, message):

 

def make_archive(name, location):

    pb_location = pybaz.ArchiveLocation(location)

                              pybaz.ArchiveLocationParams())

 

def test_environ():

            br_from.bzrdir.clone(to_location, revision_id)

        except NoSuchRevision:

            rmtree(to_location)

                                                         revision_id)

            raise UserError(msg)

    finally:

        br_from.unlock()

 

    last_patch = None

    old_revno = None

    output_exists = os.path.exists(output_dir)

        # We are starting from an existing directory, figure out what

        # the current version is

        branch = Branch.open(output_dir)

        if last_patch is None:

                raise NotPreviousImport(branch.base)

        elif version is None:

            version = last_patch.version

                    break

                # try to grab a copy of ancestor

                # note that is not optimised: we could look for namespace

                # transition.

                for history_root in reuse_history_from:

                    possible_source = os.path.join(history_root,

                        map_namespace(ancestor.version))

                    try:

                        source = Branch.open(possible_source)

                        if rev_id in source.revision_history():

                            do_branch(source, output_dir, rev_id)

                            last_patch = ancestor

                break

        else:

            raise UserError("Directory \"%s\" already exists, and the last "

                (output_dir, last_patch, version))

        # Strip off all of the ancestors which are already present

        # And get a directory starting with the latest ancestor

 

###class Importer(object):

###    """An importer.

###    Currently this is used as a parameter object, though more behaviour is

###    possible later.

###    """

###

###    def __init__(self, output_dir, version, fast=False,

###                   reuse_history_from=[]):

###        self.output_dir = output_dir

###        self.version = version

###        self.

 

 

                   verbose=False, dry_run=False, max_count=None,

                   reuse_history_from=[], standalone=True):

    """

    >>> q = test_environ()

    Progress bars output to stderr, but doctest does not capture that.

 

    >>> old_stderr = sys.stderr

    >>> bzrlib.ui.ui_factory = bzrlib.ui.text.TextUIFactory(

    ...     bar_type=bzrlib.progress.DotsProgressBar)

 

    Traceback (most recent call last):

    NotPreviousImport: / is not the location of a previous import.

    Traceback (most recent call last):

    UserError: The version test@example.com/test--test--0.1 does not exist.

    >>> version = pybaz.Version("test@example.com/test--test--0")

    importing test@example.com/test--test--0 into ...

    ...

    revisions: ..........................................

    Dry run, not modifying output_dir

    Cleaning up

    importing test@example.com/test--test--0 into ...

    ...

    revisions: .....................................................................

    Cleaning up

    Import complete.

    Tree is up-to-date with test@example.com/test--test--0--patch-2

    >>> commit_more_test_revisions()

    importing test@example.com/test--test--0 into ...

    revisions: ....................................................

    Cleaning up

    try:

        try:

            ancestors, old_revno = get_remaining_revisions(output_dir, version,

                                                           reuse_history_from)

        except NotBranchError, e:

            raise NotPreviousImport(e.path)

            progress_bar.note('Version %s has no revisions.' % version)

            return

        if len(ancestors) == 0:

            progress_bar.note('Tree is up-to-date with %s' % last_revision)

            return

 

        progress_bar.note("importing %s into %s" % (version, output_dir))

        tempdir = tempfile.mkdtemp(prefix="baz2bzr-",

                                   dir=os.path.dirname(output_dir))

        try:

            wt = WorkingTree.open(output_dir)

        except (NotBranchError, NoWorkingTree):

            wt = None

        try:

            for result in iter_import_version(output_dir, ancestors, tempdir,

                show_progress(progress_bar, result)

            if dry_run:

                progress_bar.note('Dry run, not modifying output_dir')

                return

            # Update the working tree of the branch

            try:

                wt = WorkingTree.open(output_dir)

                wt = None

            if wt is not None:

                wt.set_last_revision(wt.branch.last_revision())

        finally:

            progress_bar.note('Cleaning up')

            shutil.rmtree(tempdir)

        progress_bar.note("Import complete.")

    finally:

        progress_bar.finished()

class UserError(BzrCommandError):

    def __init__(self, message):

        """Exception to throw when a user makes an impossible request

                           % path)

 

 

    """

    Generate a Bzr revision id from an Arch revision id.  'x' in the id

    designates a revision imported with an experimental algorithm.  A number

 

    :param arch_revision: The Arch revision to generate an ID for.

 

    'Arch-1:you@example.com%cat--br--0--base-0'

    """

 

class NotArchRevision(Exception):

    def __init__(self, revision_id):

    >>> str(arch_revision("Arch-1:jrandom@example.com%test--test--0--base-5"))

    Traceback (most recent call last):

    NotArchRevision: The revision id Arch-1:jrandom@example.com%test--test--0--base-5 does not look like it came from Arch.

    """

        raise NotArchRevision(revision_id)

    else:

        try:

        except pybaz.errors.NamespaceError, e:

            raise NotArchRevision(revision_id)

 

    if revision_id is None:

        revision_id = source.last_revision()

    wt = create_checkout(source, to_location, NULL_REVISION)

    return wt

 

 

    revdir = None

 

    # Uncomment this for testing, it basically just has baz2bzr only update

    # 5 patches at a time

        else:

            target_branch = create_branch(output_dir)

 

        direct_merges = []

        if verbose:

            version = str(revision.version)

            yield Progress("revisions", i, len(ancestors))

 

        if target_branch.repository.has_revision(rev_id):

            continue

        if revdir is None:

            revdir = os.path.join(tempdir, "rd")

        try:

            if missing_ancestor:

                # if we want it to be in revision-history, do that here.

                missing_ancestor = None

            for merged_rev in direct_merges:

            target_tree.set_inventory(baz_inv)

            commitobj = Commit(reporter=ImportCommitReporter())

            commitobj.commit(working_tree=target_tree,

        finally:

            target_tree.unlock()

            branch.unlock()

    previous_version = revision.version

    if pybaz.WorkingTree(revdir).tree_version != previous_version:

        pybaz.WorkingTree(revdir).set_tree_version(previous_version)

        revision.version.nonarch, revision.archive, revision.patchlevel)

    temp_path = tempfile.mktemp(dir=os.path.dirname(revdir))

    os.rename(log_path, temp_path)

    tree = revision.get(revdir)

    log = get_log(tree, revision)

    try:

    except BadFileKind, e:

                        (revision,e.path, e.kind))

 

 

    try:

        return bzr_inventory_data(tree), log

    except BadFileKind, e:

                        (revision,e.path, e.kind))

 

 

    inv_map = {}

    for arch_id, path in inv_iter:

        bzr_file_id = map_file_id(arch_id)

 

    bzr_inv = []

    for path, file_id in inv_map.iteritems():

    bzr_inv.sort()

    return bzr_inv

 

 

 

 

class NotInABranch(Exception):

        self.path = path

 

 

 

 

def import_archive(to_root, from_archive, verbose,

                   prefixes=None):

    def selected(version):

        if prefixes is None:

            if not os.path.exists(os.path.dirname(target)):

                os.makedirs(os.path.dirname(target))

            try:

                               standalone=standalone)

            except pybaz.errors.ExecProblem,e:

                if str(e).find('The requested revision cannot be built.') != -1: