/brz/remove-bazaar

# Copyright (C) 2004, 2005, 2006, 2007, 2008 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 cStringIO

import sys

import time

import bzrlib

from bzrlib import (

    bugtracker,

    bundle,

    btree_index,

    bzrdir,

    delta,

    config,

    errors,

    globbing,

    log,

    merge as _mod_merge,

    merge_directive,

    osutils,

    reconfigure,

    revision as _mod_revision,

    symbol_versioning,

    transport,

    tree as _mod_tree,

    ui,

    urlutils,

    )

from bzrlib.branch import Branch

from bzrlib.conflicts import ConflictList

from bzrlib.option import _parse_revision_str

from bzrlib.revisionspec import RevisionSpec

from bzrlib.smtp_connection import SMTPConnection

from bzrlib.workingtree import WorkingTree

""")

from bzrlib.commands import Command, display_command

from bzrlib.option import ListOption, Option, RegistryOption, custom_help

from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level

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]))

def _get_one_revision_tree(command_name, revisions, branch=None, tree=None):

    if branch is None:

        branch = tree.branch

    if revisions is None:

        if tree is not None:

            rev_tree = tree.basis_tree()

        else:

            rev_tree = branch.basis_tree()

    else:

        if len(revisions) != 1:

            raise errors.BzrCommandError(

                'bzr %s --revision takes exactly one revision identifier' % (

                    command_name,))

        rev_tree = revisions[0].as_tree(branch)

    return rev_tree

# 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]

    return tree, safe_relpath_files(tree, file_list)

def safe_relpath_files(tree, file_list):

    """Convert file_list into a list of relpaths in tree.

    :param tree: A tree to operate on.

    :param file_list: A list of user provided paths or None.

    :return: A list of relative paths.

    :raises errors.PathNotChild: When a provided path is in a different tree

        than tree.

    """

    if file_list is None:

        return None

    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 new_list

# 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 on the

    changes to file texts, use 'bzr diff'.

    Note that --short or -S gives status flags for each item, similar

    to Subversion's status command. To get output similar to svn -q,

    use bzr status -SV.

    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', 'change',

                     Option('short', help='Use short status indicators.',

                            short_name='S'),

                     Option('versioned', help='Only show versioned files.',

                            short_name='V'),

                     Option('no-pending', help='Don\'t show pending merges.',

                           ),

                     ]

    aliases = ['st', 'stat']

    encoding_type = 'replace'

    _see_also = ['diff', 'revert', 'status-flags']

    @display_command

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

            versioned=False, no_pending=False):

        from bzrlib.status import show_tree_status

        if revision and len(revision) > 2:

            raise errors.BzrCommandError('bzr status --revision takes exactly'

                                         ' one or two revision specifiers')

        tree, relfile_list = tree_files(file_list)

        # Avoid asking for specific files when that is not needed.

        if relfile_list == ['']:

            relfile_list = None

            # Don't disable pending merges for full trees other than '.'.

            if file_list == ['.']:

                no_pending = True

        # A specific path within a tree was given.

        elif relfile_list is not None:

            no_pending = True

        show_tree_status(tree, show_ids=show_ids,

                         specific_files=relfile_list, revision=revision,

                         to_file=self.outf, short=short, versioned=versioned,

                         show_pending=(not no_pending))

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:

            revision_id = osutils.safe_revision_id(revision_id, warn=False)

            try:

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

            except errors.NoSuchRevision:

                msg = "The repository %s contains no revision %s." % (b.repository.base,

                    revision_id)

                raise errors.BzrCommandError(msg)

        elif revision is not None:

            for rev in revision:

                if rev is None:

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

                                                 ' revision.')

                rev_id = rev.as_revision_id(b)

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

class cmd_dump_btree(Command):

    """Dump the contents of a btree index file to stdout.

    PATH is a btree index file, it can be any URL. This includes things like

    .bzr/repository/pack-names, or .bzr/repository/indices/a34b3a...ca4a4.iix

    By default, the tuples stored in the index file will be displayed. With

    --raw, we will uncompress the pages, but otherwise display the raw bytes

    stored in the index.

    """

    # TODO: Do we want to dump the internal nodes as well?

    # TODO: It would be nice to be able to dump the un-parsed information,

    #       rather than only going through iter_all_entries. However, this is

    #       good enough for a start

    hidden = True

    encoding_type = 'exact'

    takes_args = ['path']

    takes_options = [Option('raw', help='Write the uncompressed bytes out,'

                                        ' rather than the parsed tuples.'),

                    ]

    def run(self, path, raw=False):

        dirname, basename = osutils.split(path)

        t = transport.get_transport(dirname)

        if raw:

            self._dump_raw_bytes(t, basename)

        else:

            self._dump_entries(t, basename)

    def _get_index_and_bytes(self, trans, basename):

        """Create a BTreeGraphIndex and raw bytes."""

        bt = btree_index.BTreeGraphIndex(trans, basename, None)

        bytes = trans.get_bytes(basename)

        bt._file = cStringIO.StringIO(bytes)

        bt._size = len(bytes)

        return bt, bytes

    def _dump_raw_bytes(self, trans, basename):

        import zlib

        # We need to parse at least the root node.

        # This is because the first page of every row starts with an

        # uncompressed header.

        bt, bytes = self._get_index_and_bytes(trans, basename)

        for page_idx, page_start in enumerate(xrange(0, len(bytes),

                                                     btree_index._PAGE_SIZE)):

            page_end = min(page_start + btree_index._PAGE_SIZE, len(bytes))

            page_bytes = bytes[page_start:page_end]

            if page_idx == 0:

                self.outf.write('Root node:\n')

                header_end, data = bt._parse_header_from_bytes(page_bytes)

                self.outf.write(page_bytes[:header_end])

                page_bytes = data

            self.outf.write('\nPage %d\n' % (page_idx,))

            decomp_bytes = zlib.decompress(page_bytes)

            self.outf.write(decomp_bytes)

            self.outf.write('\n')

    def _dump_entries(self, trans, basename):

        try:

            st = trans.stat(basename)

        except errors.TransportNotPossible:

            # We can't stat, so we'll fake it because we have to do the 'get()'

            # anyway.

            bt, _ = self._get_index_and_bytes(trans, basename)

        else:

            bt = btree_index.BTreeGraphIndex(trans, basename, st.st_size)

        for node in bt.iter_all_entries():

            # Node is made up of:

            # (index, key, value, [references])

            self.outf.write('%s\n' % (node[1:],))

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.

    To re-create the working tree, use "bzr checkout".

    """

    _see_also = ['checkout', 'working-trees']

    takes_args = ['location?']

    takes_options = [

        Option('force',

               help='Remove the working tree even if it has '

                    'uncommitted changes.'),

        ]

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

        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")

        if not force:

            changes = working.changes_from(working.basis_tree())

            if changes.has_changed():

                raise errors.UncommittedChanges(working)

        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.

    """

    _see_also = ['info']

    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',

        Option('directory',

            help='Branch to examine, '

                 'rather than the one containing the working directory.',

            short_name='d',

            type=unicode,

            ),

        ]

    @display_command

    def run(self, revision=None, directory=u'.', 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))

        b = Branch.open_containing(directory)[0]

        if len(revs) == 0:

            revs.append(RevisionSpec.from_string('-1'))

        for rev in revs:

            revision_id = rev.as_revision_id(b)

            try:

                revno = '%4d' % (b.revision_id_to_revno(revision_id))

            except errors.NoSuchRevision:

                dotted_map = b.get_revision_id_to_revno_map()

                revno = '.'.join(str(i) for i in dotted_map[revision_id])

            print '%s %s' % (revno, revision_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. This option is rarely needed

    but can be useful when adding the same logical file into two

    branches that will be merged later (without showing the two different

    adds as a conflict). It is also useful when merging another project

    into a subdirectory of this one.

    """

    takes_args = ['file*']

    takes_options = [

        Option('no-recurse',

               help="Don't recursively add the contents of directories."),

        Option('dry-run',

               help="Show what would be done, but don't actually do anything."),

        'verbose',

        Option('file-ids-from',

               type=unicode,

               help='Lookup file ids from this tree.'),

        ]

    encoding_type = 'replace'

    _see_also = ['remove']

    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:

            file_list = self._maybe_expand_globs(file_list)

            if file_list:

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

            else:

                tree = WorkingTree.open_containing(u'.')[0]

            added, ignored = tree.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

    """

    hidden = True

    _see_also = ['ls']

    takes_options = [

        'revision',

        'show-ids',

        Option('kind',

               help='List entries of a particular kind: file, directory, symlink.',

               type=unicode),

        ]

    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 %r specified' % (kind,))

        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')

                tree = revision[0].as_tree(work_tree.branch)

                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, because the file has already been moved."),

        ]

    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)

        tree.lock_write()

        try:

            self._run(tree, names_list, rel_names, after)

        finally:

            tree.unlock()