# 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, bdiff, 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={}, 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)

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

                             badmatch=badmatch):

        yield src, fn, util.pathto(repo.root, repo.getcwd(), fn), 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)

            myscore = equal*2.0 / (len(aa)+len(rr))

            if myscore >= bestscore:

                bestname, bestscore = r, myscore

        if bestname:

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

        islink = os.path.islink(rel)

        if repo.dirstate.state(abs) != 'r' and not islink 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)))

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

            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)

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

            expansion works like this, given name 'foo'.

            if values is empty, expand 'no_foos'.

            if 'foo' not in template map, return values as a string,

            joined by space.

            expand 'start_foos'.

            for each value, expand 'foo'. if 'last_foo' in template

            map, expand it instead of 'foo' for last key.

            expand 'end_foos'.

            '''

            if plural: names = plural

            else: names = name + 's'

            if not values:

                noname = 'no_' + names

                if noname in self.t:

                    yield self.t(noname, **args)

                return

            if name not in self.t:

                if isinstance(values[0], str):

                    yield ' '.join(values)

                else:

                    for v in values:

                        yield dict(v, **args)

                return

            startname = 'start_' + names

            if startname in self.t:

                yield self.t(startname, **args)

            vargs = args.copy()

            def one(v, tag=name):

                try:

                    vargs.update(v)

                except (AttributeError, ValueError):

                    try:

                        for a, b in v:

                            vargs[a] = b

                    except ValueError:

                        vargs[name] = v

                return self.t(tag, **vargs)

            lastname = 'last_' + name

            if lastname in self.t:

                last = values.pop()

            else:

                last = None

            for v in values:

                yield one(v)

            if last is not None:

                yield one(last, tag=lastname)

            endname = 'end_' + names

            if endname in self.t:

                yield self.t(endname, **args)

        def showbranches(**args):

            branch = changes[5].get("branch")

            if branch != 'default':

                branch = util.tolocal(branch)

                return showlist('branch', [branch], plural='branches', **args)

        def showparents(**args):

            parents = [[('rev', log.rev(p)), ('node', hex(p))]

                       for p in log.parents(changenode)

                       if self.ui.debugflag or p != nullid]

            if (not self.ui.debugflag and len(parents) == 1 and

                parents[0][0][1] == rev - 1):

                return

            return showlist('parent', parents, **args)

        def showtags(**args):

            return showlist('tag', self.repo.nodetags(changenode), **args)

        def showextras(**args):

            extras = changes[5].items()

            extras.sort()

            for key, value in extras:

                args = args.copy()

                args.update(dict(key=key, value=value))

                yield self.t('extra', **args)

        def showcopies(**args):

            c = [{'name': x[0], 'source': x[1]} for x in copies]

            return showlist('file_copy', c, plural='file_copies', **args)

        if self.ui.debugflag:

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

            def showfiles(**args):

                return showlist('file', files[0], **args)

            def showadds(**args):

                return showlist('file_add', files[1], **args)

            def showdels(**args):

                return showlist('file_del', files[2], **args)

            def showmanifest(**args):

                args = args.copy()

                args.update(dict(rev=self.repo.manifest.rev(changes[0]),

                                 node=hex(changes[0])))

                return self.t('manifest', **args)

        else:

            def showfiles(**args):

                return showlist('file', changes[3], **args)

            showadds = ''

            showdels = ''

            showmanifest = ''

        defprops = {

            'author': changes[1],

            'branches': showbranches,

            'date': changes[2],

            'desc': changes[4],

            'file_adds': showadds,

            'file_dels': showdels,

            'files': showfiles,

            'file_copies': showcopies,

            'manifest': showmanifest,

            'node': hex(changenode),

            'parents': showparents,

            'rev': rev,

            'tags': showtags,

            'extras': showextras,

            }

        props = props.copy()

        props.update(defprops)

        try:

            if self.ui.debugflag and 'header_debug' in self.t:

                key = 'header_debug'

            elif self.ui.quiet and 'header_quiet' in self.t:

                key = 'header_quiet'

            elif self.ui.verbose and 'header_verbose' in self.t:

                key = 'header_verbose'

            elif 'header' in self.t:

                key = 'header'

            else:

                key = ''

            if key:

                h = templater.stringify(self.t(key, **props))

                if self.buffered:

                    self.header[rev] = h

                else:

                    self.ui.write(h)

            if self.ui.debugflag and 'changeset_debug' in self.t:

                key = 'changeset_debug'

            elif self.ui.quiet and 'changeset_quiet' in self.t:

                key = 'changeset_quiet'