# commands.py - command processing for mercurial

#

# Copyright 2005-2007 Matt Mackall <mpm@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from node import hex, nullid, nullrev, short

from lock import release

from i18n import _, gettext

import os, re, sys, difflib, time, tempfile

import hg, util, revlog, extensions, copies, error

import patch, help, mdiff, url, encoding, templatekw, discovery

import archival, changegroup, cmdutil, sshserver, hbisect, hgweb, hgweb.server

import merge as mergemod

import minirst, revset

import dagparser

# Commands start here, listed alphabetically

def add(ui, repo, *pats, **opts):

    """add the specified files on the next commit

    Schedule files to be version controlled and added to the

    repository.

    The files will be added to the repository at the next commit. To

    undo an add before that, see :hg:`forget`.

    If no names are given, add all files to the repository.

    .. container:: verbose

       An example showing how new (unknown) files are added

       automatically by :hg:`add`::

         $ ls

         foo.c

         $ hg status

         ? foo.c

         $ hg add

         adding foo.c

         $ hg status

         A foo.c

    Returns 0 if all files are successfully added.

    """

    m = cmdutil.match(repo, pats, opts)

    rejected = cmdutil.add(ui, repo, m, opts.get('dry_run'),

                           opts.get('subrepos'), prefix="")

    return rejected and 1 or 0

def addremove(ui, repo, *pats, **opts):

    """add all new files, delete all missing files

    Add all new files and remove all missing files from the

    repository.

    New files are ignored if they match any of the patterns in

    .hgignore. As with add, these changes take effect at the next

    commit.

    Use the -s/--similarity option to detect renamed files. With a

    parameter greater than 0, this compares every removed file with

    every added file and records those similar enough as renames. This

    option takes a percentage between 0 (disabled) and 100 (files must

    be identical) as its parameter. Detecting renamed files this way

    can be expensive. After using this option, :hg:`status -C` can be

    used to check which files were identified as moved or renamed.

    Returns 0 if all files are successfully added.

    """

    try:

        sim = float(opts.get('similarity') or 100)

    except ValueError:

        raise util.Abort(_('similarity must be a number'))

    if sim < 0 or sim > 100:

        raise util.Abort(_('similarity must be between 0 and 100'))

    return cmdutil.addremove(repo, pats, opts, similarity=sim / 100.0)

def annotate(ui, repo, *pats, **opts):

    """show changeset information by line for each file

    List changes in files, showing the revision id responsible for

    each line

    This command is useful for discovering when a change was made and

    by whom.

    Without the -a/--text option, annotate will avoid processing files

    it detects as binary. With -a, annotate will annotate the file

    anyway, although the results will probably be neither useful

    nor desirable.

    Returns 0 on success.

    """

    if opts.get('follow'):

        # --follow is deprecated and now just an alias for -f/--file

        # to mimic the behavior of Mercurial before version 1.5

        opts['file'] = 1

    datefunc = ui.quiet and util.shortdate or util.datestr

    getdate = util.cachefunc(lambda x: datefunc(x[0].date()))

    if not pats:

        raise util.Abort(_('at least one filename or pattern is required'))

    opmap = [('user', lambda x: ui.shortuser(x[0].user())),

             ('number', lambda x: str(x[0].rev())),

             ('changeset', lambda x: short(x[0].node())),

             ('date', getdate),

             ('file', lambda x: x[0].path()),

            ]

    if (not opts.get('user') and not opts.get('changeset')

        and not opts.get('date') and not opts.get('file')):

        opts['number'] = 1

    linenumber = opts.get('line_number') is not None

    if linenumber and (not opts.get('changeset')) and (not opts.get('number')):

        raise util.Abort(_('at least one of -n/-c is required for -l'))

    funcmap = [func for op, func in opmap if opts.get(op)]

    if linenumber:

        lastfunc = funcmap[-1]

        funcmap[-1] = lambda x: "%s:%s" % (lastfunc(x), x[1])

    ctx = repo[opts.get('rev')]

    m = cmdutil.match(repo, pats, opts)

    follow = not opts.get('no_follow')

    for abs in ctx.walk(m):

        fctx = ctx[abs]

        if not opts.get('text') and util.binary(fctx.data()):

            ui.write(_("%s: binary file\n") % ((pats and m.rel(abs)) or abs))

            continue

        lines = fctx.annotate(follow=follow, linenumber=linenumber)

        pieces = []

        for f in funcmap:

            l = [f(n) for n, dummy in lines]

            if l:

                sized = [(x, encoding.colwidth(x)) for x in l]

                ml = max([w for x, w in sized])

                pieces.append(["%s%s" % (' ' * (ml - w), x) for x, w in sized])

        if pieces:

            for p, l in zip(zip(*pieces), lines):

                ui.write("%s: %s" % (" ".join(p), l[1]))

