~bzr-pqm/bzr/bzr.dev

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

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

 

# DO NOT change this to cStringIO - it results in control files 

# written as UCS4

# FIXIT! (Only deal with byte streams OR unicode at any one layer.)

# RBC 20051018

from StringIO import StringIO

import sys

import os

from bzrlib import BZRDIR

from bzrlib.commands import Command, display_command

from bzrlib.branch import Branch

from bzrlib.option import Option

from bzrlib.revisionspec import RevisionSpec

import bzrlib.trace

from bzrlib.workingtree import WorkingTree

    """\

    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:

    new_list = []

    for filename in file_list:

        try:

            new_list.append(tree.relpath(filename))

 

 

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

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

    """

    

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

    

    takes_args = ['file*']

    aliases = ['st', 'stat']

    

    @display_command

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

            

        from bzrlib.status import show_status

                    specific_files=file_list, revision=revision)

 

 

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

        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.

 

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

    @display_command

 

 

class cmd_revision_info(Command):

        if len(revs) == 0:

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

 

 

        for rev in revs:

            revinfo = rev.in_history(b)

    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.

    """

    takes_args = ['file*']

        else:

 

 

class cmd_mkdir(Command):

    takes_args = ['dir+']

 

    def run(self, dir_list):

        for d in dir_list:

            os.mkdir(d)

            print 'added', d

 

 

    

    @display_command

    def run(self, filename):

        print relpath

 

 

class cmd_inventory(Command):

    

    @display_command

        if revision is None:

        else:

            if len(revision) > 1:

                raise BzrCommandError('bzr inventory --revision takes'

                    ' exactly one revision identifier')

 

        for path, entry in inv.entries():

            if show_ids:

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

            else:

    """

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

    def run(self, source_list, dest):

        # TODO: glob expansion on windows?

 

 

class cmd_rename(Command):

    takes_args = ['from_name', 'to_name']

    

    def run(self, from_name, to_name):

 

 

class cmd_mv(Command):

    def run(self, names_list):

        if len(names_list) < 2:

            raise BzrCommandError("missing file argument")

        

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

            # move into existing directory

                print "%s => %s" % pair

        else:

            if len(names_list) != 2:

                raise BzrCommandError('to mv multiple files the destination '

                                      'must be a versioned directory')

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

            

    

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

    match the remote one, use --overwrite.

    """

    takes_args = ['location?']

 

        from bzrlib.merge import merge

        from shutil import rmtree

        import errno

        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

        if br_to.get_parent() is None or remember:

            br_to.set_parent(location)

 

 

class cmd_push(Command):

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

    before doing a 'push --overwrite'.

    """

    takes_args = ['location?']

 

        import errno

        from shutil import rmtree

        from bzrlib.transport import get_transport

        

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

            br_to = Branch.initialize(location)

        try:

        except DivergedBranches:

            raise BzrCommandError("These branches have diverged."

                                  "  Try a merge then push with overwrite.")

 

 

class cmd_branch(Command):

        br_from.lock_read()

        try:

            if basis is not None:

            else:

                basis_branch = None

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

                rmtree(to_location)

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

                raise BzrCommandError(msg)

            if name:

                name = StringIO(name)

                branch.put_controlfile('branch-name', name)

        finally:

            br_from.unlock()

 

    takes_args = ['dir?']

 

    @display_command

 

        renames = list(bzrlib.tree.find_renames(old_inv, new_inv))

        renames.sort()

    @display_command

    def run(self, branch=None):

        import info

        info.show_info(b)

 

 

    aliases = ['rm']

    

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

        tree.remove(file_list, verbose=verbose)

 

 

    takes_args = ['filename']

    @display_command

    def run(self, filename):

        if i == None:

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

        else:

    takes_args = ['filename']

    @display_command

    def run(self, filename):

        fid = inv.path2id(relpath)

        if fid == None:

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

    hidden = True

    @display_command

    def run(self):

            print patchid

 

 

    hidden = True

    @display_command

    def run(self):

        for revision_id in b.get_ancestry(b.last_revision()):

            print revision_id

 

 

