/brz/remove-bazaar

# Copyright (C) 2004, 2005, 2006, 2007 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""builtin bzr commands"""

import os

from bzrlib.lazy_import import lazy_import

lazy_import(globals(), """

import codecs

import errno

import sys

import tempfile

import bzrlib

from bzrlib import (

    branch,

    bundle,

    bzrdir,

    delta,

    config,

    errors,

    ignores,

    log,

    merge as _mod_merge,

    osutils,

    repository,

    symbol_versioning,

    transport,

    tree as _mod_tree,

    ui,

    urlutils,

    )

from bzrlib.branch import Branch

from bzrlib.bundle.apply_bundle import install_bundle, merge_bundle

from bzrlib.conflicts import ConflictList

from bzrlib.revision import common_ancestor

from bzrlib.revisionspec import RevisionSpec

from bzrlib.workingtree import WorkingTree

""")

from bzrlib.commands import Command, display_command

from bzrlib.option import Option, RegistryOption

from bzrlib.progress import DummyProgress, ProgressPhase

from bzrlib.trace import mutter, note, log_error, warning, is_quiet, info

def tree_files(file_list, default_branch=u'.'):

    try:

        return internal_tree_files(file_list, default_branch)

    except errors.FileInWrongBranch, e:

        raise errors.BzrCommandError("%s is not in the same branch as %s" %

                                     (e.path, file_list[0]))

# XXX: Bad function name; should possibly also be a class method of

# WorkingTree rather than a function.

def internal_tree_files(file_list, default_branch=u'.'):

    """Convert command-line paths to a WorkingTree and relative paths.

    This is typically used for command-line processors that take one or

    more filenames, and infer the workingtree that contains them.

    The filenames given are not required to exist.

    :param file_list: Filenames to convert.  

    :param default_branch: Fallback tree path to use if file_list is empty or

        None.

    :return: workingtree, [relative_paths]

    """

    if file_list is None or len(file_list) == 0:

        return WorkingTree.open_containing(default_branch)[0], file_list

    tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]

    new_list = []

    for filename in file_list:

        try:

            new_list.append(tree.relpath(osutils.dereference_path(filename)))

        except errors.PathNotChild:

            raise errors.FileInWrongBranch(tree.branch, filename)

    return tree, new_list

@symbol_versioning.deprecated_function(symbol_versioning.zero_fifteen)

def get_format_type(typestring):

    """Parse and return a format specifier."""

    # Have to use BzrDirMetaFormat1 directly, so that

    # RepositoryFormat.set_default_format works

    if typestring == "default":

        return bzrdir.BzrDirMetaFormat1()

    try:

        return bzrdir.format_registry.make_bzrdir(typestring)

    except KeyError:

        msg = 'Unknown bzr format "%s". See "bzr help formats".' % typestring

        raise errors.BzrCommandError(msg)

# TODO: Make sure no commands unconditionally use the working directory as a

# branch.  If a filename argument is used, the first of them should be used to

# specify the branch.  (Perhaps this can be factored out into some kind of

# Argument class, representing a file in a branch, where the first occurrence

# opens the branch?)

