#!/usr/bin/env python

from os.path import abspath, exists, join, split

import sys

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

parent = split(dirname)[0]

try:

    import moinformat

except ImportError:

    if split(parent)[1] == "MoinLight":

        sys.path.append(parent)

from moinformat import all_parsers, get_serialiser, parse, serialise

from moinformat.tree.moin import Container

from glob import glob

def test_input(d, s):

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

    o = serialise(d)

    identical = o == s

    if quiet:

        return identical

    # Show output versus input comparison result.

    print identical

    print "-" * 60

    print o

    if not identical:

        print "-" * 60

        print s

    print "-" * 60

    print serialise(d, get_serialiser("html"))

    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 readfile(filename):

    "Read the contents of 'filename' and return them."

    f = open(filename)

    try:

        return f.read()

    finally:

        f.close()

if __name__ == "__main__":

    args = sys.argv[1:]

    quiet = "-q" in args

    if quiet:

        del args[args.index("-q")]

    filenames = args or glob(join(dirname, "test*.txt"))

    filenames.sort()

    for filename in filenames:

        tree_filename = "%s.tree" % filename.rsplit(".", 1)[0]

        s = readfile(filename)

        d = parse(s, all_parsers)

        if exists(tree_filename):

            ts = readfile(tree_filename)

            t = parse_tree(ts)

        else:

            ts = None

        if not quiet:

            print filename

        identical = test_input(d, s)

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

        if quiet:

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

# vim: tabstop=4 expandtab shiftwidth=4