# 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, tempfile

import match as matchmod

import subrepo

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 bailifchanged(repo):

    if repo.dirstate.p2() != 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 = '\n'.join(util.readfile(logfile).splitlines())

        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 makefilename(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 makefileobj(repo, pat, node=None, total=None,

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

    writable = mode not in ('r', 'rb')

    if not pat or pat == '-':

        fp = writable and sys.stdout or sys.stdin

        return os.fdopen(os.dup(fp.fileno()), mode)

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

        return pat

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

        return pat

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

                              pathname),

                mode)

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

    wctx = repo[None]

    def walkpat(pat):

        srcs = []

        badstates = after and '?' or '?r'

        m = scmutil.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 badstates:

                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 = scmutil.canonpath(repo.root, cwd, otarget)

        reltarget = repo.pathto(abstarget, cwd)

        target = repo.wjoin(abstarget)

        src = repo.wjoin(abssrc)

        state = repo.dirstate[abstarget]

        scmutil.checkportable(ui, abstarget)

        # check for collisions

        prevsrc = targets.get(abstarget)

        if prevsrc is not None:

            ui.warn(_('%s: not overwriting - %s collides with %s\n') %

                    (reltarget, repo.pathto(abssrc, cwd),

                     repo.pathto(prevsrc, cwd)))

            return

        # check for overwrites

        exists = os.path.lexists(target)

        if not after and exists or after and state in 'mn':

            if not opts['force']:

                ui.warn(_('%s: not overwriting - file exists\n') %

                        reltarget)

                return

        if after:

            if not exists:

                if rename:

                    ui.warn(_('%s: not recording move - %s does not exist\n') %

                            (relsrc, reltarget))

                else:

                    ui.warn(_('%s: not recording copy - %s does not exist\n') %

                            (relsrc, reltarget))

                return

        elif not dryrun:

            try:

                if exists:

                    os.unlink(target)

                targetdir = os.path.dirname(target) or '.'

                if not os.path.isdir(targetdir):

                    os.makedirs(targetdir)

                util.copyfile(src, target)

            except IOError, inst:

                if inst.errno == errno.ENOENT:

                    ui.warn(_('%s: deleted in working copy\n') % relsrc)

                else:

                    ui.warn(_('%s: cannot copy - %s\n') %

                            (relsrc, inst.strerror))

                    return True # report a failure

        if ui.verbose or not exact:

            if rename:

                ui.status(_('moving %s to %s\n') % (relsrc, reltarget))

            else:

                ui.status(_('copying %s to %s\n') % (relsrc, reltarget))

        targets[abstarget] = abssrc

        # fix up dirstate

        scmutil.dirstatecopy(ui, repo, wctx, abssrc, abstarget,

                             dryrun=dryrun, cwd=cwd)

        if rename and not dryrun:

            wctx.remove([abssrc], not after)

    # pat: ossep

    # dest ossep

    # srcs: list of (hgsep, hgsep, ossep, bool)

    # return: function that takes hgsep and returns ossep

    def targetpathfn(pat, dest, srcs):

        if os.path.isdir(pat):

            abspfx = scmutil.canonpath(repo.root, cwd, pat)

            abspfx = util.localpath(abspfx)

            if destdirexists:

                striplen = len(os.path.split(abspfx)[0])

            else:

                striplen = len(abspfx)

            if striplen:

                striplen += len(os.sep)

            res = lambda p: os.path.join(dest, util.localpath(p)[striplen:])

        elif destdirexists:

            res = lambda p: os.path.join(dest,

                                         os.path.basename(util.localpath(p)))

        else:

            res = lambda p: dest

        return res

    # pat: ossep

    # dest ossep

    # srcs: list of (hgsep, hgsep, ossep, bool)

    # return: function that takes hgsep and returns ossep

    def targetpathafterfn(pat, dest, srcs):

        if matchmod.patkind(pat):

            # a mercurial pattern

            res = lambda p: os.path.join(dest,

                                         os.path.basename(util.localpath(p)))

        else:

            abspfx = scmutil.canonpath(repo.root, cwd, pat)

            if len(abspfx) < len(srcs[0][0]):

                # A directory. Either the target path contains the last

                # component of the source path or it does not.

                def evalpath(striplen):

                    score = 0

                    for s in srcs:

                        t = os.path.join(dest, util.localpath(s[0])[striplen:])

                        if os.path.lexists(t):

                            score += 1

                    return score

                abspfx = util.localpath(abspfx)

                striplen = len(abspfx)

                if striplen:

                    striplen += len(os.sep)

                if os.path.isdir(os.path.join(dest, os.path.split(abspfx)[1])):

                    score = evalpath(striplen)

                    striplen1 = len(os.path.split(abspfx)[0])

                    if striplen1:

                        striplen1 += len(os.sep)

                    if evalpath(striplen1) > score:

                        striplen = striplen1

                res = lambda p: os.path.join(dest,

                                             util.localpath(p)[striplen:])

            else:

                # a file

                if destdirexists:

                    res = lambda p: os.path.join(dest,

                                        os.path.basename(util.localpath(p)))

                else:

                    res = lambda p: dest

        return res

    pats = scmutil.expandpats(pats)

    if not pats:

        raise util.Abort(_('no source or destination specified'))

    if len(pats) == 1:

        raise util.Abort(_('no destination specified'))

    dest = pats.pop()

    destdirexists = os.path.isdir(dest) and not os.path.islink(dest)

    if not destdirexists:

        if len(pats) > 1 or matchmod.patkind(pats[0]):

            raise util.Abort(_('with multiple sources, destination must be an '

                               'existing directory'))

        if util.endswithsep(dest):

            raise util.Abort(_('destination %s is not a directory') % dest)

    tfn = targetpathfn

    if after:

        tfn = targetpathafterfn

    copylist = []

    for pat in pats:

        srcs = walkpat(pat)

        if not srcs:

            continue

        copylist.append((tfn(pat, dest, srcs), srcs))

    if not copylist:

        raise util.Abort(_('no files to copy'))

    errors = 0

    for targetpath, srcs in copylist:

        for abssrc, relsrc, exact in srcs:

            if copyfile(abssrc, relsrc, targetpath(abssrc), exact):

                errors += 1

    if errors:

        ui.warn(_('(consider using --after)\n'))

    return errors != 0

