# 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 *

from i18n import _

import os, sys, bisect, stat

import mdiff, bdiff, util, templater, patch

revrangesep = ':'

class UnknownCommand(Exception):

    """Exception raised if command is not in the command table."""

class AmbiguousCommand(Exception):

    """Exception raised if command shortcut matches more than one command."""

def findpossible(ui, cmd, table):

    """

    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 ui.config("ui", "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(ui, cmd, table):

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

    choice = findpossible(ui, cmd, table)

    if choice.has_key(cmd):

        return choice[cmd]

    if len(choice) > 1:

        clist = choice.keys()

        clist.sort()

        raise AmbiguousCommand(cmd, clist)

    if choice:

        return choice.values()[0]

    raise UnknownCommand(cmd)

def bail_if_changed(repo):

    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['message']

    logfile = opts['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 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, repo.changelog.count() - 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, repo.changelog.count() - 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):

    if not pat or pat == '-':

        return 'w' in mode and sys.stdout or sys.stdin

    if hasattr(pat, 'write') and 'w' in mode:

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

    cwd = repo.getcwd()

    return util.cmdmatcher(repo.root, cwd, pats or [], opts.get('include'),

                           opts.get('exclude'), globbed=globbed,

                           default=default)

def walk(repo, pats=[], opts={}, node=None, badmatch=None, globbed=False,

         default=None):

    files, matchfn, anypats = matchpats(repo, pats, opts, globbed=globbed,

                                        default=default)

    exact = dict.fromkeys(files)

    cwd = repo.getcwd()

    for src, fn in repo.walk(node=node, files=files, match=matchfn,

                             badmatch=badmatch):

        yield src, fn, repo.pathto(fn, cwd), fn in exact

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

    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 = {}

    for src, abs, rel, exact in walk(repo, pats, opts):

        target = repo.wjoin(abs)

        if src == 'f' and abs not in repo.dirstate:

            add.append(abs)

            mapping[abs] = rel, exact

            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 util.lexists(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.add(add)

        repo.remove(remove)

    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 service(opts, parentfn=None, initfn=None, runfn=None):

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

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

        rfd, wfd = os.pipe()

        args = sys.argv[:]

        args.append('--daemon-pipefds=%d,%d' % (rfd, wfd))

        pid = os.spawnvp(os.P_NOWAIT | getattr(os, 'P_DETACH', 0),

                         args[0], args)

        os.close(wfd)

        os.read(rfd, 1)

        if parentfn:

            return parentfn(pid)

        else:

            os._exit(0)

    if initfn:

        initfn()

    if opts['pid_file']:

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

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

        fp.close()

    if opts['daemon_pipefds']:

        rfd, wfd = [int(x) for x in opts['daemon_pipefds'].split(',')]

        os.close(rfd)

        try:

            os.setsid()

        except AttributeError:

            pass

        os.write(wfd, 'y')

        os.close(wfd)

        sys.stdout.flush()

        sys.stderr.flush()

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

        if fd != 0: os.dup2(fd, 0)

        if fd != 1: os.dup2(fd, 1)

        if fd != 2: os.dup2(fd, 2)

        if fd not in (0, 1, 2): os.close(fd)

    if runfn:

        return runfn()

class changeset_printer(object):

    '''show changeset information when templating not requested.'''

    def __init__(self, ui, repo, patch, buffered):

        self.ui = ui

        self.repo = repo

        self.buffered = buffered

        self.patch = patch

        self.header = {}

        self.hunk = {}

        self.lastheader = None

    def flush(self, rev):

        if rev in self.header:

            h = self.header[rev]

            if h != self.lastheader:

                self.lastheader = h

                self.ui.write(h)

            del self.header[rev]

        if rev in self.hunk:

            self.ui.write(self.hunk[rev])

            del self.hunk[rev]

            return 1

        return 0

    def show(self, rev=0, changenode=None, copies=(), **props):

        if self.buffered:

            self.ui.pushbuffer()

            self._show(rev, changenode, copies, props)

            self.hunk[rev] = self.ui.popbuffer()

        else:

            self._show(rev, changenode, copies, props)

    def _show(self, rev, changenode, copies, props):

        '''show a single changeset or file revision'''

        log = self.repo.changelog

        if changenode is None:

            changenode = log.node(rev)

        elif not rev:

            rev = log.rev(changenode)

        if self.ui.quiet:

            self.ui.write("%d:%s\n" % (rev, short(changenode)))

            return

        changes = log.read(changenode)

        date = util.datestr(changes[2])

        extra = changes[5]

        branch = extra.get("branch")

        hexfunc = self.ui.debugflag and hex or short

        parents = [(p, hexfunc(log.node(p)))

                   for p in self._meaningful_parentrevs(log, rev)]

        self.ui.write(_("changeset:   %d:%s\n") % (rev, hexfunc(changenode)))

        # don't show the default branch name

        if branch != 'default':

            branch = util.tolocal(branch)

            self.ui.write(_("branch:      %s\n") % branch)

        for tag in self.repo.nodetags(changenode):

            self.ui.write(_("tag:         %s\n") % tag)

        for parent in parents:

            self.ui.write(_("parent:      %d:%s\n") % parent)

        if self.ui.debugflag:

            self.ui.write(_("manifest:    %d:%s\n") %

                          (self.repo.manifest.rev(changes[0]), hex(changes[0])))

        self.ui.write(_("user:        %s\n") % changes[1])

        self.ui.write(_("date:        %s\n") % date)

        if self.ui.debugflag:

            files = self.repo.status(log.parents(changenode)[0], changenode)[:3]

            for key, value in zip([_("files:"), _("files+:"), _("files-:")],

                                  files):

                if value:

                    self.ui.write("%-12s %s\n" % (key, " ".join(value)))

        elif changes[3] and self.ui.verbose:

            self.ui.write(_("files:       %s\n") % " ".join(changes[3]))

        if copies and self.ui.verbose:

            copies = ['%s (%s)' % c for c in copies]

            self.ui.write(_("copies:      %s\n") % ' '.join(copies))

        if extra and self.ui.debugflag:

            extraitems = extra.items()

            extraitems.sort()

            for key, value in extraitems:

                self.ui.write(_("extra:       %s=%s\n")

                              % (key, value.encode('string_escape')))

        description = changes[4].strip()

        if description:

            if self.ui.verbose:

                self.ui.write(_("description:\n"))

                self.ui.write(description)

                self.ui.write("\n\n")

            else:

                self.ui.write(_("summary:     %s\n") %

                              description.splitlines()[0])

        self.ui.write("\n")

        self.showpatch(changenode)

    def showpatch(self, node):

        if self.patch:

            prev = self.repo.changelog.parents(node)[0]

            patch.diff(self.repo, prev, node, match=self.patch, fp=self.ui,

                       opts=patch.diffopts(self.ui))

            self.ui.write("\n")

    def _meaningful_parentrevs(self, log, rev):

        """Return list of meaningful (or all if debug) parentrevs for rev.

        For merges (two non-nullrev revisions) both parents are meaningful.

        Otherwise the first parent revision is considered meaningful if it

        is not the preceding revision.

        """

        parents = log.parentrevs(rev)

        if not self.ui.debugflag and parents[1] == nullrev:

            if parents[0] >= rev - 1:

                parents = []

            else:

                parents = [parents[0]]

        return parents

class changeset_templater(changeset_printer):

    '''format changeset information.'''

    def __init__(self, ui, repo, patch, mapfile, buffered):

        changeset_printer.__init__(self, ui, repo, patch, buffered)

        filters = templater.common_filters.copy()

        filters['formatnode'] = (ui.debugflag and (lambda x: x)

                                 or (lambda x: x[:12]))

        self.t = templater.templater(mapfile, filters,

                                     cache={

                                         'parent': '{rev}:{node|formatnode} ',

                                         'manifest': '{rev}:{node|formatnode}',

                                         'filecopy': '{name} ({source})'})

    def use_template(self, t):

        '''set template string to use'''

        self.t.cache['changeset'] = t

    def _show(self, rev, changenode, copies, props):

        '''show a single changeset or file revision'''

        log = self.repo.changelog

        if changenode is None:

            changenode = log.node(rev)

        elif not rev:

            rev = log.rev(changenode)

        changes = log.read(changenode)

        def showlist(name, values, plural=None, **args):

            '''expand set of values.

            name is name of key in template map.

            values is list of strings or dicts.

            plural is plural of name, if not simply name + 's'.