TestExtractorVisitor.java

/* --------------------------------------------------------- *
 *    __________    D E L T A S C R I P T                    *
 *   (_________()                                            *
 *    /  ===   /   - A fast, dynamic scripting language      *
 *   |  ==    |    - Version 4.13.11.0                       *
 *   /  ===   /    - Developed by Adam R. Nelson             *
 *  |  =  =  |     - 2011-2013                               *
 *  /  ===   /     - Distributed under GNU LGPL v3           *
 * (________()     - http://github.com/ar-nelson/deltascript *
 *                                                           *
 * --------------------------------------------------------- */

package com.sector91.delta.script.test.doctest;

import java.util.List;

import org.pegdown.ast.AbbreviationNode;
import org.pegdown.ast.AutoLinkNode;
import org.pegdown.ast.BlockQuoteNode;
import org.pegdown.ast.BulletListNode;
import org.pegdown.ast.CodeNode;
import org.pegdown.ast.DefinitionListNode;
import org.pegdown.ast.DefinitionNode;
import org.pegdown.ast.DefinitionTermNode;
import org.pegdown.ast.ExpImageNode;
import org.pegdown.ast.ExpLinkNode;
import org.pegdown.ast.HeaderNode;
import org.pegdown.ast.HtmlBlockNode;
import org.pegdown.ast.InlineHtmlNode;
import org.pegdown.ast.ListItemNode;
import org.pegdown.ast.MailLinkNode;
import org.pegdown.ast.Node;
import org.pegdown.ast.OrderedListNode;
import org.pegdown.ast.ParaNode;
import org.pegdown.ast.QuotedNode;
import org.pegdown.ast.RefImageNode;
import org.pegdown.ast.RefLinkNode;
import org.pegdown.ast.ReferenceNode;
import org.pegdown.ast.RootNode;
import org.pegdown.ast.SimpleNode;
import org.pegdown.ast.SpecialTextNode;
import org.pegdown.ast.StrongEmphSuperNode;
import org.pegdown.ast.SuperNode;
import org.pegdown.ast.TableBodyNode;
import org.pegdown.ast.TableCaptionNode;
import org.pegdown.ast.TableCellNode;
import org.pegdown.ast.TableColumnNode;
import org.pegdown.ast.TableHeaderNode;
import org.pegdown.ast.TableNode;
import org.pegdown.ast.TableRowNode;
import org.pegdown.ast.TextNode;
import org.pegdown.ast.VerbatimNode;
import org.pegdown.ast.Visitor;
import org.pegdown.ast.WikiLinkNode;

import com.sector91.delta.script.DScriptContext;
import com.sector91.util.A;

public class TestExtractorVisitor implements Visitor
{
    private StringBuilder sb = new StringBuilder();
    private final List<DocTest> tests = A.list();
    private final DScriptContext context;
    private String file, header, subheader;

    public TestExtractorVisitor(String file, DScriptContext context)
    {
        this.file = file;
        this.context = context;
    }
    
    public void visit(AbbreviationNode node)
    {sb.append(node.getExpansion());}

    public void visit(AutoLinkNode node)
    {}

    public void visit(BlockQuoteNode node)
    {visitChildren(node);}

    public void visit(BulletListNode node)
    {visitChildren(node);}

    public void visit(CodeNode node)
    {sb.append(node.getText());}

    public void visit(DefinitionListNode node)
    {visitChildren(node);}

    public void visit(DefinitionNode node)
    {visitChildren(node);}

    public void visit(DefinitionTermNode node)
    {visitChildren(node);}

    public void visit(ExpImageNode node)
    {visitChildren(node);}

    public void visit(ExpLinkNode node)
    {visitChildren(node);}

    public void visit(HeaderNode node)
    {
        if (node.getLevel() == 1)
            header = extractText(node).trim();
        else
            subheader = extractText(node).trim();
    }

    public void visit(HtmlBlockNode node)
    {sb.append(node.getText());}

    public void visit(InlineHtmlNode node)
    {sb.append(node.getText());}

    public void visit(ListItemNode node)
    {visitChildren(node);}

    public void visit(MailLinkNode node)
    {}

    public void visit(OrderedListNode node)
    {visitChildren(node);}

    public void visit(ParaNode node)
    {visitChildren(node);}

    public void visit(QuotedNode node)
    {visitChildren(node);}

    public void visit(ReferenceNode node)
    {visitChildren(node);}

    public void visit(RefImageNode node)
    {visitChildren(node);}

    public void visit(RefLinkNode node)
    {visitChildren(node);}

    public void visit(RootNode node)
    {visitChildren(node);}

    public void visit(SimpleNode node)
    {
        switch (node.getType()) {
        case Apostrophe:
            sb.append('\'');
            break;
        case Ellipsis:
            sb.append("...");
            break;
        case Emdash:
            sb.append(" -- ");
            break;
        case Endash:
            sb.append("--");
            break;
        case HRule:
            sb.append("\n---\n");
            break;
        case Linebreak:
            sb.append("\n");
            break;
        case Nbsp:
            sb.append(" ");
            break;
        default:
            throw new IllegalStateException();
    }
    }

    public void visit(SpecialTextNode node)
    {sb.append(node.getText());}

    public void visit(TableBodyNode node)
    {visitChildren(node);}

    public void visit(TableCaptionNode node)
    {visitChildren(node);}

    public void visit(TableCellNode node)
    {visitChildren(node);}

    public void visit(TableColumnNode node)
    {visitChildren(node);}

    public void visit(TableHeaderNode node)
    {visitChildren(node);}

    public void visit(TableNode node)
    {visitChildren(node);}

    public void visit(TableRowNode node)
    {visitChildren(node);}

    public void visit(VerbatimNode node)
    {
        final String text = node.getText();
        sb.append(text);
        if (text.contains(DocTest.ASSERT_PREFIX))
            tests.add(new DocTest(file, header, subheader, context, text));
    }

    public void visit(WikiLinkNode node)
    {sb.append(node.getText());}

    public void visit(TextNode node)
    {sb.append(node.getText());}

    public void visit(SuperNode node)
    {visitChildren(node);}

    public void visit(Node node)
    {throw new UnsupportedOperationException();}
    
    public List<DocTest> getTests()
    {return tests;}
    
    private void visitChildren(SuperNode node)
    {
        for (Node child : node.getChildren())
            child.accept(this);
    }
    
    private String extractText(SuperNode node)
    {
        sb = new StringBuilder();
        visitChildren(node);
        return sb.toString();
    }

    public void visit(StrongEmphSuperNode node)
    {visitChildren(node);}
}