private static LiquidAST CreateAST(string template)
{
LiquidASTGenerator generator = new LiquidASTGenerator();
// Act
return(generator.Generate(template).LiquidAST);
}
private static LiquidTemplate CreateRenderer(IList<LiquidError> errors, string erroneousTemplate)
{
var liquidAstGenerator = new LiquidASTGenerator();
OnParsingErrorEventHandler liquidAstGeneratorParsingErrorEventHandler = errors.Add;
liquidAstGenerator.ParsingErrorEventHandler += liquidAstGeneratorParsingErrorEventHandler;
var liquidAst = liquidAstGenerator.Generate(erroneousTemplate);
var template = new LiquidTemplate(liquidAst);
return template;
}
private static LiquidTemplate CreateRenderer(IList <LiquidError> errors, string erroneousTemplate)
{
var liquidAstGenerator = new LiquidASTGenerator();
//OnParsingErrorEventHandler liquidAstGeneratorParsingErrorEventHandler = errors.Add;
//liquidAstGenerator.ParsingErrorEventHandler += liquidAstGeneratorParsingErrorEventHandler;
var liquidAst = liquidAstGenerator.Generate(erroneousTemplate, errors.Add);
var template = new LiquidTemplate(liquidAst);
return(template);
}
public void It_Should_Parse_An_Object_Expression_With_An_Propertied_Variable()
{
// Arrange
LiquidASTGenerator generator = new LiquidASTGenerator();
// Act
LiquidAST ast = generator.Generate("Result : {{ a.b }}");
// Assert
var liquidExpressions = FindNodesWithType(ast, typeof(LiquidExpressionTree));
Logger.Log("There are " + ast.RootNode.Children.Count + " Nodes");
Assert.That(liquidExpressions.Count(), Is.EqualTo(1));
}
public static LiquidParsingResult Create(String template)
{
IList <LiquidError> errors = new List <LiquidError>();
var liquidAst = new LiquidASTGenerator().Generate(template, errors.Add);
//if (errors.Any())
//{
// //throw new LiquidParserException(errors);
//}
//else
//{
var result = new LiquidTemplate(liquidAst);
//}
return(LiquidParsingResult.Create(result, errors));
}
public void It_Should_Find_A_Filter()
{
// Arrange
LiquidASTGenerator generator = new LiquidASTGenerator();
// Act
LiquidAST ast = generator.Generate("Result : {{ 123 | plus: 3}}");
// Assert
var liquidExpressions = FindNodesWithType(ast, typeof(LiquidExpressionTree)).FirstOrDefault();
Assert.That(liquidExpressions, Is.Not.Null);
var liquidExpression = ((LiquidExpressionTree)liquidExpressions.Data);
Assert.That(liquidExpression.ExpressionTree.Data.FilterSymbols.Count(), Is.EqualTo(1));
}
public void It_Should_Render_An_Error_When_Include_Contains_Parsing_Errors()
{
// Arrange
var ctx = CreateContext(new Dictionary <String, String>
{
{ "test", "problem: {% unterminated" }
}).WithAllFilters();
const String template = "{% include 'test' %}";
// Act
var ast = new LiquidASTGenerator().Generate(template);
var renderingVisitor = new RenderingVisitor(ctx);
String result = "";
renderingVisitor.StartWalking(ast.LiquidAST.RootNode, x => result += x);
//Console.WriteLine("RESULT: " + result);
Assert.Contains("missing TAGEND", result);
}
public void It_Should_Accumulate_Errors_When_Include_Contains_Rendering_Errors()
{
// Arrange
var ctx = CreateContext(new Dictionary <String, String>
{
{ "test", "problem: {{ 1 | divided_by: 0 }}" }
}).WithAllFilters();
//var defaultAstGenerator = ctx.ASTGenerator;
//ctx.WithASTGenerator(str => { called = true; return defaultAstGenerator(str); });
const String template = "{% include 'test' %}";
// Act
var ast = new LiquidASTGenerator().Generate(template);
var renderingVisitor = new RenderingVisitor(ctx);
String result = "";
renderingVisitor.StartWalking(ast.LiquidAST.RootNode, x => result += x);
//Console.WriteLine(result);
Assert.True(renderingVisitor.HasErrors);
}
public void It_Should_Accumulate_Errors_When_Include_Contains_Parsing_Errors()
{
// Arrange
var ctx = CreateContext(new Dictionary <String, String>
{
{ "test", "problem: {% unterminated" }
}).WithAllFilters();
const String template = "{% include 'test' %}";
// Act
var liquidParsingResult = new LiquidASTGenerator().Generate(template);
Assert.False(liquidParsingResult.HasParsingErrors);
var renderingVisitor = new RenderingVisitor(ctx);
String result = "";
renderingVisitor.StartWalking(liquidParsingResult.LiquidAST.RootNode, x => result += x);
//Console.WriteLine(result);
Assert.True(renderingVisitor.HasErrors);
}
public void It_Should_Parse_An_Indexed_Object_Reference(String tmpl)
{
// Arrange
LiquidASTGenerator generator = new LiquidASTGenerator();
// Act
//LiquidAST ast = generator.Generate("Result : {{ a[12][b[\"test\"][c.d.e[1]]] }}");
LiquidAST ast = generator.Generate("Result : "+ tmpl);
// Assert
var liquidExpressions = FindNodesWithType(ast, typeof(LiquidExpressionTree));
Assert.That(liquidExpressions, Is.Not.Null);
//Logger.Log("There are " + ast.RootNode.Children.Count + " Nodes");
//Logger.Log("It is " + ast.RootNode.Children[0].Data);
//Assert.That(liquidExpressions.Count(), Is.EqualTo(1));
//Assert.That(generator.GetNonEmptyStackErrors(), Is.Empty);
Assert.That(liquidExpressions.Count(), Is.EqualTo(1));
//String result = VariableReferenceTreeBuilderTests.VariableReferenceTreePrinter.Print(liquidExpressions);
}
public void It_Should_Group_Expressions_In_Parens()
{
// Arrange
LiquidASTGenerator generator = new LiquidASTGenerator();
// Act
LiquidAST ast = generator.Generate("Result : {% if true and (false or false) %}FALSE{% endif %}");
var visitor= new DebuggingVisitor();
StartVisiting(visitor,ast.RootNode);
// Assert
var tagExpressions = FindNodesWithType(ast, typeof(IfThenElseBlockTag)).ToList();
var ifThenElseTag = (IfThenElseBlockTag) tagExpressions[0].Data;
Assert.That(tagExpressions.Count(), Is.EqualTo(1));
//Assert.That(ifThenElseTag.IfElseClauses[0].RootNode.Data, Is.TypeOf<AndExpression>());
//TODO: TextMessageWriter otu the tree
//Assert.That(ifThenElseTag.IfElseClauses[0].RootNode[0].Data, Is.TypeOf<AndExpression>());
var ifTagSymbol = ifThenElseTag.IfElseClauses[0];
//Assert.That(ifTagSymbol.RootNode.Data, Is.TypeOf<AndExpression>());
var expressionSymbolTree = ifTagSymbol.LiquidExpressionTree;
Assert.That(expressionSymbolTree.Data.Expression, Is.TypeOf<AndExpression>());
Assert.That(expressionSymbolTree.Children.Count, Is.EqualTo(2));
Assert.That(expressionSymbolTree[0].Data.Expression, Is.TypeOf<BooleanValue>());
Assert.That(expressionSymbolTree[1].Data.Expression, Is.TypeOf<GroupedExpression>());
Assert.That(expressionSymbolTree[1].Children.Count, Is.EqualTo(1));
Assert.That(expressionSymbolTree[1][0].Data.Expression, Is.TypeOf<OrExpression>());
Assert.That(expressionSymbolTree[1][0][0].Data.Expression, Is.TypeOf<BooleanValue>());
Assert.That(expressionSymbolTree[1][0][1].Data.Expression, Is.TypeOf<BooleanValue>());
//Assert.That(ifThenElseTag.IfElseClauses[0].LiquidExpression[2].Data, Is.TypeOf<GroupedExpression>());
//Assert.That(liquidExpressions, Is.Not.Null);
//Assert.That(((LiquidExpression)liquidExpressions.Data).FilterSymbols.Count(), Is.EqualTo(1));
}
public void It_Should_Nest_Expressions_Inside_Else()
{
// Arrange
LiquidASTGenerator generator = new LiquidASTGenerator();
// Act
LiquidAST ast = generator.Generate("Result : {% if true %} 33 + 4 = {% if true %} {{ 33 | add: 4}} {% endif %}{% else %} hello {% endif %}");
var tagExpressions = FindNodesWithType(ast, typeof(IfThenElseBlockTag)).FirstOrDefault();
var ifThenElseTag = (IfThenElseBlockTag)tagExpressions.Data;
var blockTags = ifThenElseTag.IfElseClauses[0].LiquidBlock.Children;
var liquidExpressions = FindWhere(blockTags, typeof(IfThenElseBlockTag));
// Assert
Assert.That(liquidExpressions.Count(), Is.EqualTo(1));
}
public void It_Should_Find_An_If_Tag_With_ElsIfs_And_Else()
{
// Arrange
LiquidASTGenerator generator = new LiquidASTGenerator();
// Act
LiquidAST ast = generator.Generate("Result : {% if true %} aaaa {% elsif false %} test 2 {% elsif true %} test 3 {% else %} ELSE {% endif %}");
// Assert
var tagExpressions = FindNodesWithType(ast, typeof(IfThenElseBlockTag));
Assert.That(tagExpressions.Count(), Is.EqualTo(1));
//Assert.That(liquidExpressions, Is.Not.Null);
//Assert.That(((LiquidExpression)liquidExpressions.Data).FilterSymbols.Count(), Is.EqualTo(1));
}
public void SetUp()
{
_generator = new LiquidASTGenerator();
}
public LiquidASTRendererTests()
{
_generator = new LiquidASTGenerator();
}
public static LiquidTemplate Create(String template)
{
var liquidAst = new LiquidASTGenerator().Generate(template);
return new LiquidTemplate(liquidAst);
}
public void SetUp()
{
_generator = new LiquidASTGenerator();
}
public void It_Can_Find_Two_Object_Expressions()
{
// Arrange
LiquidASTGenerator generator = new LiquidASTGenerator();
// Act
LiquidAST ast = generator.Generate("Result : {{ 123 }} {{ 456 }}");
// Assert
var liquidExpressions = FindNodesWithType(ast, typeof(LiquidExpressionTree));
Assert.That(liquidExpressions.Count(), Is.EqualTo(2));
//Assert.That(generator.GetNonEmptyStackErrors(), Is.Empty);
}
public void It_Should_Capture_The_Raw_Text()
{
// Arrange
LiquidASTGenerator generator = new LiquidASTGenerator();
// Act
LiquidAST ast = generator.Generate("Result : {{ 123 | add: 3}} More Text.");
// Assert
var liquidExpressions = FindNodesWithType(ast, typeof(RawBlockTag));
Assert.That(liquidExpressions.Count(), Is.EqualTo(2));
}
public LiquidASTExpressionParsingTests()
{
_generator = new LiquidASTGenerator();
}
