# 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, incorporated herein by reference.

from node import hex, nullid, nullrev, short

from repo import RepoError, NoCapability

from i18n import _, gettext

import os, re, sys

import difflib, patch, time, help, mdiff, tempfile, url

import version

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

import merge as merge_

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

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

    """

    rejected = None

    exacts = {}

    names = []

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

    m.bad = lambda x,y: True

    for abs in repo.walk(m):

        if m.exact(abs):

            if ui.verbose:

                ui.status(_('adding %s\n') % m.rel(abs))

            names.append(abs)

            exacts[abs] = 1

        elif abs not in repo.dirstate:

            ui.status(_('adding %s\n') % m.rel(abs))

            names.append(abs)

    if not opts.get('dry_run'):

        rejected = repo.add(names)

        rejected = [p for p in rejected if p in exacts]

    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 option to detect renamed files. With a parameter > 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.

    """

    try:

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

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

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

    """show changeset information per file line

    List changes in files, showing the revision id responsible for each line

    This command is useful to discover who did a change or when a change took

    place.

    Without the -a option, annotate will avoid processing files it

    detects as binary. With -a, annotate will generate an annotation

    anyway, probably with undesirable results.

    """

    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 file name or pattern 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),

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

            ]

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

        and not opts.get('follow')):

        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)

    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=opts.get('follow'),

                              linenumber=linenumber)

        pieces = []

        for f in funcmap:

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

            if l:

                ml = max(map(len, l))

                pieces.append(["%*s" % (ml, x) for x in l])

        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 unversioned archive of a repository revision

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

    directory; use "-r" to specify a different revision.

    To specify the type of archive to create, use "-t". Valid

    types are:

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

    "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" to specify a format string for the prefix.

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

    '''

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

    if not ctx:

        raise util.Abort(_('repository has no revisions'))

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

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

    kind = opts.get('type') 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)

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

                     matchfn, prefix)

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

    '''reverse effect of earlier changeset

    Commit the backed out changes as a new changeset. The new

    changeset is a child of the backed out changeset.

    If you back out a changeset other than the tip, a new head is

    created. This head will be the new tip and you should merge this

    backout changeset with another head (current one by default).

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

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

    changeset afterwards. This saves you from doing the merge by

    hand. The result of this merge is not committed, as for a normal

    merge.

    See \'hg help dates\' for a list of formats valid for -d/--date.

    '''

    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 back out change on a different branch'))

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

    if p1 == nullid:

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

    if p2 != nullid:

        if not opts.get('parent'):

            raise util.Abort(_('cannot back out 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)

    commit_opts = opts.copy()

    commit_opts['addremove'] = False

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

        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 op1 != node:

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

        if opts.get('merge'):

            ui.status(_('merging with changeset %s\n') % nice(repo.changelog.tip()))

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

        else:

            ui.status(_('the backout changeset is a new head - '

                        'do not forget to merge\n'))

            ui.status(_('(use "backout --merge" '

                        'if you want to auto-merge)\n'))

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 --noupdate option is specified).

    Once you have performed tests, mark the working directory as bad

    or good 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 as flag to mark revision as bad or good. In case exit

    status is 0 the revision is marked as good, 125 - skipped, 127 (command not

    found) - bisection will be aborted and any other status bigger than 0 will

    mark revision as bad.

    """

    def print_result(nodes, good):

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

        transition = (good and "good" or "bad")

        if len(nodes) == 1:

            # narrowed it down to a single revision

            ui.write(_("The first %s revision is:\n") % transition)

        else:

            # multiple possible revisions

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

                       "%s revision could be any of:\n") % transition)

            for n in nodes:

    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

        while changesets:

            # update state

            status = os.spawnlp(os.P_WAIT, command)

            node = repo.lookup(rev or '.')

            if status == 125:

                transition = "skip"

            elif status == 0:

                transition = "good"

            # status < 0 means process was killed

            elif status == 127 or status < 0:

                break

            else:

                transition = "bad"

            state[transition].append(node)

            ui.note(_('Changeset %s: %s\n') % (short(node), 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)

        hbisect.save_state(repo, state)

        return print_result(nodes, not status)

    # update state

    node = repo.lookup(rev or '.')

    if good:

        state['good'].append(node)

    elif bad: