~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2004, 2005, 2006 by 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 errno

import os

from shutil import rmtree

import sys

import bzrlib

import bzrlib.branch

from bzrlib.branch import Branch

import bzrlib.bzrdir as bzrdir

from bzrlib.commands import Command, display_command

from bzrlib.revision import common_ancestor

import bzrlib.errors as errors

from bzrlib.errors import (BzrError, BzrCheckError, BzrCommandError, 

                           NotBranchError, DivergedBranches, NotConflicted,

                           NoSuchFile, NoWorkingTree, FileInWrongBranch,

                           NotVersionedError)

from bzrlib.log import show_one_log

from bzrlib.merge import Merge3Merger

from bzrlib.option import Option

from bzrlib.progress import DummyProgress

from bzrlib.revisionspec import RevisionSpec

import bzrlib.trace

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

from bzrlib.transport.local import LocalTransport

import bzrlib.ui

from bzrlib.workingtree import WorkingTree

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

    try:

        return internal_tree_files(file_list, default_branch)

    except FileInWrongBranch, e:

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

                             (e.path, file_list[0]))

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

    """\

    Return a branch and list of branch-relative paths.

    If supplied file_list is empty or None, the branch default will be used,

    and returned file_list will match the original.

    """

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

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

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

    new_list = []

    for filename in file_list:

        try:

            new_list.append(tree.relpath(filename))

        except errors.PathNotChild:

            raise FileInWrongBranch(tree.branch, filename)

    return tree, 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.

    unchanged

        Nothing about this file has changed since the previous revision.

        Only shown with --all.

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

    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 = ['all', 'show-ids', 'revision']

    aliases = ['st', 'stat']

    @display_command

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

        tree, file_list = tree_files(file_list)

        from bzrlib.status import show_tree_status

        show_tree_status(tree, show_unchanged=all, show_ids=show_ids,

                         specific_files=file_list, revision=revision)

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

    @display_command

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

        if revision_id is not None and revision is not None:

            raise BzrCommandError('You can only supply one of revision_id or --revision')

        if revision_id is None and revision is None:

            raise BzrCommandError('You must supply either --revision or a revision_id')

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

        if revision_id is not None:

            sys.stdout.write(b.repository.get_revision_xml(revision_id))

        elif revision is not None:

            for rev in revision:

                if rev is None:

                    raise BzrCommandError('You cannot specify a NULL revision.')

                revno, rev_id = rev.in_history(b)

                sys.stdout.write(b.repository.get_revision_xml(rev_id))

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

        print Branch.open_containing(location)[0].revno()

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(rev))

        if len(revs) == 0:

            raise 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 explictly 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.

    """

    takes_args = ['file*']

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

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

        import bzrlib.add

        if dry_run:

            if is_quiet():

                # This is pointless, but I'd rather not raise an error

                action = bzrlib.add.add_action_null

            else:

                action = bzrlib.add.add_action_print

        elif is_quiet():

            action = bzrlib.add.add_action_add

        else:

            action = bzrlib.add.add_action_add_and_print

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

                                              action)

        if len(ignored) > 0:

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

                match_len = len(ignored[glob])

                if verbose:

                    for path in ignored[glob]:

                        print "ignored %s matching \"%s\"" % (path, glob)

                else:

                    print "ignored %d file(s) matching \"%s\"" % (match_len,

                                                              glob)

            print "If you wish to add some of these files, please add them"\

                " by name."

class cmd_mkdir(Command):

    """Create a new versioned directory.

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

    """

    takes_args = ['dir+']

    def run(self, dir_list):

        for d in dir_list:

            os.mkdir(d)

            wt, dd = WorkingTree.open_containing(d)

            wt.add([dd])

            print 'added', d

class cmd_relpath(Command):

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

    takes_args = ['filename']

    hidden = True

    @display_command

    def run(self, filename):

        tree, relpath = WorkingTree.open_containing(filename)

        print relpath

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.

    """

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

    @display_command

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

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

            raise BzrCommandError('invalid kind specified')

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

        if revision is None:

            inv = tree.read_working_inventory()

        else:

            if len(revision) > 1:

                raise BzrCommandError('bzr inventory --revision takes'

                    ' exactly one revision identifier')

            inv = tree.branch.repository.get_revision_inventory(

                revision[0].in_history(tree.branch).rev_id)

        for path, entry in inv.entries():

            if kind and kind != entry.kind:

                continue

            if show_ids:

                print '%-50s %s' % (path, entry.file_id)

            else:

                print path

class cmd_move(Command):

    """Move files to a different directory.

    examples:

        bzr move *.txt doc

    The destination must be a versioned directory in the same branch.

    """

    takes_args = ['source$', 'dest']

    def run(self, source_list, dest):

        tree, source_list = tree_files(source_list)

        # TODO: glob expansion on windows?

        tree.move(source_list, tree.relpath(dest))