class cmd_status(Command):

    """Display status summary.

    This reports on versioned and unknown files, reporting them

    grouped by state.  Possible states are:

    added

        Versioned in the working copy but not in the previous revision.

    removed

        Versioned in the previous revision but removed or deleted

        in the working copy.

    renamed

        Path of this file changed from the previous revision;

        the text may also have changed.  This includes files whose

        parent directory was renamed.

    modified

        Text has changed since the previous revision.

    kind changed

        File kind has been changed (e.g. from file to directory).

    unknown

        Not versioned and not matching an ignore pattern.

    To see ignored files use 'bzr ignored'.  For details in the

    changes to file texts, use 'bzr diff'.

    --short gives a status flags for each item, similar to the SVN's status

    command.

    Column 1: versioning / renames

      + File versioned

      - File unversioned

      R File renamed

      ? File unknown

      C File has conflicts

      P Entry for a pending merge (not a file)

    Column 2: Contents

      N File created

      D File deleted

      K File kind changed

      M File modified

    Column 3: Execute

      * The execute bit was changed

    If no arguments are specified, the status of the entire working

    directory is shown.  Otherwise, only the status of the specified

    files or directories is reported.  If a directory is given, status

    is reported for everything inside that directory.

    If a revision argument is given, the status is calculated against

    that revision, or between two revisions if two are provided.

    """

    # TODO: --no-recurse, --recurse options

    takes_args = ['file*']

    takes_options = ['show-ids', 'revision', 'short']

    aliases = ['st', 'stat']

    encoding_type = 'replace'

    @display_command

    def run(self, show_ids=False, file_list=None, revision=None, short=False):

        from bzrlib.status import show_tree_status

        tree, file_list = tree_files(file_list)

        show_tree_status(tree, show_ids=show_ids,

                         specific_files=file_list, revision=revision,

                         to_file=self.outf,

                         short=short)

class cmd_cat_revision(Command):

    """Write out metadata for a revision.

    The revision to print can either be specified by a specific

    revision identifier, or you can use --revision.

    """

    hidden = True

    takes_args = ['revision_id?']

    takes_options = ['revision']

    # cat-revision is more for frontends so should be exact

    encoding = 'strict'

    @display_command

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

        if revision_id is not None and revision is not None:

            raise errors.BzrCommandError('You can only supply one of'

                                         ' revision_id or --revision')

        if revision_id is None and revision is None:

            raise errors.BzrCommandError('You must supply either'

                                         ' --revision or a revision_id')

        b = WorkingTree.open_containing(u'.')[0].branch

        # TODO: jam 20060112 should cat-revision always output utf-8?

        if revision_id is not None:

            self.outf.write(b.repository.get_revision_xml(revision_id).decode('utf-8'))

        elif revision is not None:

            for rev in revision:

                if rev is None:

                    raise errors.BzrCommandError('You cannot specify a NULL'

                                                 ' revision.')

                revno, rev_id = rev.in_history(b)

                self.outf.write(b.repository.get_revision_xml(rev_id).decode('utf-8'))

class cmd_remove_tree(Command):

    """Remove the working tree from a given branch/checkout.

    Since a lightweight checkout is little more than a working tree

    this will refuse to run against one.

    """

    takes_args = ['location?']

    def run(self, location='.'):

        d = bzrdir.BzrDir.open(location)

        try:

            working = d.open_workingtree()

        except errors.NoWorkingTree:

            raise errors.BzrCommandError("No working tree to remove")

        except errors.NotLocalUrl:

            raise errors.BzrCommandError("You cannot remove the working tree of a "

                                         "remote path")

        working_path = working.bzrdir.root_transport.base

        branch_path = working.branch.bzrdir.root_transport.base

        if working_path != branch_path:

            raise errors.BzrCommandError("You cannot remove the working tree from "

                                         "a lightweight checkout")

        d.destroy_workingtree()

class cmd_revno(Command):

    """Show current revision number.

    This is equal to the number of revisions on this branch.

    """

    takes_args = ['location?']

    @display_command

    def run(self, location=u'.'):

        self.outf.write(str(Branch.open_containing(location)[0].revno()))

        self.outf.write('\n')

class cmd_revision_info(Command):

    """Show revision number and revision id for a given revision identifier.

    """

    hidden = True

    takes_args = ['revision_info*']

    takes_options = ['revision']

    @display_command

    def run(self, revision=None, revision_info_list=[]):

        revs = []

        if revision is not None:

            revs.extend(revision)

        if revision_info_list is not None:

            for rev in revision_info_list:

                revs.append(RevisionSpec.from_string(rev))

        if len(revs) == 0:

            raise errors.BzrCommandError('You must supply a revision identifier')

        b = WorkingTree.open_containing(u'.')[0].branch

        for rev in revs:

            revinfo = rev.in_history(b)

            if revinfo.revno is None:

                print '     %s' % revinfo.rev_id

            else:

                print '%4d %s' % (revinfo.revno, revinfo.rev_id)

