~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

import sys

 

import bzrlib

from bzrlib.commands import Command, display_command

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

                           NotBranchError, DivergedBranches, NotConflicted,

                           NoSuchFile, NoWorkingTree, FileInWrongBranch,

from bzrlib.merge import Merge3Merger

from bzrlib.option import Option

from bzrlib.progress import DummyProgress, ProgressPhase

from bzrlib.revision import common_ancestor

from bzrlib.revisionspec import RevisionSpec

from bzrlib.transport.local import LocalTransport

from bzrlib.workingtree import WorkingTree

 

 

        return bzrdir.BzrDirMetaFormat1()

    if typestring == "metaweave":

        format = bzrdir.BzrDirMetaFormat1()

        return format

    if typestring == "knit":

        format = bzrdir.BzrDirMetaFormat1()

        return format

    msg = "Unknown bzr format %s. Current formats are: default, knit,\n" \

          "metaweave and weave" % typestring

    modified

        Text has changed since the previous revision.

 

    unknown

        Not versioned and not matching an ignore pattern.

 

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

    

    takes_args = ['file*']

    aliases = ['st', 'stat']

    

    @display_command

        from bzrlib.status import show_tree_status

 

 

class cmd_cat_revision(Command):

    hidden = True

    takes_args = ['revision_id?']

    takes_options = ['revision']

    

    @display_command

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

        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:

        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)

    

 

class cmd_revno(Command):

    """Show current revision number.

 

    takes_args = ['location?']

    @display_command

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

 

 

class cmd_revision_info(Command):

    hidden = True

    takes_args = ['revision_info*']

    takes_options = ['revision']

    @display_command

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

 

 

    Adding a file whose parent directory is not versioned will

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

    get added when you add a file in the directory.

 

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

    """

    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

 

 

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

        if len(ignored) > 0:

            if verbose:

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

                    for path in ignored[glob]:

            else:

                match_len = 0

                for glob, paths in ignored.items():

                    match_len += len(paths)

 

 

class cmd_mkdir(Command):

 

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

 

 

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)

 

 

class cmd_inventory(Command):

    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

            if kind and kind != entry.kind:

                continue

            if show_ids:

            else:

 

 

class cmd_mv(Command):

 

    Files cannot be moved between branches.

    """

    takes_args = ['names*']

    aliases = ['move', 'rename']

 

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

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

            

    

class cmd_pull(Command):

    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

    """

    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

            branch_to = tree_to.branch

        except NoWorkingTree:

            tree_to = None

        stored_loc = branch_to.get_parent()

        if location is None:

            if stored_loc is None:

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

            else:

                location = stored_loc

 

        if revision is None:

        elif len(revision) == 1:

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

        else:

            if old_rh != new_rh:

                # Something changed

                from bzrlib.log import show_changed_revisions

 

 

class cmd_push(Command):

 

    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

    """

                     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.

        

        br_from = Branch.open_containing('.')[0]

        stored_loc = br_from.get_push_location()

            if stored_loc is None:

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

            else:

                location = stored_loc

        try:

            br_to = dir_to.open_branch()

        except NotBranchError:

            # create a branch.

            if not create_prefix:

                try:

                except NoSuchFile:

                    raise BzrCommandError("Parent directory of %s "

                                          "does not exist." % location)

            else:

                while needed:

                    try:

                        needed.pop()

                    except NoSuchFile:

                        needed.append((new_transport,

                            raise BzrCommandError("Could not create "

                                                  "path prefix.")

                revision_id=br_from.last_revision())

            br_to = dir_to.open_branch()

            count = len(br_to.revision_history())

        else:

            old_rh = br_to.revision_history()

            try:

                try:

            if old_rh != new_rh:

                # Something changed

                from bzrlib.log import show_changed_revisions

 

 

class cmd_branch(Command):

    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:

                name = None

            else:

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

            try:

            try:

                # preserve whatever source format we have.

                branch = dir.open_branch()

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

                raise BzrCommandError(msg)

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

                                 "such access, and also support local commits."

                            ),

                     ]

 

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

            lightweight=False):

            raise BzrCommandError(

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

        if branch_location is None:

            to_location = branch_location

        source = Branch.open(branch_location)

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

        # if the source and to_location are the same, 

        # and there is no working tree,

        # then reconstitute a branch

            try:

                source.bzrdir.open_workingtree()

            except errors.NoWorkingTree:

                                      to_location)

            else:

                raise

        try:

            if lightweight:

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

            else:

                    to_location, force_new_tree=False)

                checkout = checkout_branch.bzrdir

                checkout_branch.bind(source)

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

            checkout.create_workingtree(revision_id)

        finally:

 

 

class cmd_renames(Command):

 

    @display_command

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

        tree = WorkingTree.open_containing(dir)[0]

        old_inv = tree.basis_tree().inventory

        new_inv = tree.read_working_inventory()

        renames.sort()

        for old_name, new_name in renames:

 

 

class cmd_update(Command):

    'bzr revert' instead of 'bzr commit' after the update.

    """

    takes_args = ['dir?']

 

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

        tree = WorkingTree.open_containing(dir)[0]

        tree.lock_write()

        try:

                # may be up to date, check master too.

                master = tree.branch.get_master_branch()

            conflicts = tree.update()

            if conflicts != 0:

                return 1

            else:

 

    This makes bzr stop tracking changes to a versioned file.  It does

    not delete the working copy.

    """

    aliases = ['rm']

    

        tree, file_list = tree_files(file_list)

 

 

class cmd_file_id(Command):

    same through all revisions where the file exists, even when it is

    moved or renamed.

    """

    hidden = True

    takes_args = ['filename']

    @display_command

    def run(self, filename):

        tree, relpath = WorkingTree.open_containing(filename)

        if i == None:

            raise BzrError("%r is not a versioned file" % filename)

        else:

 

 

