private HtmlTagInstruction PopulateHtmlTag(ScopePrototype scope, HtmlTag htmlTag) { var htmlTagInstruction = new HtmlTagInstruction(scope, htmlTag); PopulateInstructions(htmlTag.Instructions, htmlTagInstruction.Block, scope); return(htmlTagInstruction); }
public void StringValueWithValueOfScopeWithStringOnly_BuildString_StringBuildCorrectly() { // prepare var scope_prototype = new ScopePrototype { Variables = new HashSet <string> { "model " }, }; var scope = new Scope(scope_prototype) { VariableValues = new Dictionary <string, AssignedValue> { { "model", new AssignedValue(JToken.Parse("\"black\"")) } } }; var stringValue = new StringValue { StringComponents = new List <IStringComponent> { new ValueOf { VariableName = "model" }, } }; // act var result = StringValueBuilder.Build(stringValue, scope); // validate Assert.Equal("black", result); }
public void ScopeWithObjectWithArray_VariableIsCalled_CorrectValueIsReturned() { // prepare var scope_prototype = new ScopePrototype { Variables = new HashSet <string> { "array" }, }; var scope = new Scope(scope_prototype) { VariableValues = new Dictionary <string, AssignedValue> { { "array", new AssignedValue(JToken.Parse("{'object': [1,3,6]}")) } } }; var valueOf = new ValueOf { VariableName = "array", NestedValue = new ValueOf { VariableName = "object", Index = 2 } }; // act var value = scope.FindValueOfValueOf(valueOf); // validate Assert.Equal("6", value); }
private FunctionCallInstruction PopulateFunctionCallInstruction(ScopePrototype scope, FunctionCall functionCall) { // check if the function has been declared in the scope Block function_block; if (!_functions.TryGetValue(functionCall.FunctionName, out function_block)) { throw new SemanticsException($"Function {functionCall.FunctionName} has not been declared in the scope of the function {scope.FunctionName}."); } // check if called arguments exist in the scope foreach (var argument in functionCall.ArgumentValues) { if (argument.GetType() == typeof(ValueOf)) { if (!scope.Variables.Contains(((ValueOf)argument).VariableName)) { throw new SemanticsException($"Variable {((ValueOf) argument).VariableName} has not been declared in the scope of the function {scope.FunctionName}."); } } } var funCallInstruction = new FunctionCallInstruction(scope, functionCall); return(funCallInstruction); }
public void ScopeWithVariable_VariableIsCalled_CorrectValueIsReturned() { // prepare var scope_prototype = new ScopePrototype { Variables = new HashSet <string> { "arg" }, }; var scope = new Scope(scope_prototype) { VariableValues = new Dictionary <string, AssignedValue> { { "arg", new AssignedValue(JToken.Parse("'value'")) } } }; var valueOf = new ValueOf { VariableName = "arg" }; // act var value = scope.FindValueOfValueOf(valueOf); // validate Assert.Equal("value", value); }
public void DefinedFunctionWithValueOfCall_CallFunctionWithArguments_ScopeInitializedCorrectly() { // prepare var variables = new List <string> { "arg1" }; var functionBlock = new Block(null, variables, "fun"); functionBlock.NestedBlocks.Add(new StringComponentInstruction(functionBlock.ScopePrototype, new ValueOf { VariableName = "arg1" })); var functionDictionary = new Dictionary <string, Block> { { "function", functionBlock } }; var scope_prototype = new ScopePrototype { Variables = new HashSet <string> { "model" }, }; var scope = new Scope(scope_prototype) { VariableValues = new Dictionary <string, AssignedValue> { { "model", new AssignedValue(JToken.Parse("['value1', 'value2']")) } } }; var functionCallInstruction = new FunctionCallInstruction(scope_prototype, new FunctionCall { FunctionName = "function", ArgumentValues = new List <Value> { new ValueOf { VariableName = "model", Index = 1 } } }); // act var memoryStream = new MemoryStream(); var streamWriter = new StreamWriter(memoryStream); var node = new Node { StreamWriter = streamWriter, NewLine = false, NestedLevel = 0, Scope = scope, FunctionsDict = functionDictionary }; functionCallInstruction.Execute(node); streamWriter.Flush(); // validate memoryStream.Position = 0; var streamReader = new StreamReader(memoryStream); //Assert.Equal("\nvalue2", streamReader.ReadToEnd()); Assert.Equal("value2", streamReader.ReadToEnd()); }
public void DefinedFunction_CallFunctionWithArgumentsOutOfScope_ThrowRuntimeException() { // prepare var variables = new List <string> { "arg1" }; var functionBlock = new Block(null, variables, "fun"); var functionDictionary = new Dictionary <string, Block> { { "function", functionBlock } }; var scope_prototype = new ScopePrototype { Variables = new HashSet <string> { "model" }, }; var scope = new Scope(scope_prototype) { VariableValues = new Dictionary <string, AssignedValue> { { "model", new AssignedValue(JToken.Parse("['value1', 'value2']")) } } }; var functionCallInstruction = new FunctionCallInstruction(scope_prototype, new FunctionCall { FunctionName = "function", ArgumentValues = new List <Value> { new ValueOf { VariableName = "model", Index = 2 } } }); // act var streamWriter = new Mock <StreamWriter>(new MemoryStream()); var exceptionWasThrown = false; var node = new Node { StreamWriter = streamWriter.Object, NewLine = false, NestedLevel = 0, Scope = scope, FunctionsDict = functionDictionary }; try { functionCallInstruction.Execute(node); } catch (RuntimeException) { exceptionWasThrown = true; } // validate Assert.True(exceptionWasThrown); }
private IfInstruction PopulateIfCondition(ScopePrototype scope, IfExpression ifExpression, ElseExpression elseExpression) { var ifInstruction = new IfInstruction(scope, ifExpression); PopulateInstructions(ifExpression.Instructions, ifInstruction.IfBlock, scope); if (elseExpression != null) { PopulateInstructions(elseExpression.Instructions, ifInstruction.ElseBlock, scope); } return(ifInstruction); }
private StringComponentInstruction PopulateValueOf(ScopePrototype scope, ValueOf valueOf) { // check if value has been declared in the scope if (!scope.Variables.Contains(valueOf.VariableName)) { throw new SemanticsException($"Variable {valueOf.VariableName} has not been declared in the scope of function {scope.FunctionName}."); } var valueOfInstruction = new StringComponentInstruction(scope, valueOf); return(valueOfInstruction); }
public void DefinedFunctionWithValueOfCallWithSimpleValue_CallFunctionWithArguments_ScopeInitializedCorrectly() { // prepare var variables = new List <string> { "arg1" }; var functionBlock = new Block(null, variables, "fun"); functionBlock.NestedBlocks.Add(new StringComponentInstruction(functionBlock.ScopePrototype, new ValueOf { VariableName = "arg1" })); var functionDictionary = new Dictionary <string, Block> { { "function", functionBlock } }; var scope_prototype = new ScopePrototype { Variables = new HashSet <string> { "model" }, }; var scope = new Scope(scope_prototype) { VariableValues = new Dictionary <string, AssignedValue> { { "model", new AssignedValue(JToken.Parse("'value2'")) } } }; var functionCallInstruction = new FunctionCallInstruction(scope_prototype, new FunctionCall { FunctionName = "function", ArgumentValues = new List <Value> { new ValueOf { VariableName = "model" } } }); // act var streamWriter = new Mock <StreamWriter>(new MemoryStream()); var node = new Node { StreamWriter = streamWriter.Object, NewLine = false, NestedLevel = 0, Scope = scope, FunctionsDict = functionDictionary }; functionCallInstruction.Execute(node); // validate streamWriter.Verify(s => s.Write("value2"), Times.Once); }
private ForInstruction PopulateForInstruction(ScopePrototype scope, ForExpression forExpression) { // check if the value to be iterated over exists in the scope if (!scope.Variables.Contains(forExpression.Collection.VariableName)) { throw new SemanticsException($"Variable {forExpression.Collection.VariableName} has not been declared in the scope of operation for in function {scope.FunctionName}."); } var forInstruction = new ForInstruction(scope, forExpression); PopulateInstructions(forExpression.Instructions, forInstruction.Block.NestedBlocks, forInstruction.Block.ScopePrototype); return(forInstruction); }
public void DefinedForInstruction_CallInsideScopeWithArrayOfObjects_NestedScopesInitializedCorrectly() { // prepare var outer_scope_prototype = new ScopePrototype { Variables = new HashSet <string> { "model" }, }; var outer_scope = new Scope(outer_scope_prototype) { VariableValues = new Dictionary <string, AssignedValue> { { "model", new AssignedValue(JToken.Parse("{'field1':[{'prop': 2},{'prop': 5},{'prop':8}],'field2':'val2'}")) } } }; var forInstruction = new ForInstruction(outer_scope_prototype, new ForExpression { Collection = new ValueOf { VariableName = "model", NestedValue = new ValueOf { VariableName = "field1" } }, ElementName = "element" }); forInstruction.Block.NestedBlocks.Add(new StringComponentInstruction(forInstruction.Block.ScopePrototype, new ValueOf { VariableName = "element", NestedValue = new ValueOf { VariableName = "prop" } })); // act var streamWriter = new Mock <StreamWriter>(new MemoryStream()); var node = new Node { StreamWriter = streamWriter.Object, NewLine = false, NestedLevel = 0, Scope = outer_scope }; forInstruction.Execute(node); // validate // Assert.Single(forInstruction.ScopePrototype.Variables); // Assert.True(forInstruction.Scope.VariableValues.ContainsKey("model")); // Assert.Single(forInstruction.Block.Scope.VariableValues); // Assert.Equal("8", forInstruction.Block.Scope.VariableValues["element"].); streamWriter.Verify(s => s.Write("2"), Times.Once); streamWriter.Verify(s => s.Write("5"), Times.Once); streamWriter.Verify(s => s.Write("8"), Times.Once); }
public void ScopeWithoutVariable_VariableIsCalled_RuntimeExceptionIsThrown() { // prepare var outer_scope_prototype = new ScopePrototype { Variables = new HashSet <string> { "arg" }, }; var scope_prototype = new ScopePrototype { Variables = new HashSet <string> { "arg2" }, UpperScopePrototype = outer_scope_prototype }; var scope = new Scope(scope_prototype) { UpperScope = new Scope(outer_scope_prototype) { VariableValues = new Dictionary <string, AssignedValue> { { "arg", new AssignedValue(JToken.Parse("'value'")) } } }, VariableValues = new Dictionary <string, AssignedValue> { { "arg2", new AssignedValue(JToken.Parse("'value2'")) } } }; var valueOf = new ValueOf { VariableName = "arg3" }; // act var exceptionWasThrown = false; try { scope.FindValueOfValueOf(valueOf); } catch (RuntimeException) { exceptionWasThrown = true; } // validate Assert.True(exceptionWasThrown); }
public void StringValueWithValueOfAndStringsAlternating_BuildString_StringBuildCorrectly() { // prepare var scope_prototype = new ScopePrototype { Variables = new HashSet <string> { "model " }, }; var scope = new Scope(scope_prototype) { VariableValues = new Dictionary <string, AssignedValue> { { "model", new AssignedValue(JToken.Parse("{'val1': 'aaa', 'val2': 'bbb'}")) } } }; var stringValue = new StringValue { StringComponents = new List <IStringComponent> { new Literal { Content = "literal_" }, new ValueOf { VariableName = "model", NestedValue = new ValueOf { VariableName = "val1" } }, new ValueOf { VariableName = "model", NestedValue = new ValueOf { VariableName = "val2" } }, new Literal { Content = "_end" } } }; // act var result = StringValueBuilder.Build(stringValue, scope); // validate Assert.Equal("literal_aaabbb_end", result); }
public void DefinedFunctionWithRecursiveFunctionCall_CallFunctionWithArguments_TwoDifferentScopesUsed() { // prepare var scope_prototype = new ScopePrototype { Variables = new HashSet <string> { "arg1", "stopcondition" }, }; var variables = new List <string> { "arg1", "stopcondition" }; var functionBlock = new Block(null, variables, "function"); functionBlock.NestedBlocks.Add(new StringComponentInstruction(functionBlock.ScopePrototype, new ValueOf { VariableName = "arg1" })); functionBlock.NestedBlocks.Add(new IfInstruction(scope_prototype, new IfExpression { Condition = new SimpleCondition { LeftHandSideVariable = new ValueOf { VariableName = "stopcondition" } }, Negated = true }) { IfBlock = new List <Executable> { new FunctionCallInstruction(scope_prototype, new FunctionCall { FunctionName = "function", ArgumentValues = new List <Value> { new StringValue { StringComponents = new List <IStringComponent> { new Literal { Content = "another_value" } } }, new StringValue { StringComponents = new List <IStringComponent> { new Literal { Content = "true" } } }, } }) } }); functionBlock.NestedBlocks.Add(new StringComponentInstruction(functionBlock.ScopePrototype, new ValueOf { VariableName = "arg1" })); var functionDictionary = new Dictionary <string, Block> { { "function", functionBlock } }; var scope = new Scope(scope_prototype) { VariableValues = new Dictionary <string, AssignedValue> { { "arg1", new AssignedValue(JToken.Parse("'value2'")) } } }; var functionCallInstruction = new FunctionCallInstruction(scope_prototype, new FunctionCall { FunctionName = "function", ArgumentValues = new List <Value> { new ValueOf { VariableName = "arg1" }, new StringValue { StringComponents = new List <IStringComponent> { new Literal { Content = "false" } } } } }); // act var streamWriter = new Mock <StreamWriter>(new MemoryStream()); var node = new Node { StreamWriter = streamWriter.Object, NewLine = false, NestedLevel = 0, Scope = scope, FunctionsDict = functionDictionary }; functionCallInstruction.Execute(node); // validate streamWriter.Verify(s => s.Write("value2"), Times.Exactly(2)); streamWriter.Verify(s => s.Write("another_value"), Times.Exactly(2)); }
private HtmlInlineTagInstruction PopulateHtmlInlineTag(ScopePrototype scope, HtmlInlineTag htmlInlineTag) { var htmlInlineInstruction = new HtmlInlineTagInstruction(scope, htmlInlineTag); return(htmlInlineInstruction); }
private StringComponentInstruction PopulateLiteral(ScopePrototype scope, Literal literal) { var literalInstruction = new StringComponentInstruction(scope, literal); return(literalInstruction); }
private void PopulateInstructions(List <IInstruction> instructions, List <Executable> block, ScopePrototype scope) { IfExpression encounteredIfExpression = null; foreach (var instruction in instructions) { if (encounteredIfExpression != null) { if (instruction.GetType() == typeof(ElseExpression)) { block.Add(PopulateIfCondition(scope, encounteredIfExpression, (ElseExpression)instruction)); encounteredIfExpression = null; continue; } else { block.Add(PopulateIfCondition(scope, encounteredIfExpression, null)); encounteredIfExpression = null; } } if (instruction.GetType() == typeof(IfExpression)) { encounteredIfExpression = (IfExpression)instruction; } else if (instruction.GetType() == typeof(ForExpression)) { block.Add(PopulateForInstruction(scope, (ForExpression)instruction)); } else if (instruction.GetType() == typeof(ElseExpression)) { throw new SemanticsException("Else instruction must be preceeded by the if block"); } else if (instruction.GetType() == typeof(FunctionCall)) { block.Add(PopulateFunctionCallInstruction(scope, (FunctionCall)instruction)); } else if (instruction.GetType() == typeof(HtmlInlineTag)) { block.Add(PopulateHtmlInlineTag(scope, (HtmlInlineTag)instruction)); } else if (instruction.GetType() == typeof(HtmlTag)) { block.Add(PopulateHtmlTag(scope, (HtmlTag)instruction)); } else if (instruction.GetType() == typeof(Literal)) { block.Add(PopulateLiteral(scope, (Literal)instruction)); } else if (instruction.GetType() == typeof(ValueOf)) { block.Add(PopulateValueOf(scope, (ValueOf)instruction)); } else { throw new SemanticsException($"Unknown instruction type: ${instruction.GetType()}"); } } if (encounteredIfExpression != null) { block.Add(PopulateIfCondition(scope, encounteredIfExpression, null)); } }