class cmd_add(Command):

    """Add specified files or directories.

    In non-recursive mode, all the named items are added, regardless

    of whether they were previously ignored.  A warning is given if

    any of the named files are already versioned.

    In recursive mode (the default), files are treated the same way

    but the behaviour for directories is different.  Directories that

    are already versioned do not give a warning.  All directories,

    whether already versioned or not, are searched for files or

    subdirectories that are neither versioned or ignored, and these

    are added.  This search proceeds recursively into versioned

    directories.  If no names are given '.' is assumed.

    Therefore simply saying 'bzr add' will version all files that

    are currently unknown.

    Adding a file whose parent directory is not versioned will

    implicitly add the parent, and so on up to the root. This means

    you should never need to explicitly add a directory, they'll just

    get added when you add a file in the directory.

    --dry-run will show which files would be added, but not actually 

    add them.

    --file-ids-from will try to use the file ids from the supplied path.

    It looks up ids trying to find a matching parent directory with the

    same filename, and then by pure path.

    """

    takes_args = ['file*']

    takes_options = ['no-recurse', 'dry-run', 'verbose',

                     Option('file-ids-from', type=unicode,

                            help='Lookup file ids from here')]

    encoding_type = 'replace'

    def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,

            file_ids_from=None):

        import bzrlib.add

        base_tree = None

        if file_ids_from is not None:

            try:

                base_tree, base_path = WorkingTree.open_containing(

                                            file_ids_from)

            except errors.NoWorkingTree:

                base_branch, base_path = Branch.open_containing(

                                            file_ids_from)

                base_tree = base_branch.basis_tree()

            action = bzrlib.add.AddFromBaseAction(base_tree, base_path,

                          to_file=self.outf, should_print=(not is_quiet()))

        else:

            action = bzrlib.add.AddAction(to_file=self.outf,

                should_print=(not is_quiet()))

        if base_tree:

            base_tree.lock_read()

        try:

            added, ignored = bzrlib.add.smart_add(file_list, not no_recurse,

                action=action, save=not dry_run)

        finally:

            if base_tree is not None:

                base_tree.unlock()

        if len(ignored) > 0:

            if verbose:

                for glob in sorted(ignored.keys()):

                    for path in ignored[glob]:

                        self.outf.write("ignored %s matching \"%s\"\n" 

                                        % (path, glob))

            else:

                match_len = 0

                for glob, paths in ignored.items():

                    match_len += len(paths)

                self.outf.write("ignored %d file(s).\n" % match_len)

            self.outf.write("If you wish to add some of these files,"

                            " please add them by name.\n")

class cmd_mkdir(Command):

    """Create a new versioned directory.

    This is equivalent to creating the directory and then adding it.

    """

    takes_args = ['dir+']

    encoding_type = 'replace'

    def run(self, dir_list):

        for d in dir_list:

            os.mkdir(d)

            wt, dd = WorkingTree.open_containing(d)

            wt.add([dd])

            self.outf.write('added %s\n' % d)

class cmd_relpath(Command):

    """Show path of a file relative to root"""

    takes_args = ['filename']

    hidden = True

    @display_command

    def run(self, filename):

        # TODO: jam 20050106 Can relpath return a munged path if

        #       sys.stdout encoding cannot represent it?

        tree, relpath = WorkingTree.open_containing(filename)

        self.outf.write(relpath)

        self.outf.write('\n')