class cmd_file_path(Command):

    """Print path of file_ids to a file or directory.

 

    This prints one line for each directory down to the target,

    hidden = True

    takes_args = ['filename']

    @display_command

    def run(self, filename):

        tree, relpath = WorkingTree.open_containing(filename)

        if fid == None:

            raise BzrError("%r is not a versioned file" % filename)

        for fip in inv.get_idpath(fid):

 

 

class cmd_reconcile(Command):

 

    def run(self, branch="."):

        from bzrlib.reconcile import reconcile

        reconcile(dir)

 

 

class cmd_revision_history(Command):

    hidden = True

    @display_command

 

 

class cmd_ancestry(Command):

    """List all revisions merged into this branch."""

    hidden = True

    @display_command

        assert revision_ids[0] == None

        revision_ids.pop(0)

        for revision_id in revision_ids:

 

 

class cmd_init(Command):

                            type=get_format_type),

                     ]

    def run(self, location=None, format=None):

        if format is None:

            format = get_format_type('default')

        if location is None:

            location = u'.'

        try:

            existing_bzrdir = bzrdir.BzrDir.open(location)

        except NotBranchError:

            bzrdir.BzrDir.create_branch_convenience(location, format=format)

        else:

            if existing_bzrdir.has_branch():

            else:

                existing_bzrdir.create_branch()

                existing_bzrdir.create_workingtree()

                             ' a working tree')]

    aliases = ["init-repo"]

    def run(self, location, format=None, trees=False):

        if format is None:

            format = get_format_type('default')

        repo = newdir.create_repository(shared=True)

        repo.set_make_working_trees(trees)

 

 

class cmd_diff(Command):

    

    If files are listed, only the changes in those files are listed.

    Otherwise, all changes for the tree are listed.

 

    examples:

        bzr diff

        bzr diff -r1

        bzr diff -r1..2

        bzr diff --diff-prefix old/:new/

        bzr diff bzr.mine bzr.dev

        bzr diff foo.c

    """

    # TODO: Option to use external diff command; could be GNU diff, wdiff,

    #       or a graphical diff.

    takes_args = ['file*']

    takes_options = ['revision', 'diff-options', 'prefix']

    aliases = ['di', 'dif']

 

    @display_command

    def run(self, revision=None, file_list=None, diff_options=None,

                # FIXME diff those two files. rbc 20051123

                raise BzrCommandError("Files are in different branches")

            file_list = None

        if revision is not None:

            if tree2 is not None:

                raise BzrCommandError("Can't specify -r with two branches")

    # directories with readdir, rather than stating each one.  Same

    # level of effort but possibly much less IO.  (Or possibly not,

    # if the directories are very large...)

    @display_command

    def run(self, show_ids=False):

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

        old = tree.basis_tree()

        for path, ie in old.inventory.iter_entries():

            if not tree.has_id(ie.file_id):

                if show_ids:

 

 

class cmd_modified(Command):

    hidden = True

    @display_command

    def run(self):

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

        for path, id, kind, text_modified, meta_modified in td.modified:

 

 

class cmd_added(Command):

            if file_id in basis_inv:

                continue

            path = inv.id2path(file_id)

                continue

 

class cmd_root(Command):

    """Show the tree root directory.

    def run(self, filename=None):

        """Print the branch root."""

        tree = WorkingTree.open_containing(filename)[0]

 

 

class cmd_log(Command):

                            type=str),

                     'short',

                     ]

    @display_command

    def run(self, location=None, timezone='original',

            verbose=False,

            short=False,

            line=False):

        from bzrlib.log import log_formatter, show_log

        assert message is None or isinstance(message, basestring), \

            "invalid message argument %r" % message

        direction = (forward and 'forward') or 'reverse'

        if rev1 > rev2:

            (rev2, rev1) = (rev1, rev2)

 

        if (log_format == None):

        lf = log_formatter(log_format,

                           show_ids=show_ids,

                           show_timezone=timezone)

 

        show_log(b,

class cmd_touching_revisions(Command):

    """Return revision-ids which affected a particular file.

 

    hidden = True

    takes_args = ["filename"]

    @display_command

    def run(self, filename):

        tree, relpath = WorkingTree.open_containing(filename)

        b = tree.branch

        inv = tree.read_working_inventory()

        file_id = inv.path2id(relpath)

 

 

class cmd_ls(Command):

        if revision is not None:

            tree = tree.branch.repository.revision_tree(

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

        for fp, fc, kind, fid, entry in tree.list_files():

            if fp.startswith(relpath):

                fp = fp[len(relpath):]

                    continue

                if verbose:

                    kindch = entry.kind_character()

                elif null:

                else:

 

 

class cmd_unknowns(Command):

    """List unknown files."""

    @display_command

    def run(self):

        for f in WorkingTree.open_containing(u'.')[0].unknowns():

 

 

class cmd_ignore(Command):

        bzr ignore '*.class'

    """

    # TODO: Complain if the filename is absolute

    

        from bzrlib.atomicfile import AtomicFile

        tree, relpath = WorkingTree.open_containing(u'.')

        ifn = tree.abspath('.bzrignore')

        if os.path.exists(ifn):

            f = open(ifn, 'rt')

            try:

    takes_args = ['dest']

    takes_options = ['revision', 'format', 'root']

    def run(self, dest, revision=None, format=None, root=None):

        from bzrlib.export import export

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

        b = tree.branch

    hidden = True    

    @display_command

    def run(self):

 

 

 

        from bzrlib.msgeditor import edit_commit_message, \

                make_commit_message_template

        from tempfile import TemporaryFile

 

        # TODO: Need a blackbox test for invoking the external editor; may be

        # slightly problematic to run this cross-platform.

            raise BzrCommandError("please specify either --message or --file")

        

        if file:

            message = codecs.open(file, 'rt', bzrlib.user_encoding).read()

 

        if message == "":

        

        if verbose:

            reporter = ReportCommitToLog()

        except PointlessCommit:

            # FIXME: This should really happen before the file is read in;

            # perhaps prepare the commit; get the message; then actually commit

        except ConflictsInTree:

            raise BzrCommandError("Conflicts detected in working tree.  "

                'Use "bzr conflicts" to list, "bzr resolve FILE" to resolve.')

            raise BzrCommandError("Commit refused because there are unknown "

                                  "files in the working tree.")

        except errors.BoundBranchOutOfDate, e:

 

class cmd_check(Command):

    """Validate consistency of branch history.

 

 

class cmd_whoami(Command):

    

    @display_command

        try:

        

        else:

 

 

class cmd_nick(Command):

        # we don't want progress meters from the tests to go to the

        # real output; and we don't want log messages cluttering up

        # the real logs.

        print '%10s: %s' % ('bzrlib', bzrlib.__path__[0])

        print

        try:

            if testspecs_list is not None:

                pattern = '|'.join(testspecs_list)

            else:

                              test_suite_factory=test_suite_factory,

                              lsprof_timed=lsprof_timed)

            if result:

            else:

            return int(not result)

        finally:

 

 

def _get_bzr_branch():

    """If bzr is run from a branch, return Branch or None"""

    from os.path import dirname

    

    try:

        return branch

        return None

    

 

def show_version():

    # is bzrlib itself in a branch?

    branch = _get_bzr_branch()

    if branch:

        print "  nick: %s" % (branch.nick,)

        if rh:

            print "  revid: %s" % (rh[-1],)

    print bzrlib.__copyright__

    print "http://bazaar-vcs.org/"

    print

 

class cmd_version(Command):

    """Show version of bzr."""

    @display_command

    def run(self):

        show_version()

 

class cmd_rocks(Command):

    """Statement of optimism."""

    hidden = True

    @display_command

    def run(self):

        print "it sure does!"

 

 

class cmd_find_merge_base(Command):

    # TODO: Options to specify revisions on either side, as if

    #       merging only part of the history.

    takes_args = ['branch', 'other']

        base_rev_id = common_ancestor(last1, last2, source)

 

        print 'merge base is revision %s' % base_rev_id