# cmdutil.py - help for command processing in mercurial

#

# Copyright 2005, 2006 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, mdiff, util, templater, patch

revrangesep = ':'

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 and revwidth is not None:

            expander['r'] = (lambda:

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

        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={}, head='', globbed=False):

    cwd = repo.getcwd()

    if not pats and cwd:

        opts['include'] = [os.path.join(cwd, i)

                           for i in opts.get('include', [])]

        opts['exclude'] = [os.path.join(cwd, x)

                           for x in opts.get('exclude', [])]

        cwd = ''

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

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

def walk(repo, pats=[], opts={}, node=None, head='', badmatch=None,

         globbed=False):

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

                                        globbed=globbed)

    exact = dict.fromkeys(files)

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

                             badmatch=badmatch):

        yield src, fn, util.pathto(repo.getcwd(), fn), fn in exact

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

    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)

        bestscore, bestname = None, None

        for r in removed:

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

            delta = mdiff.textdiff(aa, rr)

            if len(delta) < len(aa):

                myscore = 1.0 - (float(len(delta)) / len(aa))

                if bestscore is None or myscore > bestscore:

                    bestscore, bestname = myscore, r

        if bestname and bestscore >= threshold:

            yield bestname, a, bestscore

def addremove(repo, pats=[], opts={}, wlock=None, 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):

        if src == 'f' and repo.dirstate.state(abs) == '?':

            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.state(abs) != 'r' and not os.path.exists(rel):

            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, wlock=wlock)

        repo.remove(remove, wlock=wlock)

    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, wlock=wlock)

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=None, **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 = log.parentrevs(rev)

        if not self.ui.debugflag:

            if parents[1] == nullrev:

                if parents[0] >= rev - 1:

                    parents = []

                else:

                    parents = [parents[0]]

        parents = [(p, hexfunc(log.node(p))) for p in parents]

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

        if branch:

            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)

            self.ui.write("\n")

class changeset_templater(changeset_printer):

    '''format changeset information.'''

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

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

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

                                     cache={'parent': '{rev}:{node|short} ',

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

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