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

from node import hex, nullid, nullrev, short

from i18n import _

import os, sys, bisect, stat

import mdiff, bdiff, util, templater, templatefilters, patch, errno, error

import match as _match

revrangesep = ':'

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 = e.lstrip("^").split("|")

        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 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 = sys.maxint

    return limit

def setremoteconfig(ui, opts):

    "copy remote options to ui tree"

    if opts.get('ssh'):

        ui.setconfig("ui", "ssh", opts['ssh'])

    if opts.get('remotecmd'):

        ui.setconfig("ui", "remotecmd", opts['remotecmd'])

def revpair(repo, revs):

    '''return pair of nodes, given list of revisions. second item can

    be None, meaning use working dir.'''

    def revfix(repo, val, defval):

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

            val = defval

        return repo.lookup(val)

    if not revs:

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

    end = None

    if len(revs) == 1:

        if revrangesep in revs[0]:

            start, end = revs[0].split(revrangesep, 1)

            start = revfix(repo, start, 0)

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

        else:

            start = revfix(repo, revs[0], None)

    elif len(revs) == 2:

        if revrangesep in revs[0] or revrangesep in revs[1]:

            raise util.Abort(_('too many revisions specified'))

        start = revfix(repo, revs[0], None)

        end = revfix(repo, revs[1], None)

    else:

        raise util.Abort(_('too many revisions specified'))

    return start, end

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 = {}, []

    for spec in revs:

        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[rev] = 1

                l.append(rev)

        else:

            rev = revfix(repo, spec, None)

            if rev in seen:

                continue

            seen[rev] = 1

            l.append(rev)

    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 file name") %

                         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 match(repo, pats=[], opts={}, globbed=False, default='relpath'):

    if not globbed and default == 'relpath':

        pats = util.expand_glob(pats or [])

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

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

    def badfn(f, msg):

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

        return False

    m.bad = badfn

    return m

def matchall(repo):

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

def matchfiles(repo, files):

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

def findrenames(repo, added=None, removed=None, threshold=0.5):

    '''find renamed files -- yields (before, after, score) tuples'''

    if added is None or removed is None:

        added, removed = repo.status()[1:3]

    ctx = repo['.']

    for a in added:

        aa = repo.wread(a)

        bestname, bestscore = None, threshold

        for r in removed:

            rr = ctx.filectx(r).data()

            # bdiff.blocks() returns blocks of matching lines

            # count the number of bytes in each

            equal = 0

            alines = mdiff.splitnewlines(aa)

            matches = bdiff.blocks(aa, rr)

            for x1,x2,y1,y2 in matches:

                for line in alines[x1:x2]:

                    equal += len(line)

            lengths = len(aa) + len(rr)

            if lengths:

                myscore = equal*2.0 / lengths

                if myscore >= bestscore:

                    bestname, bestscore = r, myscore

        if bestname:

            yield bestname, a, bestscore

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)

    add, remove = [], []

    mapping = {}

    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:

            add.append(abs)

            mapping[abs] = rel, m.exact(abs)

            if repo.ui.verbose or not exact:

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

        if repo.dirstate[abs] != 'r' and (not good or not util.lexists(target)

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

            remove.append(abs)

            mapping[abs] = rel, exact

            if repo.ui.verbose or not exact:

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

    if not dry_run:

        repo.remove(remove)

        repo.add(add)

    if similarity > 0:

        for old, new, score in findrenames(repo, add, remove, similarity):

            oldrel, oldexact = mapping[old]

            newrel, newexact = mapping[new]

            if repo.ui.verbose or not oldexact or not newexact:

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

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

                               (oldrel, newrel, score * 100))

            if not dry_run:

                repo.copy(old, new)

def copy(ui, repo, pats, opts, rename=False):

    # called with the repo lock held

    #

    # hgsep => pathname that uses "/" to separate directories

    # ossep => pathname that uses os.sep to separate directories

    cwd = repo.getcwd()

    targets = {}

    after = opts.get("after")

    dryrun = opts.get("dry_run")

    def walkpat(pat):

        srcs = []

        m = match(repo, [pat], opts, globbed=True)

        for abs in repo.walk(m):

            state = repo.dirstate[abs]

            rel = m.rel(abs)

            exact = m.exact(abs)

            if state in '?r':

                if exact and state == '?':

                    ui.warn(_('%s: not copying - file is not managed\n') % rel)

                if exact and state == 'r':

                    ui.warn(_('%s: not copying - file has been marked for'

                              ' remove\n') % rel)

                continue

            # abs: hgsep

            # rel: ossep

            srcs.append((abs, rel, exact))

        return srcs

    # abssrc: hgsep

    # relsrc: ossep

    # otarget: ossep

    def copyfile(abssrc, relsrc, otarget, exact):

        abstarget = util.canonpath(repo.root, cwd, otarget)

        reltarget = repo.pathto(abstarget, cwd)

        target = repo.wjoin(abstarget)

        src = repo.wjoin(abssrc)

        state = repo.dirstate[abstarget]