class cmd_init(Command):

    """Make a directory into a versioned branch.

 

        bzr status

        bzr commit -m 'imported project'

    """

 

 

class cmd_diff(Command):

    @display_command

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

        from bzrlib.diff import show_diff

        if revision is not None:

            if len(revision) == 1:

                                 external_diff_options=diff_options)

            elif len(revision) == 2:

                                 external_diff_options=diff_options,

                                 revision2=revision[1])

            else:

                raise BzrCommandError('bzr diff --revision takes exactly one or two revision identifiers')

        else:

 

 

class cmd_deleted(Command):

    # if the directories are very large...)

    @display_command

    def run(self, show_ids=False):

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

                if show_ids:

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

                else:

    def run(self):

        from bzrlib.delta import compare_trees

 

 

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

            print path

    hidden = True

    @display_command

    def run(self):

        inv = wt.inventory

        for file_id in inv:

            if file_id in basis_inv:

    @display_command

    def run(self, filename=None):

        """Print the branch root."""

 

 

class cmd_log(Command):

    """Show log of this branch.

 

    also valid.

    """

 

                            help='show from oldest to newest'),

                     'timezone', 'verbose', 

                     'show-ids', 'revision',

                     Option('message',

                            help='show revisions whose message matches this regexp',

                            type=str),

                     ]

    @display_command

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

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

        

        if filename:

            if fp != '':

            else:

                file_id = None  # points to branch root

        else:

            file_id = None

 

        if revision is None:

        else:

            raise BzrCommandError('bzr log --revision takes one or two values.')

 

 

 

        # use 'replace' so that we don't abort if trying to write out

        # in e.g. the default C locale.

        outf = codecs.getwriter(bzrlib.user_encoding)(sys.stdout, errors='replace')

 

        lf = log_formatter(log_format,

                           show_ids=show_ids,

                           to_file=outf,

                 end_revision=rev2,

                 search=message)

 

 

 

class cmd_touching_revisions(Command):

    takes_args = ["filename"]

    @display_command

    def run(self, filename):

        file_id = inv.path2id(relpath)

        for revno, revision_id, what in bzrlib.log.find_touching_revisions(b, file_id):

            print "%6d %s" % (revno, what)

 

        selection = {'I':ignored, '?':unknown, 'V':versioned}

 

        if from_root:

        elif relpath:

            relpath += '/'

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

            if fp.startswith(relpath):

                fp = fp[len(relpath):]

                    print fp

 

 

class cmd_unknowns(Command):

    """List unknown files."""

    @display_command

    def run(self):

        from bzrlib.osutils import quotefn

            print quotefn(f)

 

 

class cmd_ignore(Command):

    """Ignore a command or pattern.

 

        from bzrlib.atomicfile import AtomicFile

        import os.path

 

 

        if os.path.exists(ifn):

            f = open(ifn, 'rt')

        finally:

            f.close()

 

        if inv.path2id('.bzrignore'):

            mutter('.bzrignore is already versioned')

        else:

            mutter('need to make new .bzrignore file versioned')

 

 

class cmd_ignored(Command):

    See also: bzr ignore"""

    @display_command

    def run(self):

        for path, file_class, kind, file_id, entry in tree.list_files():

            if file_class != 'I':

                continue

        except ValueError:

            raise BzrCommandError("not a valid revision-number: %r" % revno)

 

 

 

class cmd_export(Command):

    is found exports to a directory (equivalent to --format=dir).

 

    Root may be the top directory for tar, tgz and tbz2 formats. If none

    takes_args = ['dest']

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

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

        import os.path

        if revision is None:

            rev_id = b.last_revision()

        else:

            if len(revision) != 1:

                raise BzrError('bzr export --revision takes exactly 1 argument')

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

        t = b.revision_tree(rev_id)

 

 