class cmd_inventory(Command):

    """Show inventory of the current working copy or a revision.

    It is possible to limit the output to a particular entry

    type using the --kind option.  For example: --kind file.

    It is also possible to restrict the list of files to a specific

    set. For example: bzr inventory --show-ids this/file

    See also: bzr ls

    """

    hidden = True

    takes_options = ['revision', 'show-ids', 'kind']

    takes_args = ['file*']

    @display_command

    def run(self, revision=None, show_ids=False, kind=None, file_list=None):

        if kind and kind not in ['file', 'directory', 'symlink']:

            raise errors.BzrCommandError('invalid kind specified')

        work_tree, file_list = tree_files(file_list)

        work_tree.lock_read()

        try:

            if revision is not None:

                if len(revision) > 1:

                    raise errors.BzrCommandError(

                        'bzr inventory --revision takes exactly one revision'

                        ' identifier')

                revision_id = revision[0].in_history(work_tree.branch).rev_id

                tree = work_tree.branch.repository.revision_tree(revision_id)

                extra_trees = [work_tree]

                tree.lock_read()

            else:

                tree = work_tree

                extra_trees = []

            if file_list is not None:

                file_ids = tree.paths2ids(file_list, trees=extra_trees,

                                          require_versioned=True)

                # find_ids_across_trees may include some paths that don't

                # exist in 'tree'.

                entries = sorted((tree.id2path(file_id), tree.inventory[file_id])

                                 for file_id in file_ids if file_id in tree)

            else:

                entries = tree.inventory.entries()

        finally:

            tree.unlock()

            if tree is not work_tree:

                work_tree.unlock()

        for path, entry in entries:

            if kind and kind != entry.kind:

                continue

            if show_ids:

                self.outf.write('%-50s %s\n' % (path, entry.file_id))

            else:

                self.outf.write(path)

                self.outf.write('\n')

class cmd_mv(Command):

    """Move or rename a file.

    usage:

        bzr mv OLDNAME NEWNAME

        bzr mv SOURCE... DESTINATION

    If the last argument is a versioned directory, all the other names

    are moved into it.  Otherwise, there must be exactly two arguments

    and the file is changed to a new name.

    If OLDNAME does not exist on the filesystem but is versioned and

    NEWNAME does exist on the filesystem but is not versioned, mv

    assumes that the file has been manually moved and only updates

    its internal inventory to reflect that change.

    The same is valid when moving many SOURCE files to a DESTINATION.

    Files cannot be moved between branches.

    """

    takes_args = ['names*']

    takes_options = [Option("after", help="move only the bzr identifier"

        " of the file (file has already been moved). Use this flag if"

        " bzr is not able to detect this itself.")]

    aliases = ['move', 'rename']

    encoding_type = 'replace'

    def run(self, names_list, after=False):

        if names_list is None:

            names_list = []

        if len(names_list) < 2:

            raise errors.BzrCommandError("missing file argument")

        tree, rel_names = tree_files(names_list)

        if os.path.isdir(names_list[-1]):

            # move into existing directory

            for pair in tree.move(rel_names[:-1], rel_names[-1], after=after):

                self.outf.write("%s => %s\n" % pair)

        else:

            if len(names_list) != 2:

                raise errors.BzrCommandError('to mv multiple files the'

                                             ' destination must be a versioned'

                                             ' directory')

            tree.rename_one(rel_names[0], rel_names[1], after=after)

            self.outf.write("%s => %s\n" % (rel_names[0], rel_names[1]))

