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;
}
