public void ParseCallNoArgsMarkupTest()
{
//Parse tokens
MarkupParser markupParser = new MarkupParser(Init("home()"));
Markup parsedMarkup = markupParser.ParseMarkup();
//Check markup
Assert.AreEqual("home", parsedMarkup.GetDesignator().GetIdentifier()); //identifier check
Assert.AreEqual(0, parsedMarkup.GetDesignator().GetAttributes().Count); //no attributes
Assert.AreEqual(0, parsedMarkup.GetArguments().Count); //no arguments
}
public void ParseEmbeddingTest()
{
//Create parser
EmbeddingParser embeddingParser = new EmbeddingParser(Init("\"left<func1() \"text\">right\""));
Embedding parsedEmbedding = embeddingParser.ParseEmbedding();
//Test PreText
Assert.AreEqual("left", parsedEmbedding.GetPreText().GetText());
//Test Embed
Assert.AreEqual(typeof(ExpressionEmbed), parsedEmbedding.GetEmbed().GetType());
ExpressionEmbed expressionEmbed = (ExpressionEmbed)parsedEmbedding.GetEmbed();
Assert.AreEqual("\"text\"", expressionEmbed.GetExpression().ToString());
//Test Markup
Markup markup = (Markup)expressionEmbed.GetMarkups().Get(0);
Assert.AreEqual("func1", markup.GetDesignator().ToString());
Assert.AreEqual(0, markup.GetArguments().Count);
//Test TextTail
Assert.AreEqual(typeof(PostTextTail), parsedEmbedding.GetTextTail().GetType());
PostTextTail postTextTail = (PostTextTail)parsedEmbedding.GetTextTail();
Assert.AreEqual("right", postTextTail.GetPostText().GetText());
}
public void ParseSiteTest()
{
//Get tokens and parse it
SiteParser siteParser = new SiteParser(Init("site/index.html : home(\"argument\")\nend"));
Site parsedSite = siteParser.ParseSite();
//Test mappings of site
Assert.AreEqual(1, parsedSite.GetMappings().Count);
Mapping[] mappingArray = (Mapping[])parsedSite.GetMappings().ToArray();
Mapping mapping = mappingArray[0];
//Test path of site
Assert.AreEqual("site/index.html", mapping.GetPath().ToString());
//Test markup of site
Markup parsedMarkup = mapping.GetMarkup();
Assert.AreEqual("home", parsedMarkup.GetDesignator().GetIdentifier());
Assert.AreEqual(1, parsedMarkup.GetArguments().Count);
//Test argument
Argument[] argumentArray = (Argument[])parsedMarkup.GetArguments().ToArray();
Assert.AreEqual(typeof(ExpressionArgument), argumentArray[0].GetType());
Assert.AreEqual("argument", argumentArray[0].ToString());
}
public void ParseMarkupStatStatementTest()
{
//Create parser
StatementParser statementParser = new StatementParser(Init("p { echo \"test\"; }"));
Statement parsedStatement = statementParser.ParseMarkupStatement();
//Test Statement
Assert.AreEqual(typeof(MarkupStatStatement), parsedStatement.GetType());
//Test MarkupStatStatement
MarkupStatStatement markupStatStatement = (MarkupStatStatement)parsedStatement;
Assert.AreEqual(1, markupStatStatement.GetMarkups().Count);
//Test markup
Markup markup = (Markup)markupStatStatement.GetMarkups().Get(0);
Assert.AreEqual("p", markup.GetDesignator().GetIdentifier());
Assert.AreEqual(0, markup.GetArguments().Count);
//Test statement
Assert.AreEqual(typeof(BlockStatement), markupStatStatement.GetStatement().GetType());
BlockStatement statement = (BlockStatement)markupStatStatement.GetStatement();
Assert.AreEqual(1, statement.GetStatements().Count);
Statement stmt = (Statement)statement.GetStatements().Get(0);
Assert.AreEqual(typeof(EchoExpressionStatement), stmt.GetType());
Assert.AreEqual("echo \"test\";", stmt.ToString());
}
public void ParseSingleMappingTest()
{
//Set up parser
TokenIterator tokens = Init("site/home.html : home()");
SiteParser siteParser = new SiteParser(tokens);
Mapping mapping = siteParser.ParseMapping();
//Test path of site
Assert.AreEqual("site/home.html", mapping.GetPath().ToString());
//Test markup of site
Markup parsedMarkup = mapping.GetMarkup();
Assert.AreEqual("home", parsedMarkup.GetDesignator().GetIdentifier());
Assert.AreEqual(0, parsedMarkup.GetArguments().Count);
}
/// <summary>
/// Visit Markup
/// </summary>
/// <param name="markup">Markup to check</param>
public override void Visit(Markup markup)
{
//Check identifier in designator, it should be an XHTML or an user defined function
String identifier = markup.GetDesignator().GetIdentifier();
if (SymbolTable.ContainsFunction(identifier))
{
//Check arguments
FunctionDefinition referencedDefinition = SymbolTable.GetFunctionDefinition(identifier);
if (referencedDefinition.GetFormals().Count != markup.GetArguments().Count)
{ //Arity mismatch
ExceptionList.Add(new FunctionCallArityIncorrect(identifier));
}
}
else
{
//Check if it is XHTML, if not its undefined
if (!IdentifierIsXHTML(identifier) && markup.GetCallState())
{
ExceptionList.Add(new UndefinedFunction(identifier));
}
}
}
/// <summary>
/// Determine if an markup is an CallMarkup
/// </summary>
/// <param name="markup">Markup to check</param>
/// <returns>IsCall</returns>
private bool IsCall(Markup markup)
{
return(SymbolTable.ContainsFunction(markup.GetDesignator().GetIdentifier()));
}
/// <summary>
/// Interpret an Markup
/// </summary>
/// <param name="markup">Markup to interpret</param>
public override void Visit(Markup markup)
{
if (IsCall(markup))
{ //We are calling a function
FunctionDefinition functionDefinition = SymbolTable.GetFunctionDefinition(markup.GetDesignator().GetIdentifier());
//Create SymbolTable for specific function
SymbolTable tempSymbolTable = SymbolTable;
SymbolTable = new SymbolTable(GetSymbolTableOfFunction(functionDefinition));
//Store arguments in SymbolTable as variables
int index = 0;
NodeList arguments = markup.GetArguments();
foreach (Formal formal in functionDefinition.GetFormals())
{
Expression expr = null;
if (arguments.Count > index)
{
Argument arg = (Argument)arguments.Get(index);
expr = arg.GetExpression();
}
SymbolTable.AddVariableDefinition(formal.GetIdentifier(), expr);
index++;
}
//Visit functiondefinition
functionDefinition.AcceptVisitor(this);
//Go back to parent SymbolTable
SymbolTable = tempSymbolTable;
}
else
{ //Dealing with an Tag
String tag = markup.GetDesignator().GetIdentifier();
//Write tag with retrieved attributes
AddElement(new XHTMLElement(tag, Current));
//Visit the attributes
foreach (Parser.Ast.Markup.Attribute attribute in markup.GetDesignator().GetAttributes())
{
attribute.AcceptVisitor(this);
}
//Interpret arguments also as attributes
String attributeValue = "";
foreach (Argument argument in markup.GetArguments())
{
if (argument is AttrArgument)
{
//Interpret expression to retrieve value
((AttrArgument)argument).GetExpression().AcceptVisitor(this);
//Store attribute
String attr = ((AttrArgument)argument).GetIdentifier();
Current.AddAttribute(attr, TextValue);
}
else if (argument is ExpressionArgument)
{
//Interpret expression
((ExpressionArgument)argument).GetExpression().AcceptVisitor(this);
if (TextValue == "undef")
{
TextValue = "UNDEFINED";
}
//Store value
if (!(attributeValue == "") && !(TextValue != ""))
{
attributeValue += " ";
}
attributeValue += TextValue;
}
}
if (attributeValue != "")
{ //Add value attribute
Current.AddAttribute("value", attributeValue);
}
}
}
/// <summary>
/// Visit Markup
/// </summary>
/// <param name="markup">Markup to check</param>
public override void Visit(Markup markup)
{
//Check identifier in designator, it should be an XHTML or an user defined function
String identifier = markup.GetDesignator().GetIdentifier();
if(SymbolTable.ContainsFunction(identifier))
{
//Check arguments
FunctionDefinition referencedDefinition = SymbolTable.GetFunctionDefinition(identifier);
if(referencedDefinition.GetFormals().Count != markup.GetArguments().Count)
{ //Arity mismatch
ExceptionList.Add(new FunctionCallArityIncorrect(identifier));
}
}
else
{
//Check if it is XHTML, if not its undefined
if (!IdentifierIsXHTML(identifier) && markup.GetCallState())
{
ExceptionList.Add(new UndefinedFunction(identifier));
}
}
}