class cmd_pull(Command):

    """Turn this branch into a mirror of another branch.

    This command only works on branches that have not diverged.  Branches are

    considered diverged if the destination branch's most recent commit is one

    that has not been merged (directly or indirectly) into the parent.

    If branches have diverged, you can use 'bzr merge' to integrate the changes

    from one into the other.  Once one branch has merged, the other should

    be able to pull it again.

    If you want to forget your local changes and just update your branch to

    match the remote one, use pull --overwrite.

    If there is no default location set, the first pull will set it.  After

    that, you can omit the location to use the default.  To change the

    default, use --remember. The value will only be saved if the remote

    location can be accessed.

    """

    takes_options = ['remember', 'overwrite', 'revision', 'verbose',

        Option('directory',

            help='branch to pull into, '

                 'rather than the one containing the working directory',

            short_name='d',

            type=unicode,

            ),

        ]

    takes_args = ['location?']

    encoding_type = 'replace'

    def run(self, location=None, remember=False, overwrite=False,

            revision=None, verbose=False,

            directory=None):

        # FIXME: too much stuff is in the command class

        if directory is None:

            directory = u'.'

        try:

            tree_to = WorkingTree.open_containing(directory)[0]

            branch_to = tree_to.branch

        except errors.NoWorkingTree:

            tree_to = None

            branch_to = Branch.open_containing(directory)[0]

        reader = None

        if location is not None:

            try:

                reader = bundle.read_bundle_from_url(location)

            except errors.NotABundle:

                pass # Continue on considering this url a Branch

        stored_loc = branch_to.get_parent()

        if location is None:

            if stored_loc is None:

                raise errors.BzrCommandError("No pull location known or"

                                             " specified.")

            else:

                display_url = urlutils.unescape_for_display(stored_loc,

                        self.outf.encoding)

                self.outf.write("Using saved location: %s\n" % display_url)

                location = stored_loc

        if reader is not None:

            install_bundle(branch_to.repository, reader)

            branch_from = branch_to

        else:

            branch_from = Branch.open(location)

            if branch_to.get_parent() is None or remember:

                branch_to.set_parent(branch_from.base)

        rev_id = None

        if revision is None:

            if reader is not None:

                rev_id = reader.target

        elif len(revision) == 1:

            rev_id = revision[0].in_history(branch_from).rev_id

        else:

            raise errors.BzrCommandError('bzr pull --revision takes one value.')

        old_rh = branch_to.revision_history()

        if tree_to is not None:

            # lock the tree we are pulling too, so that its inventory is

            # stable. This is a hack to workaround the _iter_changes interface

            # not exposing the old path, which will be fixed soon. RBC 20070301

            tree_to.lock_write()

            try:

                count = tree_to.pull(branch_from, overwrite, rev_id,

                    delta.ChangeReporter(tree_to.inventory))

            finally:

                tree_to.unlock()

        else:

            count = branch_to.pull(branch_from, overwrite, rev_id)

        note('%d revision(s) pulled.' % (count,))

        if verbose:

            new_rh = branch_to.revision_history()

            if old_rh != new_rh:

                # Something changed

                from bzrlib.log import show_changed_revisions

                show_changed_revisions(branch_to, old_rh, new_rh,

                                       to_file=self.outf)

class cmd_push(Command):

    """Update a mirror of this branch.

    The target branch will not have its working tree populated because this

    is both expensive, and is not supported on remote file systems.

    Some smart servers or protocols *may* put the working tree in place in

    the future.

    This command only works on branches that have not diverged.  Branches are

    considered diverged if the destination branch's most recent commit is one

    that has not been merged (directly or indirectly) by the source branch.

    If branches have diverged, you can use 'bzr push --overwrite' to replace

    the other branch completely, discarding its unmerged changes.

    If you want to ensure you have the different changes in the other branch,

    do a merge (see bzr help merge) from the other branch, and commit that.

    After that you will be able to do a push without '--overwrite'.

    If there is no default push location set, the first push will set it.

    After that, you can omit the location to use the default.  To change the

    default, use --remember. The value will only be saved if the remote

    location can be accessed.

    """

    takes_options = ['remember', 'overwrite', 'verbose',

        Option('create-prefix',

               help='Create the path leading up to the branch '

                    'if it does not already exist'),

        Option('directory',

            help='branch to push from, '

                 'rather than the one containing the working directory',

            short_name='d',

            type=unicode,

            ),

        Option('use-existing-dir',

               help='By default push will fail if the target'

                    ' directory exists, but does not already'

                    ' have a control directory. This flag will'

                    ' allow push to proceed.'),

        ]

    takes_args = ['location?']

    encoding_type = 'replace'

    def run(self, location=None, remember=False, overwrite=False,

            create_prefix=False, verbose=False,

            use_existing_dir=False,

            directory=None):

        # FIXME: Way too big!  Put this into a function called from the