# cmdutil.py - help for command processing in 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 i18n import _

import os, sys, errno, re, glob, tempfile

import util, templater, patch, error, encoding, templatekw

import match as matchmod

import similar, revset, subrepo

revrangesep = ':'

def parsealiases(cmd):

    return cmd.lstrip("^").split("|")

def findpossible(cmd, table, strict=False):

    """

    Return cmd -> (aliases, command table entry)

    for each matching command.

    Return debug commands (or their aliases) only if no normal command matches.

    """

    choice = {}

    debugchoice = {}

    for e in table.keys():

        aliases = parsealiases(e)

        found = None

        if cmd in aliases:

            found = cmd

        elif not strict:

            for a in aliases:

                if a.startswith(cmd):

                    found = a

                    break

        if found is not None:

            if aliases[0].startswith("debug") or found.startswith("debug"):

                debugchoice[found] = (aliases, table[e])

            else:

                choice[found] = (aliases, table[e])

    if not choice and debugchoice:

        choice = debugchoice

    return choice

def findcmd(cmd, table, strict=True):

    """Return (aliases, command table entry) for command string."""

    choice = findpossible(cmd, table, strict)

    if cmd in choice:

        return choice[cmd]

    if len(choice) > 1:

        clist = choice.keys()

        clist.sort()

        raise error.AmbiguousCommand(cmd, clist)

    if choice:

        return choice.values()[0]

    raise error.UnknownCommand(cmd)

def findrepo(p):

    while not os.path.isdir(os.path.join(p, ".hg")):

        oldp, p = p, os.path.dirname(p)

        if p == oldp:

            return None

    return p

def bail_if_changed(repo):

    if repo.dirstate.parents()[1] != nullid:

        raise util.Abort(_('outstanding uncommitted merge'))

    modified, added, removed, deleted = repo.status()[:4]

    if modified or added or removed or deleted:

        raise util.Abort(_("outstanding uncommitted changes"))

def logmessage(opts):

    """ get the log message according to -m and -l option """

    message = opts.get('message')

    logfile = opts.get('logfile')

    if message and logfile:

        raise util.Abort(_('options --message and --logfile are mutually '

                           'exclusive'))

    if not message and logfile:

        try:

            if logfile == '-':

                message = sys.stdin.read()

            else:

                message = open(logfile).read()

        except IOError, inst:

            raise util.Abort(_("can't read commit message '%s': %s") %

                             (logfile, inst.strerror))

    return message

def loglimit(opts):

    """get the log limit according to option -l/--limit"""

    limit = opts.get('limit')

    if limit:

        try:

            limit = int(limit)

        except ValueError:

            raise util.Abort(_('limit must be a positive integer'))

        if limit <= 0:

            raise util.Abort(_('limit must be positive'))

    else:

        limit = None

    return limit

def revsingle(repo, revspec, default='.'):

    if not revspec:

        return repo[default]

    l = revrange(repo, [revspec])

    if len(l) < 1:

        raise util.Abort(_('empty revision set'))

    return repo[l[-1]]

def revpair(repo, revs):

    if not revs:

        return repo.dirstate.parents()[0], None

    l = revrange(repo, revs)

    if len(l) == 0:

        return repo.dirstate.parents()[0], None

    if len(l) == 1:

        return repo.lookup(l[0]), None

    return repo.lookup(l[0]), repo.lookup(l[-1])

def revrange(repo, revs):

    """Yield revision as strings from a list of revision specifications."""

    def revfix(repo, val, defval):

        if not val and val != 0 and defval is not None:

            return defval

        return repo.changelog.rev(repo.lookup(val))

    seen, l = set(), []

    for spec in revs:

        # attempt to parse old-style ranges first to deal with

        # things like old-tag which contain query metacharacters

        try:

            if revrangesep in spec:

                start, end = spec.split(revrangesep, 1)

                start = revfix(repo, start, 0)

                end = revfix(repo, end, len(repo) - 1)

                step = start > end and -1 or 1

                for rev in xrange(start, end + step, step):

                    if rev in seen:

                        continue

                    seen.add(rev)

                    l.append(rev)

                continue

            elif spec and spec in repo: # single unquoted rev

                rev = revfix(repo, spec, None)

                if rev in seen:

                    continue

                seen.add(rev)

                l.append(rev)

                continue

        except error.RepoLookupError:

            pass

        # fall through to new-style queries if old-style fails

        m = revset.match(spec)

        for r in m(repo, range(len(repo))):

            if r not in seen:

                l.append(r)

        seen.update(l)

    return l