def archive(ui, repo, dest, **opts):

    '''create an unversioned archive of a repository revision

    By default, the revision used is the parent of the working

    directory; use -r/--rev to specify a different revision.

    The archive type is automatically detected based on file

    extension (or override using -t/--type).

    Valid types are:

    :``files``: a directory full of files (default)

    :``tar``:   tar archive, uncompressed

    :``tbz2``:  tar archive, compressed using bzip2

    :``tgz``:   tar archive, compressed using gzip

    :``uzip``:  zip archive, uncompressed

    :``zip``:   zip archive, compressed using deflate

    The exact name of the destination archive or directory is given

    using a format string; see :hg:`help export` for details.

    Each member added to an archive file has a directory prefix

    prepended. Use -p/--prefix to specify a format string for the

    prefix. The default is the basename of the archive, with suffixes

    removed.

    Returns 0 on success.

    '''

    ctx = repo[opts.get('rev')]

    if not ctx:

        raise util.Abort(_('no working directory: please specify a revision'))

    node = ctx.node()

    dest = cmdutil.make_filename(repo, dest, node)

    if os.path.realpath(dest) == repo.root:

        raise util.Abort(_('repository root cannot be destination'))

    kind = opts.get('type') or archival.guesskind(dest) or 'files'

    prefix = opts.get('prefix')

    if dest == '-':

        if kind == 'files':

            raise util.Abort(_('cannot archive plain files to stdout'))

        dest = sys.stdout

        if not prefix:

            prefix = os.path.basename(repo.root) + '-%h'

    prefix = cmdutil.make_filename(repo, prefix, node)

    matchfn = cmdutil.match(repo, [], opts)

    archival.archive(repo, dest, node, kind, not opts.get('no_decode'),

                     matchfn, prefix, subrepos=opts.get('subrepos'))

def backout(ui, repo, node=None, rev=None, **opts):

    '''reverse effect of earlier changeset

    The backout command merges the reverse effect of the reverted

    changeset into the working directory.

    With the --merge option, it first commits the reverted changes

    as a new changeset. This new changeset is a child of the reverted

    changeset.

    The --merge option remembers the parent of the working directory

    before starting the backout, then merges the new head with that

    changeset afterwards.

    This will result in an explicit merge in the history.

    If you backout a changeset other than the original parent of the

    working directory, the result of this merge is not committed,

    as with a normal merge. Otherwise, no merge is needed and the

    commit is automatic.

    Note that the default behavior (without --merge) has changed in

    version 1.7. To restore the previous default behavior, use

    :hg:`backout --merge` and then :hg:`update --clean .` to get rid of

    the ongoing merge.

    See :hg:`help dates` for a list of formats valid for -d/--date.

    Returns 0 on success.

    '''

    if rev and node:

        raise util.Abort(_("please specify just one revision"))

    if not rev:

        rev = node

    if not rev:

        raise util.Abort(_("please specify a revision to backout"))

    date = opts.get('date')

    if date:

        opts['date'] = util.parsedate(date)

    cmdutil.bail_if_changed(repo)

    node = repo.lookup(rev)

    op1, op2 = repo.dirstate.parents()

    a = repo.changelog.ancestor(op1, node)

    if a != node:

        raise util.Abort(_('cannot backout change on a different branch'))

    p1, p2 = repo.changelog.parents(node)

    if p1 == nullid:

        raise util.Abort(_('cannot backout a change with no parents'))

    if p2 != nullid:

        if not opts.get('parent'):

            raise util.Abort(_('cannot backout a merge changeset without '

                               '--parent'))

        p = repo.lookup(opts['parent'])

        if p not in (p1, p2):

            raise util.Abort(_('%s is not a parent of %s') %

                             (short(p), short(node)))

        parent = p

    else:

        if opts.get('parent'):

            raise util.Abort(_('cannot use --parent on non-merge changeset'))

        parent = p1

    # the backout should appear on the same branch

    branch = repo.dirstate.branch()

    hg.clean(repo, node, show_stats=False)

    repo.dirstate.setbranch(branch)

    revert_opts = opts.copy()

    revert_opts['date'] = None

    revert_opts['all'] = True

    revert_opts['rev'] = hex(parent)

    revert_opts['no_backup'] = None

    revert(ui, repo, **revert_opts)

    if not opts.get('merge') and op1 != node:

        try:

            ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))

            return hg.update(repo, op1)

        finally:

            ui.setconfig('ui', 'forcemerge', '')

    commit_opts = opts.copy()

    commit_opts['addremove'] = False

    if not commit_opts['message'] and not commit_opts['logfile']:

        # we don't translate commit messages

        commit_opts['message'] = "Backed out changeset %s" % short(node)

        commit_opts['force_editor'] = True

    commit(ui, repo, **commit_opts)

    def nice(node):

        return '%d:%s' % (repo.changelog.rev(node), short(node))

    ui.status(_('changeset %s backs out changeset %s\n') %

              (nice(repo.changelog.tip()), nice(node)))

    if opts.get('merge') and op1 != node:

        hg.clean(repo, op1, show_stats=False)

        ui.status(_('merging with changeset %s\n')

                  % nice(repo.changelog.tip()))

        try:

            ui.setconfig('ui', 'forcemerge', opts.get('tool', ''))

            return hg.merge(repo, hex(repo.changelog.tip()))

        finally:

            ui.setconfig('ui', 'forcemerge', '')

    return 0

