#!/usr/bin/env python

from os import listdir

from os.path import abspath, split

import sys

# Locate and import the moinformat package.

dirname = split(abspath(sys.argv[0]))[0]

parent = split(dirname)[0]

try:

    import moinformat

except ImportError:

    if "moinformat" in listdir(parent):

        sys.path.append(parent)

# Import specific objects.

from moinformat import Metadata, make_input, make_output, make_parser, \

                       make_serialiser, parse, serialise

from moinformat.tree.moin import Container

def test_input(d, s):

    "Compare serialised output from 'd' with its original form 's'."

    metadata = Metadata({

        "pagename" : "TestPage",

        })

    # Encode the input.

    output = make_output(metadata)

    expected = output.encode(s)

    # Obtain and encode the output.

    result = serialise(d, make_serialiser(metadata))

    result = output.encode(result)

    # Test encoded input and output.

    identical = result == expected

    if quiet:

        return identical

    # Show output versus input comparison result.

    print identical

    print "-" * 60

    print result

    if not identical:

        print "-" * 60

        print expected

    print "-" * 60

    # Show HTML serialisation.

    metadata.set("output_format", "html")

    metadata.set("mapping", {"MoinMoin" : "https://moinmo.in/"})

    print serialise(d, make_serialiser(metadata))

    print "-" * 60

    print

    return identical

def test_tree(d, t, ts):

    "Compare tree structure 'd' with simplified, expected form 't' from 'ts'."

    failing = t.test(d)

    if quiet:

        return not failing

    # Show tree versus expected forms.

    print not failing

    print "-" * 60

    print d.prettyprint()

    if failing:

        print "-" * 60

        print ts

        simple, tree, error = failing

        print "-" * 60

        print error

        print repr(simple)

        print repr(tree)

        print "-" * 60

        print tree.prettyprint()

        print "-" * 60

        print simple.prettyprint()

    print "-" * 60

    print

    return not failing

class Node:

    "A simplified tree node representation."

    def __init__(self, name):

        self.name = name

        self.nodes = []

    def __repr__(self):

        return "Node(%r, %r)" % (self.name, self.nodes)

    def prettyprint(self, indent=""):

        l = []

        l.append("%s%s%s" % (indent, self.name, len(self.nodes) and " nodes=%d" % len(self.nodes) or ""))

        for node in self.nodes:

            l.append(node.prettyprint(indent + "  "))

        return "\n".join(l)

    def append(self, node):

        self.nodes.append(node)

    def test(self, other):

        """

        Test whether this node is considered equivalent to 'other', where

        'other' is a moinparser.tree node.

        Return any failing tree nodes or None.

        """

        if other.__class__.__name__ != self.name:

            return self, other, "name"

        if isinstance(other, Container):

            for node, other_node in map(None, self.nodes, other.nodes):

                if node is None or other_node is None:

                    return self, other, node is None and "simple" or "document"

                t = node.test(other_node)

                if t:

                    return t

        elif self.nodes:

            return self, other, "empty"

        return None

def parse_tree(s):

    "Parse the tree structure representation in 's'."

    indent = 0

    branches = []

    for line in s.split("\n"):

        line = line.rstrip()

        if not line:

            continue

        new_indent = line.rfind(" ") + 1

        node = Node(line[new_indent:])

        # Establish a branch to add nodes to.

        if not branches:

            branches.append(node)

        else:

            # Note the current node as outermost branch.

            if new_indent > indent:

                branches.append(node)

            else:

                # Reduced indent involves obtaining an inner branch again.

                while indent > new_indent:

                    del branches[-1]

                    indent -= 2

                # Note the current node as outermost branch.

                branches[-1] = node

            # Append the current node to the parent branch.

            branches[-2].append(node)

        indent = new_indent

    return branches[0]

def get_filename(filename):

    "Using 'filename', return the core text filename and any encoding."

    t = filename.split(".")

    if len(t) > 2:

        text_filename = ".".join(t[:2])

        encoding = t[2]

    else:

        text_filename = filename

        encoding = None

    return text_filename, encoding

def get_tree(input, tree_filename):

    "Using 'input', return (text, tree) for 'tree_filename'."

    if input.dir.exists(tree_filename):

        ts = input.readfile(tree_filename)

        return ts, parse_tree(ts)

    else:

        return None, None

if __name__ == "__main__":

    args = sys.argv[1:]

    if "--help" in args:

        print >>sys.stderr, """\

Usage: %s [ -q ] [ <filename>... ]

Run the test suite or, if filenames are indicated, specific test files.

The following options are supported:

-q          Suppress test output, reporting only success or failure

--quiet     Equivalent to -q

"""

        sys.exit(1)

    for arg in ["-q", "--quiet"]:

        if arg in args:

            del args[args.index(arg)]

            quiet = True

            break

    else:

        quiet = False

    metadata = Metadata({

        "input_context"     : "directory",

        "input_filename"    : dirname,

        })

    # Make an input context.

    input = make_input(metadata)

    # Obtain input filenames.

    filenames = args or input.dir.select_files("test*.txt*")

    filenames.sort()

    # Process each filename, obtaining a corresponding tree definition.

    for filename in filenames:

        text_filename, encoding = get_filename(filename)

        # Identify any tree-related filenames.

        basename = text_filename.rsplit(".", 1)[0]

        tree_filename = "%s.tree" % basename

        tree_exp_filename = "%s.tree-exp" % basename

        # Read and parse the input.

        s = input.readfile(filename, encoding)

        p = make_parser(metadata)

        d = parse(s, p)

        # Read and parse any tree definitions.

        ts, t = get_tree(input, tree_filename)

        tsexp, texp = get_tree(input, tree_exp_filename)

        # Report the test results.

        if not quiet:

            print filename

        identical = test_input(d, s)

        tree_identical = ts and test_tree(d, t, ts)

        if tsexp:

            p.evaluate_macros()

            tree_exp_identical = test_tree(d, texp, tsexp)

        else:

            tree_exp_identical = None

        if quiet:

            print "%s %s %s: %s" % (identical, tree_identical, tree_exp_identical, filename)

# vim: tabstop=4 expandtab shiftwidth=4