class cmd_cat(Command):

 

    @display_command

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

            raise BzrCommandError("bzr cat --revision takes exactly one number")

 

 

class cmd_local_time_offset(Command):

            unchanged=False, strict=False):

        from bzrlib.errors import (PointlessCommit, ConflictsInTree,

                StrictCommitFailed)

        from bzrlib.status import show_status

        if message is None and not file:

            if message is None:

                raise BzrCommandError("please specify a commit message"

                                      " with either --message or --file")

                raise BzrCommandError("empty commit message specified")

            

        try:

        except PointlessCommit:

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

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

        except StrictCommitFailed:

            raise BzrCommandError("Commit refused because there are unknown "

                                  "files in the working tree.")

 

 

class cmd_check(Command):

    This command checks various invariants about the branch storage to

    detect data corruption or bzr bugs.

    """

    takes_options = ['verbose']

 

        from bzrlib.check import check

 

 

class cmd_scan_cache(Command):

    def run(self):

        from bzrlib.hashcache import HashCache

 

        c.read()

        c.scan()

            

    """

    takes_args = ['dir?']

 

        from bzrlib.upgrade import upgrade

        upgrade(dir)

 

    @display_command

    def run(self, email=False):

        try:

            config = bzrlib.config.BranchConfig(b)

        except NotBranchError:

            config = bzrlib.config.GlobalConfig()

        else:

            print config.username()

 

 

class cmd_selftest(Command):

    """Run internal test suite.

    This creates temporary test directories in the working directory,

    but not existing data is affected.  These directories are deleted

    if the tests pass, or left behind to help in debugging if they

    

    If arguments are given, they are regular expressions that say

    which tests should run.

    takes_args = ['testspecs*']

    takes_options = ['verbose', 

                     Option('one', help='stop when one test fails'),

                    ]

 

        import bzrlib.ui

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

                pattern = ".*"

            result = selftest(verbose=verbose, 

                              pattern=pattern,

            if result:

                bzrlib.trace.info('tests passed')

            else:

            bzrlib.ui.ui_factory = save_ui

 

 

def show_version():

    print "bzr (bazaar-ng) %s" % bzrlib.__version__

    # is bzrlib itself in a branch?

    print bzrlib.__copyright__

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

    print

        if merge_type is None:

            merge_type = ApplyMerge3

        if branch is None:

            if branch is None:

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

            else:

            log_error(m)

 

 

class cmd_revert(Command):

    """Reverse all changes since the last commit.

 

    aliases = ['merge-revert']

 

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

        from bzrlib.commands import parse_spec

        if file_list is not None:

            if len(file_list) == 0:

                raise BzrCommandError("No files specified")

        if revision is None:

            revno = -1

        elif len(revision) != 1:

            raise BzrCommandError('bzr revert --revision takes exactly 1 argument')

        else:

 

 

class cmd_assert_fail(Command):

 

 

class cmd_missing(Command):

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

 

 

class cmd_plugins(Command):

    def run(self):

        import bzrlib.plugin

        from inspect import getdoc

            if hasattr(plugin, '__path__'):

                print plugin.__path__[0]

            elif hasattr(plugin, '__file__'):

    takes_options = ['revision', 'long']

    takes_args = ['branch?']

    @display_command

        from bzrlib.testament import Testament

        b.lock_read()

        try:

            if revision is None:

    @display_command

    def run(self, filename, all=False, long=False):

        from bzrlib.annotate import annotate_file

        try:

            file_id = tree.inventory.path2id(relpath)

            file_version = tree.inventory[file_id].revision

        finally:

 

 

class cmd_re_sign(Command):

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

        gpg_strategy = gpg.GPGStrategy(config.BranchConfig(b))

        if revision_id is not None:

            b.sign_revision(revision_id, gpg_strategy)

                raise BzrCommandError('Please supply either one revision, or a range.')