class cmd_rename(Command):

    """Change the name of an entry.

    examples:

      bzr rename frob.c frobber.c

      bzr rename src/frob.c lib/frob.c

    It is an error if the destination name exists.

    See also the 'move' command, which moves files into a different

    directory without changing their name.

    """

    # TODO: Some way to rename multiple files without invoking 

    # bzr for each one?"""

    takes_args = ['from_name', 'to_name']

    def run(self, from_name, to_name):

        tree, (from_name, to_name) = tree_files((from_name, to_name))

        tree.rename_one(from_name, to_name)

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, which must not already exist.

    Files cannot be moved between branches.

    """

    takes_args = ['names*']

    def run(self, names_list):

        if len(names_list) < 2:

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

                print "%s => %s" % pair

        else:

            if len(names_list) != 2:

                raise BzrCommandError('to mv multiple files the destination '

                                      'must be a versioned directory')

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

            print "%s => %s" % (rel_names[0], rel_names[1])

class cmd_pull(Command):

    """Pull any changes from another branch into the current one.

    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.

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

    considered diverged if both branches have had commits without first

    pulling from the other.

    If branches have diverged, you can use 'bzr merge' to pull the text 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 --overwrite.

    """

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

    takes_args = ['location?']

    def run(self, location=None, remember=False, overwrite=False, revision=None, verbose=False):

        # FIXME: too much stuff is in the command class        

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

        stored_loc = tree_to.branch.get_parent()

        if location is None:

            if stored_loc is None:

                raise BzrCommandError("No pull location known or specified.")

            else:

                print "Using saved location: %s" % stored_loc

                location = stored_loc

        br_from = Branch.open(location)

        br_to = tree_to.branch

        if revision is None:

            rev_id = None

        elif len(revision) == 1:

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

        else:

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

        old_rh = br_to.revision_history()

        count = tree_to.pull(br_from, overwrite, rev_id)

        if br_to.get_parent() is None or remember:

            br_to.set_parent(location)

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

        if verbose:

            new_rh = tree_to.branch.revision_history()

            if old_rh != new_rh:

                # Something changed

                from bzrlib.log import show_changed_revisions

                show_changed_revisions(tree_to.branch, old_rh, new_rh)

class cmd_push(Command):

    """Push this branch into another branch.

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

    is both expensive, and may not be supported on the remote file system.

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

    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.

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

    considered diverged if the branch being pushed to is not an older version

    of this branch.

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

    the other branch completely.

    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

    before doing a 'push --overwrite'.

    """

    takes_options = ['remember', 'overwrite', 

                     Option('create-prefix', 

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

                                 'if it does not already exist')]

    takes_args = ['location?']

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

            create_prefix=False, verbose=False):

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

        # command.

        from bzrlib.transport import get_transport

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

        br_from = tree_from.branch

        stored_loc = tree_from.branch.get_push_location()

        if location is None:

            if stored_loc is None:

                raise BzrCommandError("No push location known or specified.")

            else:

                print "Using saved location: %s" % stored_loc

                location = stored_loc

        try:

            br_to = Branch.open(location)

        except NotBranchError:

            # create a branch.

            transport = get_transport(location).clone('..')

            if not create_prefix:

                try:

                    transport.mkdir(transport.relpath(location))

                except NoSuchFile:

                    raise BzrCommandError("Parent directory of %s "

                                          "does not exist." % location)

            else:

                current = transport.base

                needed = [(transport, transport.relpath(location))]

                while needed:

                    try:

                        transport, relpath = needed[-1]

                        transport.mkdir(relpath)

                        needed.pop()

                    except NoSuchFile:

                        new_transport = transport.clone('..')

                        needed.append((new_transport,

                                       new_transport.relpath(transport.base)))

                        if new_transport.base == transport.base:

                            raise BzrCommandError("Could not creeate "

                                                  "path prefix.")

            br_to = bzrlib.bzrdir.BzrDir.create_branch_convenience(location)

        old_rh = br_to.revision_history()

        try:

            try:

                tree_to = br_to.working_tree()

            except NoWorkingTree:

                # TODO: This should be updated for branches which don't have a

                # working tree, as opposed to ones where we just couldn't 

                # update the tree.

                warning('Unable to update the working tree of: %s' % (br_to.base,))

                count = br_to.pull(br_from, overwrite)

            else:

                count = tree_to.pull(br_from, overwrite)

        except DivergedBranches:

            raise BzrCommandError("These branches have diverged."

                                  "  Try a merge then push with overwrite.")

        if br_from.get_push_location() is None or remember:

            br_from.set_push_location(location)

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

        if verbose:

            new_rh = br_to.revision_history()

            if old_rh != new_rh:

                # Something changed

                from bzrlib.log import show_changed_revisions

                show_changed_revisions(br_to, old_rh, new_rh)

class cmd_branch(Command):

    """Create a new copy of a branch.

    If the TO_LOCATION is omitted, the last component of the FROM_LOCATION will

    be used.  In other words, "branch ../foo/bar" will attempt to create ./bar.

    To retrieve the branch as of a particular revision, supply the --revision

    parameter, as in "branch foo/bar -r 5".

    --basis is to speed up branching from remote branches.  When specified, it

    copies all the file-contents, inventory and revision data from the basis

    branch before copying anything from the remote branch.

    """

    takes_args = ['from_location', 'to_location?']

    takes_options = ['revision', 'basis']

    aliases = ['get', 'clone']

    def run(self, from_location, to_location=None, revision=None, basis=None):

        if revision is None:

            revision = [None]

        elif len(revision) > 1:

            raise BzrCommandError(

                'bzr branch --revision takes exactly 1 revision value')

        try:

            br_from = Branch.open(from_location)

        except OSError, e:

            if e.errno == errno.ENOENT:

                raise BzrCommandError('Source location "%s" does not'

                                      ' exist.' % to_location)

            else:

                raise

        br_from.lock_read()

        try:

            if basis is not None:

                basis_dir = bzrdir.BzrDir.open_containing(basis)[0]

            else:

                basis_dir = None

            if len(revision) == 1 and revision[0] is not None:

                revision_id = revision[0].in_history(br_from)[1]

            else:

                # FIXME - wt.last_revision, fallback to branch, fall back to

                # None or perhaps NULL_REVISION to mean copy nothing

                # RBC 20060209

                revision_id = br_from.last_revision()

            if to_location is None:

                to_location = os.path.basename(from_location.rstrip("/\\"))

                name = None

            else:

                name = os.path.basename(to_location) + '\n'

            try:

                os.mkdir(to_location)

            except OSError, e:

                if e.errno == errno.EEXIST:

                    raise BzrCommandError('Target directory "%s" already'

                                          ' exists.' % to_location)

                if e.errno == errno.ENOENT:

                    raise BzrCommandError('Parent of "%s" does not exist.' %

                                          to_location)

                else:

                    raise

            try:

                # preserve whatever source format we have.

                dir = br_from.bzrdir.sprout(to_location, revision_id, basis_dir)

                branch = dir.open_branch()

            except bzrlib.errors.NoSuchRevision:

                rmtree(to_location)

                msg = "The branch %s has no revision %s." % (from_location, revision[0])

                raise BzrCommandError(msg)

            except bzrlib.errors.UnlistableBranch:

                rmtree(to_location)

                msg = "The branch %s cannot be used as a --basis" % (basis,)

                raise BzrCommandError(msg)

            if name:

                branch.control_files.put_utf8('branch-name', name)

            note('Branched %d revision(s).' % branch.revno())

        finally:

            br_from.unlock()

class cmd_checkout(Command):

    """Create a new checkout of an existing branch.

    If the TO_LOCATION is omitted, the last component of the BRANCH_LOCATION will

    be used.  In other words, "checkout ../foo/bar" will attempt to create ./bar.

    To retrieve the branch as of a particular revision, supply the --revision

    parameter, as in "checkout foo/bar -r 5". Note that this will be immediately

    out of date [so you cannot commit] but it may be useful (i.e. to examine old

    code.)

    --basis is to speed up checking out from remote branches.  When specified, it

    uses the inventory and file contents from the basis branch in preference to the

    branch being checked out. [Not implemented yet.]

    """

    takes_args = ['branch_location', 'to_location?']

    takes_options = ['revision', # , 'basis']

                     Option('lightweight',

                            help="perform a lightweight checkout. Lightweight "

                                 "checkouts depend on access to the branch for "

                                 "every operation. Normal checkouts can perform "

                                 "common operations like diff and status without "

                                 "such access, and also support local commits."

                            ),

                     ]

    def run(self, branch_location, to_location=None, revision=None, basis=None,

            lightweight=False):

        if revision is None:

            revision = [None]

        elif len(revision) > 1:

            raise BzrCommandError(

                'bzr checkout --revision takes exactly 1 revision value')

        source = Branch.open(branch_location)

        if len(revision) == 1 and revision[0] is not None:

            revision_id = revision[0].in_history(source)[1]

        else:

            revision_id = None

        if to_location is None:

            to_location = os.path.basename(branch_location.rstrip("/\\"))

        try:

            os.mkdir(to_location)

        except OSError, e:

            if e.errno == errno.EEXIST:

                raise BzrCommandError('Target directory "%s" already'

                                      ' exists.' % to_location)

            if e.errno == errno.ENOENT:

                raise BzrCommandError('Parent of "%s" does not exist.' %

                                      to_location)

            else:

                raise

        old_format = bzrlib.bzrdir.BzrDirFormat.get_default_format()

        bzrlib.bzrdir.BzrDirFormat.set_default_format(bzrdir.BzrDirMetaFormat1())

        try:

            if lightweight:

                checkout = bzrdir.BzrDirMetaFormat1().initialize(to_location)

                bzrlib.branch.BranchReferenceFormat().initialize(checkout, source)

            else:

                checkout_branch =  bzrlib.bzrdir.BzrDir.create_branch_convenience(

                    to_location, force_new_tree=False)

                checkout = checkout_branch.bzrdir

                checkout_branch.bind(source)

                if revision_id is not None:

                    rh = checkout_branch.revision_history()

                    checkout_branch.set_revision_history(rh[:rh.index(revision_id) + 1])

            checkout.create_workingtree(revision_id)

        finally:

            bzrlib.bzrdir.BzrDirFormat.set_default_format(old_format)

class cmd_renames(Command):

    """Show list of renamed files.

    """