def bisect(ui, repo, rev=None, extra=None, command=None,

               reset=None, good=None, bad=None, skip=None, noupdate=None):

    """subdivision search of changesets

    This command helps to find changesets which introduce problems. To

    use, mark the earliest changeset you know exhibits the problem as

    bad, then mark the latest changeset which is free from the problem

    as good. Bisect will update your working directory to a revision

    for testing (unless the -U/--noupdate option is specified). Once

    you have performed tests, mark the working directory as good or

    bad, and bisect will either update to another candidate changeset

    or announce that it has found the bad revision.

    As a shortcut, you can also use the revision argument to mark a

    revision as good or bad without checking it out first.

    If you supply a command, it will be used for automatic bisection.

    Its exit status will be used to mark revisions as good or bad:

    status 0 means good, 125 means to skip the revision, 127

    (command not found) will abort the bisection, and any other

    non-zero exit status means the revision is bad.

    Returns 0 on success.

    """

    def print_result(nodes, good):

        displayer = cmdutil.show_changeset(ui, repo, {})

        if len(nodes) == 1:

            # narrowed it down to a single revision

            if good:

                ui.write(_("The first good revision is:\n"))

            else:

                ui.write(_("The first bad revision is:\n"))

            displayer.show(repo[nodes[0]])

            parents = repo[nodes[0]].parents()

            if len(parents) > 1:

                side = good and state['bad'] or state['good']

                num = len(set(i.node() for i in parents) & set(side))

                if num == 1:

                    common = parents[0].ancestor(parents[1])

                    ui.write(_('Not all ancestors of this changeset have been'

                               ' checked.\nTo check the other ancestors, start'

                               ' from the common ancestor, %s.\n' % common))

        else:

            # multiple possible revisions

            if good:

                ui.write(_("Due to skipped revisions, the first "

                        "good revision could be any of:\n"))

            else:

                ui.write(_("Due to skipped revisions, the first "

                        "bad revision could be any of:\n"))

            for n in nodes:

                displayer.show(repo[n])

        displayer.close()

    def check_state(state, interactive=True):

        if not state['good'] or not state['bad']:

            if (good or bad or skip or reset) and interactive:

                return

            if not state['good']:

                raise util.Abort(_('cannot bisect (no known good revisions)'))

            else:

                raise util.Abort(_('cannot bisect (no known bad revisions)'))

        return True

    # backward compatibility

    if rev in "good bad reset init".split():

        ui.warn(_("(use of 'hg bisect <cmd>' is deprecated)\n"))

        cmd, rev, extra = rev, extra, None

        if cmd == "good":

            good = True

        elif cmd == "bad":

            bad = True

        else:

            reset = True

    elif extra or good + bad + skip + reset + bool(command) > 1:

        raise util.Abort(_('incompatible arguments'))

    if reset:

        p = repo.join("bisect.state")

        if os.path.exists(p):

            os.unlink(p)

        return

    state = hbisect.load_state(repo)

    if command:

        changesets = 1

        try:

            while changesets:

                # update state

                status = util.system(command)

                if status == 125:

                    transition = "skip"

                elif status == 0:

                    transition = "good"

                # status < 0 means process was killed

                elif status == 127:

                    raise util.Abort(_("failed to execute %s") % command)

                elif status < 0:

                    raise util.Abort(_("%s killed") % command)

                else:

                    transition = "bad"

                ctx = repo[rev or '.']

                state[transition].append(ctx.node())

                ui.status(_('Changeset %d:%s: %s\n') % (ctx, ctx, transition))

                check_state(state, interactive=False)

                # bisect

                nodes, changesets, good = hbisect.bisect(repo.changelog, state)

                # update to next check

                cmdutil.bail_if_changed(repo)

                hg.clean(repo, nodes[0], show_stats=False)

        finally:

            hbisect.save_state(repo, state)

        print_result(nodes, good)

        return

    # update state

    if rev:

        nodes = [repo.lookup(i) for i in cmdutil.revrange(repo, [rev])]

    else:

        nodes = [repo.lookup('.')]

    if good or bad or skip:

        if good:

            state['good'] += nodes

        elif bad:

            state['bad'] += nodes

        elif skip:

            state['skip'] += nodes

        hbisect.save_state(repo, state)

    if not check_state(state):

        return

    # actually bisect

    nodes, changesets, good = hbisect.bisect(repo.changelog, state)

    if changesets == 0:

        print_result(nodes, good)

    else:

        assert len(nodes) == 1 # only a single node can be tested next

        node = nodes[0]

        # compute the approximate number of remaining tests

        tests, size = 0, 2

        while size <= changesets:

            tests, size = tests + 1, size * 2

        rev = repo.changelog.rev(node)

        ui.write(_("Testing changeset %d:%s "

                   "(%d changesets remaining, ~%d tests)\n")

                 % (rev, short(node), changesets, tests))

        if not noupdate:

            cmdutil.bail_if_changed(repo)

            return hg.clean(repo, node)