def service(opts, parentfn=None, initfn=None, runfn=None, logfile=None,

    runargs=None, appendpid=False):

    '''Run a command as a service.'''

    if opts['daemon'] and not opts['daemon_pipefds']:

        # Signal child process startup with file removal

        lockfd, lockpath = tempfile.mkstemp(prefix='hg-service-')

        os.close(lockfd)

        try:

            if not runargs:

                runargs = util.hgcmd() + sys.argv[1:]

            runargs.append('--daemon-pipefds=%s' % lockpath)

            # Don't pass --cwd to the child process, because we've already

            # changed directory.

            for i in xrange(1, len(runargs)):

                if runargs[i].startswith('--cwd='):

                    del runargs[i]

                    break

                elif runargs[i].startswith('--cwd'):

                    del runargs[i:i + 2]

                    break

            def condfn():

                return not os.path.exists(lockpath)

            pid = util.rundetached(runargs, condfn)

            if pid < 0:

                raise util.Abort(_('child process failed to start'))

        finally:

            try:

                os.unlink(lockpath)

            except OSError, e:

                if e.errno != errno.ENOENT:

                    raise

        if parentfn:

            return parentfn(pid)

        else:

            return

    if initfn:

        initfn()

    if opts['pid_file']:

        mode = appendpid and 'a' or 'w'

        fp = open(opts['pid_file'], mode)

        fp.write(str(os.getpid()) + '\n')

        fp.close()

    if opts['daemon_pipefds']:

        lockpath = opts['daemon_pipefds']

        try:

            os.setsid()

        except AttributeError:

            pass

        os.unlink(lockpath)

        util.hidewindow()

        sys.stdout.flush()

        sys.stderr.flush()

        nullfd = os.open(util.nulldev, os.O_RDWR)

        logfilefd = nullfd

        if logfile:

            logfilefd = os.open(logfile, os.O_RDWR | os.O_CREAT | os.O_APPEND)

        os.dup2(nullfd, 0)

        os.dup2(logfilefd, 1)

        os.dup2(logfilefd, 2)

        if nullfd not in (0, 1, 2):

            os.close(nullfd)

        if logfile and logfilefd not in (0, 1, 2):

            os.close(logfilefd)

    if runfn:

        return runfn()

def export(repo, revs, template='hg-%h.patch', fp=None, switch_parent=False,

           opts=None):

    '''export changesets as hg patches.'''

    total = len(revs)

    revwidth = max([len(str(rev)) for rev in revs])