def make_filename(repo, pat, node,

                  total=None, seqno=None, revwidth=None, pathname=None):

    node_expander = {

        'H': lambda: hex(node),

        'R': lambda: str(repo.changelog.rev(node)),

        'h': lambda: short(node),

        }

    expander = {

        '%': lambda: '%',

        'b': lambda: os.path.basename(repo.root),

        }

    try:

        if node:

            expander.update(node_expander)

        if node:

            expander['r'] = (lambda:

                    str(repo.changelog.rev(node)).zfill(revwidth or 0))

        if total is not None:

            expander['N'] = lambda: str(total)

        if seqno is not None:

            expander['n'] = lambda: str(seqno)

        if total is not None and seqno is not None:

            expander['n'] = lambda: str(seqno).zfill(len(str(total)))

        if pathname is not None:

            expander['s'] = lambda: os.path.basename(pathname)

            expander['d'] = lambda: os.path.dirname(pathname) or '.'

            expander['p'] = lambda: pathname

        newname = []

        patlen = len(pat)

        i = 0

        while i < patlen:

            c = pat[i]

            if c == '%':

                i += 1

                c = pat[i]

                c = expander[c]()

            newname.append(c)

            i += 1

        return ''.join(newname)

    except KeyError, inst:

        raise util.Abort(_("invalid format spec '%%%s' in output filename") %

                         inst.args[0])

def make_file(repo, pat, node=None,

              total=None, seqno=None, revwidth=None, mode='wb', pathname=None):

    writable = 'w' in mode or 'a' in mode

    if not pat or pat == '-':

        return writable and sys.stdout or sys.stdin

    if hasattr(pat, 'write') and writable:

        return pat

    if hasattr(pat, 'read') and 'r' in mode:

        return pat

    return open(make_filename(repo, pat, node, total, seqno, revwidth,

                              pathname),

                mode)

def expandpats(pats):

    if not util.expandglobs:

        return list(pats)

    ret = []

    for p in pats:

        kind, name = matchmod._patsplit(p, None)

        if kind is None:

            try:

                globbed = glob.glob(name)

            except re.error:

                globbed = [name]

            if globbed:

                ret.extend(globbed)

                continue

        ret.append(p)

    return ret

def match(repo, pats=[], opts={}, globbed=False, default='relpath'):

    if not globbed and default == 'relpath':

        pats = expandpats(pats or [])

    m = matchmod.match(repo.root, repo.getcwd(), pats,

                       opts.get('include'), opts.get('exclude'), default,

                       auditor=repo.auditor)

    def badfn(f, msg):

        repo.ui.warn("%s: %s\n" % (m.rel(f), msg))

    m.bad = badfn

    return m

def matchall(repo):

    return matchmod.always(repo.root, repo.getcwd())

def matchfiles(repo, files):

    return matchmod.exact(repo.root, repo.getcwd(), files)

def addremove(repo, pats=[], opts={}, dry_run=None, similarity=None):

    if dry_run is None:

        dry_run = opts.get('dry_run')

    if similarity is None:

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

    # we'd use status here, except handling of symlinks and ignore is tricky

    added, unknown, deleted, removed = [], [], [], []

    audit_path = util.path_auditor(repo.root)

    m = match(repo, pats, opts)

    for abs in repo.walk(m):

        target = repo.wjoin(abs)

        good = True

        try:

            audit_path(abs)

        except:

            good = False

        rel = m.rel(abs)

        exact = m.exact(abs)

        if good and abs not in repo.dirstate:

            unknown.append(abs)

            if repo.ui.verbose or not exact:

                repo.ui.status(_('adding %s\n') % ((pats and rel) or abs))

        elif repo.dirstate[abs] != 'r' and (not good or not os.path.lexists(target)

            or (os.path.isdir(target) and not os.path.islink(target))):

            deleted.append(abs)

            if repo.ui.verbose or not exact:

                repo.ui.status(_('removing %s\n') % ((pats and rel) or abs))

        # for finding renames

        elif repo.dirstate[abs] == 'r':

            removed.append(abs)

        elif repo.dirstate[abs] == 'a':

            added.append(abs)

    copies = {}

    if similarity > 0:

        for old, new, score in similar.findrenames(repo,

                added + unknown, removed + deleted, similarity):

            if repo.ui.verbose or not m.exact(old) or not m.exact(new):

                repo.ui.status(_('recording removal of %s as rename to %s '

                                 '(%d%% similar)\n') %

                               (m.rel(old), m.rel(new), score * 100))

            copies[new] = old

    if not dry_run:

        wctx = repo[None]

        wlock = repo.wlock()

        try:

            wctx.remove(deleted)

            wctx.add(unknown)

            for new, old in copies.iteritems():

                wctx.copy(old, new)

        finally:

            wlock.release()

def updatedir(ui, repo, patches, similarity=0):

    '''Update dirstate after patch application according to metadata'''

    if not patches:

        return

    copies = []

    removes = set()

    cfiles = patches.keys()

    cwd = repo.getcwd()

    if cwd:

        cfiles = [util.pathto(repo.root, cwd, f) for f in patches.keys()]

    for f in patches:

        gp = patches[f]

        if not gp:

            continue

        if gp.op == 'RENAME':

            copies.append((gp.oldpath, gp.path))

            removes.add(gp.oldpath)

        elif gp.op == 'COPY':

            copies.append((gp.oldpath, gp.path))

        elif gp.op == 'DELETE':

            removes.add(gp.path)

    wctx = repo[None]

    for src, dst in copies:

        dirstatecopy(ui, repo, wctx, src, dst, cwd=cwd)

    if (not similarity) and removes:

        wctx.remove(sorted(removes), True)