# testparseutil.py - utilities to parse test script for check tools

#

#  Copyright 2018 FUJIWARA Katsunori <foozy@lares.dti.ne.jp> and others

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from __future__ import absolute_import, print_function

import abc

import re

import sys

####################

# for Python3 compatibility (almost comes from mercurial/pycompat.py)

ispy3 = (sys.version_info[0] >= 3)

def identity(a):

    return a

def _rapply(f, xs):

    if xs is None:

        # assume None means non-value of optional data

        return xs

    if isinstance(xs, (list, set, tuple)):

        return type(xs)(_rapply(f, x) for x in xs)

    if isinstance(xs, dict):

        return type(xs)((_rapply(f, k), _rapply(f, v)) for k, v in xs.items())

    return f(xs)

def rapply(f, xs):

    if f is identity:

        # fast path mainly for py2

        return xs

    return _rapply(f, xs)

if ispy3:

    import builtins

    # TODO: .buffer might not exist if std streams were replaced; we'll need

    # a silly wrapper to make a bytes stream backed by a unicode one.

    stdin = sys.stdin.buffer

    stdout = sys.stdout.buffer

    stderr = sys.stderr.buffer

    def bytestr(s):

        # tiny version of pycompat.bytestr

        return s.encode('latin1')

    def sysstr(s):

        if isinstance(s, builtins.str):

            return s

        return s.decode(u'latin-1')

    def opentext(f):

        return open(f, 'rb')

else:

    stdin = sys.stdin

    stdout = sys.stdout

    stderr = sys.stderr

    bytestr = str

    sysstr = identity

    opentext = open

def b2s(x):

    # convert BYTES elements in "x" to SYSSTR recursively

    return rapply(sysstr, x)

def writeout(data):

    # write "data" in BYTES into stdout

    stdout.write(data)

def writeerr(data):

    # write "data" in BYTES into stderr

    stderr.write(data)

####################

class embeddedmatcher(object):

    """Base class to detect embedded code fragments in *.t test script

    """

    __metaclass__ = abc.ABCMeta

    def __init__(self, desc):

        self.desc = desc

    @abc.abstractmethod

    def startsat(self, line):

        """Examine whether embedded code starts at line

        This can return arbitrary object, and it is used as 'ctx' for

        subsequent method invocations.

        """

    @abc.abstractmethod

    def endsat(self, ctx, line):

        """Examine whether embedded code ends at line"""

    @abc.abstractmethod

    def isinside(self, ctx, line):

        """Examine whether line is inside embedded code, if not yet endsat

        """

    @abc.abstractmethod

    def ignores(self, ctx):

        """Examine whether detected embedded code should be ignored"""

    @abc.abstractmethod

    def filename(self, ctx):

        """Return filename of embedded code

        If filename isn't specified for embedded code explicitly, this

        returns None.

        """

    @abc.abstractmethod

    def codeatstart(self, ctx, line):

        """Return actual code at the start line of embedded code

        This might return None, if the start line doesn't contain

        actual code.

        """

    @abc.abstractmethod

    def codeatend(self, ctx, line):

        """Return actual code at the end line of embedded code

        This might return None, if the end line doesn't contain actual

        code.

        """

    @abc.abstractmethod

    def codeinside(self, ctx, line):

        """Return actual code at line inside embedded code"""

def embedded(basefile, lines, errors, matchers):

    """pick embedded code fragments up from given lines

    This is common parsing logic, which examines specified matchers on

    given lines.

    :basefile: a name of a file, from which lines to be parsed come.

    :lines: to be parsed (might be a value returned by "open(basefile)")

    :errors: an array, into which messages for detected error are stored

    :matchers: an array of embeddedmatcher objects

    This function yields '(filename, starts, ends, code)' tuple.

    :filename: a name of embedded code, if it is explicitly specified

               (e.g.  "foobar" of "cat >> foobar <<EOF").

               Otherwise, this is None

    :starts: line number (1-origin), at which embedded code starts (inclusive)

    :ends: line number (1-origin), at which embedded code ends (exclusive)

    :code: extracted embedded code, which is single-stringified

    >>> class ambigmatcher(object):

    ...     # mock matcher class to examine implementation of

    ...     # "ambiguous matching" corner case

    ...     def __init__(self, desc, matchfunc):

    ...         self.desc = desc

    ...         self.matchfunc = matchfunc

    ...     def startsat(self, line):

    ...         return self.matchfunc(line)

    >>> ambig1 = ambigmatcher(b'ambiguous #1',

    ...                       lambda l: l.startswith(b'  $ cat '))

    >>> ambig2 = ambigmatcher(b'ambiguous #2',

    ...                       lambda l: l.endswith(b'<< EOF\\n'))

    >>> lines = [b'  $ cat > foo.py << EOF\\n']

    >>> errors = []

    >>> matchers = [ambig1, ambig2]

    >>> list(t for t in embedded(b'<dummy>', lines, errors, matchers))

    []

    >>> b2s(errors)

    ['<dummy>:1: ambiguous line for "ambiguous #1", "ambiguous #2"']

    """

    matcher = None

    ctx = filename = code = startline = None # for pyflakes

    for lineno, line in enumerate(lines, 1):

        if not line.endswith(b'\n'):

            line += b'\n' # to normalize EOF line

        if matcher: # now, inside embedded code

            if matcher.endsat(ctx, line):

                codeatend = matcher.codeatend(ctx, line)

                if codeatend is not None:

                    code.append(codeatend)

                if not matcher.ignores(ctx):

                    yield (filename, startline, lineno, b''.join(code))

                matcher = None

                # DO NOT "continue", because line might start next fragment

            elif not matcher.isinside(ctx, line):

                # this is an error of basefile

                # (if matchers are implemented correctly)

                errors.append(b'%s:%d: unexpected line for "%s"'

                              % (basefile, lineno, matcher.desc))

                # stop extracting embedded code by current 'matcher',

                # because appearance of unexpected line might mean

                # that expected end-of-embedded-code line might never