def branch(ui, repo, label=None, **opts):

    """set or show the current branch name

    With no argument, show the current branch name. With one argument,

    set the working directory branch name (the branch will not exist

    in the repository until the next commit). Standard practice

    recommends that primary development take place on the 'default'

    branch.

    Unless -f/--force is specified, branch will not let you set a

    branch name that already exists, even if it's inactive.

    Use -C/--clean to reset the working directory branch to that of

    the parent of the working directory, negating a previous branch

    change.

    Use the command :hg:`update` to switch to an existing branch. Use

    :hg:`commit --close-branch` to mark this branch as closed.

    Returns 0 on success.

    """

    if opts.get('clean'):

        label = repo[None].parents()[0].branch()

        repo.dirstate.setbranch(label)

        ui.status(_('reset working directory to branch %s\n') % label)

    elif label:

        utflabel = encoding.fromlocal(label)

        if not opts.get('force') and utflabel in repo.branchtags():

            if label not in [p.branch() for p in repo.parents()]:

                raise util.Abort(_('a branch of the same name already exists'

                                   " (use 'hg update' to switch to it)"))

        repo.dirstate.setbranch(utflabel)

        ui.status(_('marked working directory as branch %s\n') % label)

    else:

        ui.write("%s\n" % encoding.tolocal(repo.dirstate.branch()))

def branches(ui, repo, active=False, closed=False):

    """list repository named branches

    List the repository's named branches, indicating which ones are

    inactive. If -c/--closed is specified, also list branches which have

    been marked closed (see :hg:`commit --close-branch`).

    If -a/--active is specified, only show active branches. A branch

    is considered active if it contains repository heads.

    Use the command :hg:`update` to switch to an existing branch.

    Returns 0.

    """

    hexfunc = ui.debugflag and hex or short

    activebranches = [repo[n].branch() for n in repo.heads()]

    def testactive(tag, node):

        realhead = tag in activebranches

        open = node in repo.branchheads(tag, closed=False)

        return realhead and open

    branches = sorted([(testactive(tag, node), repo.changelog.rev(node), tag)

                          for tag, node in repo.branchtags().items()],

                      reverse=True)

    for isactive, node, tag in branches:

        if (not active) or isactive:

            encodedtag = encoding.tolocal(tag)

            if ui.quiet:

                ui.write("%s\n" % encodedtag)