private ExpressionSyntax GenerateInternal(ExpressionData expressionData, TypeCode parentTypeCode, bool isParentImmutableType) { var(success, typeCode, (generatedSyntax, argumentList)) = GenerateForMainExpression(expressionData); if (success) { var generated = generatedSyntax.FirstOrDefault(); if (IsNotImmutableType(generated, typeCode)) { return(GenerateExpressionSyntax(expressionData, generated, isParentImmutableType, parentTypeCode)); } if (_typeAnalyzer.IsPrimitiveType(parentTypeCode)) { return(argumentList.First()); } var objectCreationSyntax = _immutableInitializationGenerator.Generate(expressionData, argumentList); return(GenerateExpressionSyntax(expressionData, objectCreationSyntax, isParentImmutableType, parentTypeCode)); } var underlyingExpressionData = IterateThroughUnderlyingExpressionsData(expressionData.UnderlyingExpressionData, typeCode, isParentImmutableType); switch (typeCode) { case TypeCode.DictionaryKeyValuePair: { var dictionaryKey = GetExpressionDataForDictionary(expressionData, "Key"); if (dictionaryKey == null) { return(null); } var dictionaryValue = GetExpressionDataForDictionary(expressionData, "Value"); if (dictionaryValue == null) { return(null); } var keyExpressionSyntax = GenerateInternal(dictionaryKey, typeCode, isParentImmutableType); var valueExpressionSyntax = GenerateInternal(dictionaryValue, typeCode, isParentImmutableType); return(_dictionaryExpressionGenerator.Generate(keyExpressionSyntax, valueExpressionSyntax)); } case TypeCode.Array: { var arraySyntax = _arrayInitializationGenerator.Generate(expressionData, underlyingExpressionData, typeCode); return(_assignmentExpressionGenerator.GenerateAssignmentExpression(expressionData.Name, arraySyntax)); } case TypeCode.Collection: default: { var complexTypeExpression = _complexTypeInitializationGenerator.Generate(expressionData, underlyingExpressionData); return(GenerateExpressionSyntax(expressionData, complexTypeExpression, isParentImmutableType, parentTypeCode)); } } }
/// <summary> /// Promotes/writes the specified set of properties into the message context. /// </summary> /// <param name="pipelineContext">Pipeline context</param> /// <param name="inputMessage">Input message</param> /// <returns>Original input message</returns> protected override IBaseMessage Execute(IPipelineContext pipelineContext, IBaseMessage inputMessage) { if (this.ContextProperties != null && this.ContextProperties.Count > 0) { // set the dynamic expression context required for ContextProperty properties of type "Expression" ExpressionData expressionData = new ExpressionData(inputMessage); this.ExpressionContext = new Expressions.ExpressionContext(ExpressionImports, expressionData); // iterate through all context properties promoting or writing foreach (ContextProperty contextProperty in this.ContextProperties) { object value = this.GetPropertyValue(inputMessage, contextProperty); if (contextProperty.IgnoreNullOrEmptyValue == false || this.IsNullOrEmptyValue(value) == false) { if (contextProperty.Promote == true) { TraceProvider.Logger.TraceInfo("Promoting property into context: {0} = {1}; Namespace = {2}, Source = {3}", contextProperty.Name, value, contextProperty.Namespace, contextProperty.Source.ToString()); inputMessage.Context.Promote(contextProperty.Name, contextProperty.Namespace, value); } else { TraceProvider.Logger.TraceInfo("Writing property into context: {0} = {1}; Namespace = {2}, Source = {3}", contextProperty.Name, value, contextProperty.Namespace, contextProperty.Source.ToString()); inputMessage.Context.Write(contextProperty.Name, contextProperty.Namespace, value); } } else { TraceProvider.Logger.TraceInfo("Ignoring null or empty value: {0} = {1}; Namespace = {2}, Source = {3}", contextProperty.Name, value, contextProperty.Namespace, contextProperty.Source.ToString()); } } } return(inputMessage); }
internal static Template FromBlockNode(string templateName, JinjaEnvironment environment, BlockNode blockNode, IDictionary <string, object?> variableTemplate) { var rootScope = Scope.CreateRootScope("GLOBALS", variableTemplate); var expr = NewASTCompiler.ToExpression(templateName, environment, blockNode, out var newcompiler, rootScope); return(new Template(environment, ExpressionData.CreateCompiled(expr, rootScope), blockNode.Name, null)); }
public ExpressionSyntax Generate(ExpressionData expressionData) { return(SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(expressionData.Type), SyntaxFactory.IdentifierName(expressionData.Value))); }
public void ShouldGenerate_ListOfComplexType() { var stackObject = new ExpressionData("Test", "{ConsoleApp1.Program.Test}", "test123", new List <ExpressionData>() { new ExpressionData("List<int>", "Count = 3", "IntList", new List <ExpressionData>() { new ExpressionData("int", "221", "[0]", new List <ExpressionData>() { }, "int"), new ExpressionData("int", "195", "[1]", new List <ExpressionData>() { }, "int"), new ExpressionData("int", "10", "[2]", new List <ExpressionData>() { }, "int") }, "System.Collections.Generic.List<int>"), new ExpressionData("List<string>", "Count = 3", "IntString", new List <ExpressionData>() { new ExpressionData("string", "ef311e42-8e09-4f69-8332-880e87b02add", "[0]", new List <ExpressionData>() { }, "string"), new ExpressionData("string", "3d5f03ec-556e-4ca5-9bf5-2162a392b2be", "[1]", new List <ExpressionData>() { }, "string"), new ExpressionData("string", "4df373a1-5785-4787-94cb-0b5bddadac0b", "[2]", new List <ExpressionData>() { }, "string") }, "System.Collections.Generic.List<string>") }, "ConsoleApp1.Program.Test"); var generated = _codeGeneratorManager.GenerateStackDump(stackObject); generated.Should().Be("var test123 = new Test()\n{\r\n IntList = new List<int>() { 221, 195, 10 },\r\n IntString = new List<string>() { \"ef311e42-8e09-4f69-8332-880e87b02add\", \"3d5f03ec-556e-4ca5-9bf5-2162a392b2be\", \"4df373a1-5785-4787-94cb-0b5bddadac0b\" }\r\n};\n"); }
public void TestExpressionDataToStringReturnsType() { var expression = Expression.Constant(null, typeof(object)); var expressionData = new ExpressionData(expression, expression.Type); Assert.AreEqual("Type: System.Object", expressionData.ToString()); }
public void TestExpressionDataToStringWhenNameIsSpecifiedReturnsTypeAndName() { var expression = Expression.Constant(null, typeof(object)); var expressionData = new ExpressionData(expression, expression.Type, "SomeProperty"); Assert.AreEqual("Type: System.Object, Name: SomeProperty", expressionData.ToString()); }
internal static CompiledTemplate LoadTemplate(JinjaEnvironment environment, string templateText, IDictionary <string, object?> variableTemplate, string templateName, string?templatePath) { var rootScope = CompiledScope.CreateRootScope("GLOBALS", variableTemplate); var expr = ToExpression(templateName, environment, templateText, rootScope); return(new CompiledTemplate(environment, ExpressionData.CreateCompiled(expr, rootScope), templateName, templatePath)); }
public (SeparatedSyntaxList <ExpressionSyntax> generatedSyntax, List <ExpressionSyntax> argumentSyntax) Generate(ExpressionData expressionData) { if (expressionData.UnderlyingExpressionData.Count != 11) { return(new SeparatedSyntaxList <ExpressionSyntax>(), null); } var guid = new System.Guid( int.Parse(expressionData.UnderlyingExpressionData[0].Value), short.Parse(expressionData.UnderlyingExpressionData[1].Value), short.Parse(expressionData.UnderlyingExpressionData[2].Value), byte.Parse(expressionData.UnderlyingExpressionData[3].Value), byte.Parse(expressionData.UnderlyingExpressionData[4].Value), byte.Parse(expressionData.UnderlyingExpressionData[5].Value), byte.Parse(expressionData.UnderlyingExpressionData[6].Value), byte.Parse(expressionData.UnderlyingExpressionData[7].Value), byte.Parse(expressionData.UnderlyingExpressionData[8].Value), byte.Parse(expressionData.UnderlyingExpressionData[9].Value), byte.Parse(expressionData.UnderlyingExpressionData[10].Value)); var newExpressionData = new ExpressionData(expressionData.Type, expressionData.Value, expressionData.Name, null, expressionData.TypeWithNamespace); var stringConstructorArgument = _primitiveExpressionGenerator.Generate(TypeCode.String, guid.ToString()); var generated = _complexTypeInitializationGenerator.Generate(newExpressionData, new SeparatedSyntaxList <ExpressionSyntax>()); return(new SeparatedSyntaxList <ExpressionSyntax>().Add(generated), new List <ExpressionSyntax> { stringConstructorArgument }); }
private CompiledTemplate(JinjaEnvironment environment, ExpressionData templateNode, string?templateName, string?templatePath) { TemplateNode = templateNode; Environment = environment; TemplateName = templateName; TemplatePath = templatePath; }
private static ExpressionData GenerateDictionaryElement(string keyValue, string valueValue, int index) { var key = new ExpressionData("int", keyValue, "Key", new List <ExpressionData>(), "int"); var value = new ExpressionData("string", valueValue, "Value", new List <ExpressionData>(), "string"); var keyDuplicated = new ExpressionData("int", keyValue, "key", new List <ExpressionData>(), "int"); var firstObject = new ExpressionData("KeyValuePair<int, string>", $"{{[{keyValue}, {valueValue}]}}", $"[{index}]", new[] { key, value, keyDuplicated }, "System.Collections.Generic.KeyValuePair<int, string>"); return(firstObject); }
public void ShouldGenerate_SimpleCharacter(string charString) { var stackObject = new ExpressionData("char", $"'{charString}'", "testString", new ExpressionData[] { }, "char"); var generated = _codeGeneratorManager.GenerateStackDump(stackObject); generated.Should().Be($"var testString = \'{charString}\';\n"); }
public void ShouldGenerate_StringWithQuotationMarkAndTwoBackslashAndSpaceBetween() { var stackObject = new ExpressionData("string", "\" sdasd \\\\\\\\ \\\\\\\\ \\\\\\\\ \\\"test\\\" asdasd ' asd\"", "testString", new ExpressionData[] { }, "string"); var generated = _codeGeneratorManager.GenerateStackDump(stackObject); generated.Should().Be("var testString = \" sdasd \\\\ \\\\ \\\\ \\\"test\\\" asdasd ' asd\";\n"); }
public void ShouldGenerate_CharacterWithApostrophe() { var stackObject = new ExpressionData("char", "'\\''", "testString", new ExpressionData[] { }, "char"); var generated = _codeGeneratorManager.GenerateStackDump(stackObject); generated.Should().Be("var testString = \'\\\'\';\n"); }
/// <summary> /// Creates the child context. /// </summary> /// <param name="childContext">The new child context element.</param> /// <returns>The created child context.</returns> public PageBuilderContext CreateChildContext(ExpressionData childContext) { return(new PageBuilderContext(this.Browser, this.Document, childContext) { CurrentElement = null, RootLocator = this.RootLocator ?? this.ParentElement }); }
public void ShouldGenerate_SimpleStringAssignment() { var stackObject = new ExpressionData("string", "10", "testString", new ExpressionData[] { }, "string"); var generated = _codeGeneratorManager.GenerateStackDump(stackObject); generated.Should().Be("var testString = \"10\";\n"); }
public void ShouldGenerate_SimpleBoolAssignment() { var stackObject = new ExpressionData("bool", "true", "testBool", new ExpressionData[] { }, "bool"); var generated = _codeGeneratorManager.GenerateStackDump(stackObject); generated.Should().Be("var testBool = true;\n"); }
public void ShouldGenerate_SimpleIntAssignment() { var stackObject = new ExpressionData("int", "10", "testInt", new ExpressionData[] { }, "int"); var generated = _codeGeneratorManager.GenerateStackDump(stackObject); generated.Should().Be("var testInt = 10;\n"); }
/// <summary> /// Creates the child context. /// </summary> /// <param name="childContext">The new child context element.</param> /// <returns>The created child context.</returns> public PageBuilderContext CreateChildContext(ExpressionData childContext) { return new PageBuilderContext(this.Browser, this.Document, childContext) { CurrentElement = null, RootLocator = this.RootLocator ?? this.ParentElement }; }
private static ExpressionData GetExpressionDataForDictionary(ExpressionData expressionData, string keyOrValueName) { if (expressionData.UnderlyingExpressionData.Count == 0) { return(null); } return(expressionData.UnderlyingExpressionData.First(x => x.Name == keyOrValueName)); }
/// <summary> /// Creates the child context. /// </summary> /// <param name="childContext">The new child context element.</param> /// <returns>The created child context.</returns> public ControlBuilderContext CreateChildContext(ExpressionData childContext) { return(new ControlBuilderContext(this.Application, this.Window, childContext) { CurrentControl = null, RootLocator = this.RootLocator ?? this.ParentControl }); }
public void TestExpressionDataWhenConstructedReturnsTheConstructedValues() { var expression = Expression.Constant(null, typeof(object)); var expressionData = new ExpressionData(expression, expression.Type); Assert.AreSame(expression, expressionData.Expression); Assert.AreEqual(typeof(object), expressionData.Type); }
public void ShouldGenerate_Enum() { var stackObject = new ExpressionData("TestEnum", "One", "objectOnStack", new List <ExpressionData>() { }, "ConsoleApp1.Program.TestEnum"); var generated = _codeGeneratorManager.GenerateStackDump(stackObject); generated.Should().Be("var objectOnStack = TestEnum.One;\n"); }
public void ShouldGenerate_NullabeIntAssignment() { var stackObject = new ExpressionData("int?", "10", "testNullable", new List <ExpressionData>() { }, "int?"); var generated = _codeGeneratorManager.GenerateStackDump(stackObject); generated.Should().Be("var testNullable = new Nullable<int>(10);\n"); }
public void ShouldGenerate_ComplexObjectAssignment_WithList() { var stackObject = new ExpressionData("List<Test>", "Count = 3", "test123", new List <ExpressionData>() { new ExpressionData("Test", "{ConsoleApp1.Program.Test}", "[0]", new List <ExpressionData>() { new ExpressionData("decimal?", "106", "TestDecimal", new List <ExpressionData>() { }, "decimal?"), new ExpressionData("int", "102", "TestInt", new List <ExpressionData>() { }, "int"), new ExpressionData("int?", "28", "TestNullableInt", new List <ExpressionData>() { }, "int?"), new ExpressionData("string", "TestStringb4073650-af31-47a3-a64e-8555da37ff9a", "TestString", new List <ExpressionData>() { }, "string") }, "ConsoleApp1.Program.Test"), new ExpressionData("Test", "{ConsoleApp1.Program.Test}", "[1]", new List <ExpressionData>() { new ExpressionData("decimal?", "145", "TestDecimal", new List <ExpressionData>() { }, "decimal?"), new ExpressionData("int", "50", "TestInt", new List <ExpressionData>() { }, "int"), new ExpressionData("int?", "25", "TestNullableInt", new List <ExpressionData>() { }, "int?"), new ExpressionData("string", "TestString76a1d3c9-0bb9-4651-9b2d-68363f96ddda", "TestString", new List <ExpressionData>() { }, "string") }, "ConsoleApp1.Program.Test"), new ExpressionData("Test", "{ConsoleApp1.Program.Test}", "[2]", new List <ExpressionData>() { new ExpressionData("decimal?", "120", "TestDecimal", new List <ExpressionData>() { }, "decimal?"), new ExpressionData("int", "11", "TestInt", new List <ExpressionData>() { }, "int"), new ExpressionData("int?", "136", "TestNullableInt", new List <ExpressionData>() { }, "int?"), new ExpressionData("string", "TestString1c8653d0-62d2-4a99-a087-3a21d49764b4", "TestString", new List <ExpressionData>() { }, "string") }, "ConsoleApp1.Program.Test") }, "System.Collections.Generic.List<ConsoleApp1.Program.Test>"); var generated = _codeGeneratorManager.GenerateStackDump(stackObject); generated.Should().Be("var test123 = new List<Test>()\n{\r\n new Test()\r\n {\r\n TestDecimal = 106M,\r\n TestInt = 102,\r\n TestNullableInt = 28,\r\n TestString = \"TestStringb4073650-af31-47a3-a64e-8555da37ff9a\"\r\n },\r\n new Test()\r\n {\r\n TestDecimal = 145M,\r\n TestInt = 50,\r\n TestNullableInt = 25,\r\n TestString = \"TestString76a1d3c9-0bb9-4651-9b2d-68363f96ddda\"\r\n },\r\n new Test()\r\n {\r\n TestDecimal = 120M,\r\n TestInt = 11,\r\n TestNullableInt = 136,\r\n TestString = \"TestString1c8653d0-62d2-4a99-a087-3a21d49764b4\"\r\n }\r\n};\n"); }
public (SeparatedSyntaxList <ExpressionSyntax> generatedSyntax, List <ExpressionSyntax> argumentSyntax) Generate(ExpressionData expressionData) { var newExpressionData = new ExpressionData(expressionData.Type, expressionData.Value, expressionData.Name, null, expressionData.TypeWithNamespace); var regexPattern = _primitiveExpressionGenerator.Generate(TypeCode.String, expressionData.Value.Trim('{', '}').Replace("\\\\", "\\")); var generated = _complexTypeInitializationGenerator.Generate(newExpressionData, new SeparatedSyntaxList <ExpressionSyntax>()); return(new SeparatedSyntaxList <ExpressionSyntax>().Add(generated), new List <ExpressionSyntax> { regexPattern }); }
public void ShouldGenerate_NullabeBoolAssignment() { var stackObject = new ExpressionData("bool?", "true", "nullablebool", new List <ExpressionData>() { }, "bool?"); var generated = _codeGeneratorManager.GenerateStackDump(stackObject); generated.Should().Be("var nullablebool = new Nullable<bool>(true);\n"); }
internal static CompiledTemplate FromBlockNode(string templateName, JinjaEnvironment environment, BlockNode blockNode, IDictionary <string, object?> variableTemplate) { var rootScope = CompiledScope.CreateRootScope("GLOBALS", variableTemplate); #if DEBUG var expr = NewASTCompiler.ToExpression(templateName, environment, blockNode, out var newcompiler, rootScope); return(new CompiledTemplate(environment, ExpressionData.CreateCompiled(expr, rootScope), blockNode.Name, null)); #else throw new NotImplementedException(); #endif }
public ExpressionSyntax Generate(ExpressionData expressionData, List <ExpressionSyntax> constructorArguments) { return(SyntaxFactory.ObjectCreationExpression( SyntaxFactory.IdentifierName(expressionData.Type)) .WithNewKeyword( SyntaxFactory.Token( SyntaxFactory.TriviaList(), SyntaxKind.NewKeyword, SyntaxFactory.TriviaList( SyntaxFactory.Space))) .WithArgumentList(GenerateArgumentListSyntaxWithCommas(constructorArguments))); }
//internal static Template LoadTemplate(JinjaEnvironment environment, string templateText, IDictionary<string, object?> variableTemplate, string? templateName, string? templatePath) //{ // var expr = ToExpression(environment, templateText, variableTemplate, out var compiler); // return new Template(environment, compiler.Compile(expr), templateName, templatePath); //} internal static Template LoadTemplate(JinjaEnvironment environment, string templateText, IScope scope, string?templateName, string?templatePath) { var expr = ToExpression(templateName, environment, templateText, scope); var debug = expr.ToString("C#"); var test = new VariableSetterWalker(); var x = test.Visit(expr); ; return(new Template(environment, ExpressionData.CreateCompiled(expr, scope), templateName, templatePath)); }
public void ShouldGenerate_DateTime() { var dateTime = new ExpressionData("DateTime", "{10.10.0010 10:10:10}", "Date", new List <ExpressionData>() { new ExpressionData("int", "10", "Day", new List <ExpressionData>() { }, "int"), new ExpressionData("DayOfWeek", "Sunday", "DayOfWeek", new List <ExpressionData>() { }, "System.DayOfWeek"), new ExpressionData("int", "283", "DayOfYear", new List <ExpressionData>() { }, "int"), new ExpressionData("int", "10", "Hour", new List <ExpressionData>() { }, "int"), new ExpressionData("ulong", "0", "InternalKind", new List <ExpressionData>() { }, "ulong"), new ExpressionData("long", "3083982100000000", "InternalTicks", new List <ExpressionData>() { }, "long"), new ExpressionData("DateTimeKind", "Unspecified", "Kind", new List <ExpressionData>() { }, "System.DateTimeKind"), new ExpressionData("int", "0", "Millisecond", new List <ExpressionData>() { }, "int"), new ExpressionData("int", "10", "Minute", new List <ExpressionData>() { }, "int"), new ExpressionData("int", "10", "Month", new List <ExpressionData>() { }, "int"), new ExpressionData("int", "10", "Second", new List <ExpressionData>() { }, "int"), new ExpressionData("long", "3083982100000000", "Ticks", new List <ExpressionData>() { }, "long"), new ExpressionData("int", "10", "Year", new List <ExpressionData>() { }, "int"), new ExpressionData("ulong", "3083982100000000", "_dateData", new List <ExpressionData>() { }, "ulong") }, "System.DateTime"); var generated = _codeGeneratorManager.GenerateStackDump(dateTime); generated.Should().Be("var Date = new DateTime(10, 10, 10, 10, 10, 10, 0, DateTimeKind.Unspecified);\n"); }
/// <summary> /// Initializes a new instance of the <see cref="PageBuilderContext" /> class. /// </summary> /// <param name="browser">The browser.</param> /// <param name="parentElement">The parent element.</param> /// <param name="document">The document.</param> public PageBuilderContext(ExpressionData browser, ExpressionData parentElement, ExpressionData document) { this.Browser = browser; this.Document = document; this.ParentElement = parentElement; }