public ExpressionParserTests()
{
_dynamicTypeProviderMock = new Mock <IDynamicLinkCustomTypeProvider>();
_dynamicTypeProviderMock.Setup(dt => dt.GetCustomTypes()).Returns(new HashSet <Type>()
{
typeof(Company), typeof(MainCompany)
});
_dynamicTypeProviderMock.Setup(dt => dt.ResolveType(typeof(Company).FullName)).Returns(typeof(Company));
_dynamicTypeProviderMock.Setup(dt => dt.ResolveType(typeof(MainCompany).FullName)).Returns(typeof(MainCompany));
_dynamicTypeProviderMock.Setup(dt => dt.ResolveTypeBySimpleName("Company")).Returns(typeof(Company));
_dynamicTypeProviderMock.Setup(dt => dt.ResolveTypeBySimpleName("MainCompany")).Returns(typeof(MainCompany));
_parsingConfig = new ParsingConfig
{
CustomTypeProvider = _dynamicTypeProviderMock.Object
};
}
internal override Expression <Func <RuleInput, RuleResultTree> > BuildExpressionForRule(Rule rule, IEnumerable <ParameterExpression> typeParamExpressions, ParameterExpression ruleInputExp)
{
try
{
var config = new ParsingConfig {
CustomTypeProvider = new CustomTypeProvider(_reSettings.CustomTypes)
};
var e = DynamicExpressionParser.ParseLambda(config, typeParamExpressions.ToArray(), null, rule.Expression);
var body = (BinaryExpression)e.Body;
return(Helpers.ToResultTreeExpression(rule, null, body, typeParamExpressions, ruleInputExp));
}
catch (Exception ex)
{
var binaryExpression = Expression.And(Expression.Constant(true), Expression.Constant(false));
var exceptionMessage = ex.Message;
return(Helpers.ToResultTreeExpression(rule, null, binaryExpression, typeParamExpressions, ruleInputExp, exceptionMessage));
}
}
public void FilterByNullableLocalDate_WithDynamicExpressionParser_CompareWithNull(string equal, int numberOfEntities)
{
// Arrange
var config = new ParsingConfig
{
TypeConverters = new Dictionary <Type, TypeConverter>
{
{ typeof(LocalDate), new LocalDateConverter() }
}
};
// Act
var expr = DynamicExpressionParser.ParseLambda <Entity, bool>(config, false, $"BirthDateNullable {equal}");
var result = entities.AsQueryable().Where(expr).ToList();
// Assert
result.Should().HaveCount(numberOfEntities);
}
public void ExpressionHelper_TryGenerateAndAlsoNotNullExpression_Nested3NonNullable_Config_Has_UseDefault()
{
// Assign
var config = new ParsingConfig
{
NullPropagatingUseDefaultValueForNonNullableValueTypes = true
};
var expressionHelper = new ExpressionHelper(config);
Expression <Func <Item, int> > expression = x => x.Relation1.Relation2.Id;
// Act
bool result = expressionHelper.TryGenerateAndAlsoNotNullExpression(expression, true, out Expression generatedExpression);
// Assert
Check.That(result).IsTrue();
Check.That(generatedExpression.ToString()).IsEqualTo("((((x != null) AndAlso (x.Relation1 != null)) AndAlso (x.Relation1.Relation2 != null)) AndAlso (x => x.Relation1.Relation2.Id != null))");
}
public void Entities_Select_BrokenObject()
{
ParsingConfig config = ParsingConfig.Default;
config.DisableMemberAccessToIndexAccessorFallback = false;
// Silently creates something that will later fail on materialization
var test = _context.Blogs.Select(config, "new(~.BlogId)");
test = test.Select(config, "new(nonexistentproperty as howcanthiswork)");
// Will fail when creating the expression
config.DisableMemberAccessToIndexAccessorFallback = true;
Assert.ThrowsAny <ParseException>(() =>
{
test = test.Select(config, "new(nonexistentproperty as howcanthiswork)");
});
}
/// <summary>
/// Using a hack data source, query with custom types
/// </summary>
static void TestUnit3()
{
var data = new TestData();
var dataSource = new BlackBoxDataSource <Person>();
dataSource.DataSource = data.Persons;
dataSource.Where = @"Regex.IsMatch(Name,""^(?i)bob(by)?$"") and Id > 3";
var config = new ParsingConfig {
CustomTypeProvider = new DynamicLinqTypeProvider()
};
var result = dataSource.Select(config);
Console.WriteLine(SerializeObject(result));
}
public void DynamicExpressionParser_ParseLambda_UseParameterizedNamesInDynamicQuery_true()
{
// Assign
var config = new ParsingConfig
{
UseParameterizedNamesInDynamicQuery = true
};
// Act
var expression = DynamicExpressionParser.ParseLambda <string, bool>(config, true, "s => s == \"x\"");
// Assert
dynamic constantExpression = ((MemberExpression)(expression.Body as BinaryExpression).Right).Expression as ConstantExpression;
dynamic wrappedObj = constantExpression.Value;
string value = wrappedObj.Value;
Check.That(value).IsEqualTo("x");
}
public void FilterByLocalDate_WithDynamicExpressionParser()
{
// Arrange
var config = new ParsingConfig
{
TypeConverters = new Dictionary <Type, TypeConverter>
{
{ typeof(LocalDate), new LocalDateConverter() }
}
};
// Act
var expr = DynamicExpressionParser.ParseLambda <Entity, bool>(config, false, "BirthDate == @0", "1987-10-12");
var result = entities.AsQueryable().Where(expr).ToList();
// Assert
Assert.Single(result);
}
public void GetConverter_WithCustomConverer_ReturnsCorrectTypeConverter(Type type, Type expected)
{
// Arrange
var parsingConfig = new ParsingConfig
{
TypeConverters = new Dictionary <Type, TypeConverter>
{
{ typeof(LocalDate), new LocalDateConverter() }
}
};
var factory = new TypeConverterFactory(parsingConfig);
// Act
var typeConverter = factory.GetConverter(type);
// Assert
typeConverter.Should().BeOfType(expected);
}
public void ParseLambda_CustomMethod()
{
// Assign
var config = new ParsingConfig
{
CustomTypeProvider = new TestCustomTypeProvider()
};
var context = new CustomClassWithStaticMethod();
string expression = $"{nameof(CustomClassWithStaticMethod)}.{nameof(CustomClassWithStaticMethod.GetAge)}(10)";
// Act
var lambdaExpression = DynamicExpressionParser.ParseLambda(config, typeof(CustomClassWithStaticMethod), null, expression);
Delegate del = lambdaExpression.Compile();
int result = (int)del.DynamicInvoke(context);
// Assert
Check.That(result).IsEqualTo(10);
}
public void ExpressionHelper_WrapNullableConstantExpression_false()
{
// Assign
var config = new ParsingConfig
{
UseParameterizedNamesInDynamicQuery = false
};
var expressionHelper = new ExpressionHelper(config);
int? value = 42;
Expression expression = Expression.Constant(value);
// Act
expressionHelper.WrapConstantExpression(ref expression);
// Assert
Check.That(expression).IsInstanceOf <ConstantExpression>();
Check.That(expression.ToString()).Equals("42");
}
public void EvalDictionaryParams2()
{
object CreateDicParameter(string name) => new Dictionary <string, object>
{
{ "Name", new Dictionary <string, object> {
{ "FirstName", name }
} }
};
var config = new ParsingConfig()
{
CustomTypeProvider = new DefaultDynamicLinqCustomTypeProvider()
};
var parType = new Dictionary <string, object>().GetType();
var lambda = DynamicExpressionParser.ParseLambda(config, new [] { Expression.Parameter(parType, "item") }, typeof(object), "item.Name.FirstName").Compile();
lambda.DynamicInvoke(CreateDicParameter("Julio")).Should().Be("Julio");
lambda.DynamicInvoke(CreateDicParameter("John")).Should().Be("John");
}
/// <summary>
/// Simple example of parsing a dynamic expression with custom types.
/// </summary>
static void TestUnit1()
{
var data = new TestData();
var config = new ParsingConfig {
CustomTypeProvider = new DynamicLinqTypeProvider()
};
const string exp = @"Regex.IsMatch(Name,""^(?i)bob(by)?$"") and Id > 3";
//Note that since we do not have a data source, dynamic linq makes this first WHERE parameter the IT instance
var p = Expression.Parameter(typeof(Person), "bob");
var e = DynamicExpressionParser.ParseLambda(config, new ParameterExpression[] { p }, typeof(bool), exp);
var result = e.Compile().DynamicInvoke(data.Bob);
Console.WriteLine(SerializeObject(result));
}
public void DynamicExpressionParser_ParseLambda_ActionDelegate_VoidMethodCallExpression()
{
// Arrange
var dataSource = new MyClass();
var expressionText = "it.Bar()";
var parsingConfig = new ParsingConfig {
CustomTypeProvider = new MyClassCustomTypeProvider()
};
dataSource.Name.Should().BeNull();
// Act
LambdaExpression expression = DynamicExpressionParser.ParseLambda(typeof(Action <MyClass>), parsingConfig, dataSource.GetType(), null, expressionText);
Delegate del = expression.Compile();
del.DynamicInvoke(dataSource);
// Assert
dataSource.Name.Should().NotBeNullOrEmpty();
}
public void DynamicExpressionParser_ParseLambda_UseParameterizedNamesInDynamicQuery_true()
{
// Assign
var config = new ParsingConfig
{
UseParameterizedNamesInDynamicQuery = true
};
// Act
var expression = DynamicExpressionParser.ParseLambda <string, bool>(config, true, "s => s == \"x\"");
// Assert
dynamic constantExpression = ((MemberExpression)(expression.Body as BinaryExpression).Right).Expression as ConstantExpression;
dynamic wrappedObj = constantExpression.Value;
var propertyInfo = wrappedObj.GetType().GetProperty("Value", BindingFlags.Instance | BindingFlags.Public);
string value = propertyInfo.GetValue(wrappedObj) as string;
Check.That(value).IsEqualTo("x");
}
public void Where_Dynamic_DateTimeIsParsedAsUTC(string time, int hours)
{
// Arrange
var queryable = new List <Example> {
new Example
{
TimeNull = new DateTime(2019, 5, 10, hours, 3, 17, DateTimeKind.Utc)
}
}.AsQueryable();
// Act
var parsingConfig = new ParsingConfig
{
DateTimeIsParsedAsUTC = true
};
var result = queryable.Where(parsingConfig, $"it.TimeNull >= \"{time}\"");
// Assert
Assert.Equal(1, result.Count());
}
public void Select_Dynamic_IntoTypeWithNullableProperties2()
{
// Arrange
var dates = Enumerable.Repeat(0, 7)
.Select((d, i) => new DateTime(2000, 1, 1).AddDays(i).AddSeconds(i))
.AsQueryable();
var config = new ParsingConfig {
SupportEnumerationsFromSystemNamespace = false
};
// Act
IQueryable <ExampleWithConstructor> result = dates
.Select(d => new ExampleWithConstructor(d, d.DayOfWeek, d.DayOfWeek, d.Second, d.Second));
IQueryable <ExampleWithConstructor> resultDynamic = dates
.Select <ExampleWithConstructor>(config, "new (it as Time, DayOfWeek as DOWNull, DayOfWeek as DOW, Second as Sec, int?(Second) as SecNull)");
// Assert
Check.That(resultDynamic.First()).Equals(result.First());
Check.That(resultDynamic.Last()).Equals(result.Last());
}
public void ExpressionHelper_WrapNullableConstantExpression_true()
{
// Assign
var config = new ParsingConfig
{
UseParameterizedNamesInDynamicQuery = true
};
var expressionHelper = new ExpressionHelper(config);
int? value = 42;
Expression expression = Expression.Constant(value);
// Act
expressionHelper.WrapConstantExpression(ref expression);
expressionHelper.WrapConstantExpression(ref expression);
// Assert
Check.That(expression.GetType().FullName).Equals("System.Linq.Expressions.PropertyExpression");
Check.That(expression.ToString()).Equals("value(System.Linq.Dynamic.Core.Parser.WrappedValue`1[System.Int32]).Value");
}
public KeywordsHelper(ParsingConfig config)
{
if (config.AreContextKeywordsEnabled)
{
_keywords.Add(KEYWORD_IT, KEYWORD_IT);
_keywords.Add(KEYWORD_PARENT, KEYWORD_PARENT);
_keywords.Add(KEYWORD_ROOT, KEYWORD_ROOT);
}
_keywords.Add(SYMBOL_IT, SYMBOL_IT);
_keywords.Add(SYMBOL_PARENT, SYMBOL_PARENT);
_keywords.Add(SYMBOL_ROOT, SYMBOL_ROOT);
_keywords.Add(FUNCTION_IIF, FUNCTION_IIF);
_keywords.Add(FUNCTION_ISNULL, FUNCTION_ISNULL);
_keywords.Add(FUNCTION_NEW, FUNCTION_NEW);
_keywords.Add(FUNCTION_NULLPROPAGATION, FUNCTION_NULLPROPAGATION);
_keywords.Add(FUNCTION_IS, FUNCTION_IS);
_keywords.Add(FUNCTION_AS, FUNCTION_AS);
_keywords.Add(FUNCTION_CAST, FUNCTION_CAST);
foreach (Type type in PredefinedTypesHelper.PredefinedTypes.OrderBy(kvp => kvp.Value).Select(kvp => kvp.Key))
{
_keywords[type.FullName] = type;
_keywords[type.Name] = type;
}
foreach (KeyValuePair <string, Type> pair in PredefinedTypesHelper.PredefinedTypesShorthands)
{
_keywords.Add(pair.Key, pair.Value);
}
if (config.CustomTypeProvider != null)
{
foreach (Type type in config.CustomTypeProvider.GetCustomTypes())
{
_keywords[type.FullName] = type;
_keywords[type.Name] = type;
}
}
}
internal override RuleFunc <RuleResultTree> BuildExpressionForRule(Rule rule, IEnumerable <ParameterExpression> typeParamExpressions)
{
try
{
var config = new ParsingConfig {
CustomTypeProvider = new CustomTypeProvider(_reSettings.CustomTypes)
};
var e = DynamicExpressionParser.ParseLambda(config, true, typeParamExpressions.ToArray(), typeof(bool), rule.Expression);
var ruleDelegate = e.Compile();
bool func(object[] paramList) => (bool)ruleDelegate.DynamicInvoke(paramList);
return(Helpers.ToResultTree(rule, null, func));
}
catch (Exception ex)
{
bool func(object[] param) => false;
var exceptionMessage = ex.Message;
return(Helpers.ToResultTree(rule, null, func, exceptionMessage));
}
}
public void ParseLambda_CustomMethod()
{
var config = new ParsingConfig
{
CustomTypeProvider = new TestCustomTypeProvider()
};
var context = new CustomClassWithStaticMethod();
var original = $"{nameof(CustomClassWithStaticMethod)}.{nameof(CustomClassWithStaticMethod.GetAge)}(10)";
int result = 0;
Check.ThatCode(() =>
{
var expression = System.Linq.Dynamic.Core.DynamicExpressionParser.ParseLambda(config, typeof(CustomClassWithStaticMethod), null, original);
Delegate del = expression.Compile();
result = (int)del.DynamicInvoke(context);
})
.DoesNotThrow();
Check.That(result).IsEqualTo(10);
}
public void Select_Dynamic_IntoKnownNestedType()
{
var config = new ParsingConfig {
AllowNewToEvaluateAnyType = true
};
#if NETCOREAPP
// config.CustomTypeProvider = new NetStandardCustomTypeProvider();
#endif
// Assign
var queryable = new List <string>()
{
"name1", "name2"
}.AsQueryable();
// Act
var projectedData = queryable.Select <Example.NestedDto>(config, $"new {typeof(Example.NestedDto).FullName}(~ as Name)");
// Assert
Check.That(projectedData.First().Name).Equals("name1");
Check.That(projectedData.Last().Name).Equals("name2");
}
public void DynamicExpressionParser_ParseLambda_UseParameterizedNamesInDynamicQuery_true()
{
// Assign
var config = new ParsingConfig
{
UseParameterizedNamesInDynamicQuery = true
};
// Act
var expression = DynamicExpressionParser.ParseLambda <Person, bool>(config, false, "Id = 42");
string expressionAsString = expression.ToString();
// Assert
Check.That(expressionAsString).IsEqualTo("Param_0 => (Param_0.Id == value(System.Linq.Dynamic.Core.Parser.WrappedValue`1[System.Int32]).Value)");
dynamic constantExpression = ((MemberExpression)(expression.Body as BinaryExpression).Right).Expression as ConstantExpression;
dynamic wrappedObj = constantExpression.Value;
var propertyInfo = wrappedObj.GetType().GetProperty("Value", BindingFlags.Instance | BindingFlags.Public);
int value = (int)propertyInfo.GetValue(wrappedObj);
Check.That(value).IsEqualTo(42);
}
private static void QueryCollection(Uri collectionUri, ParsingConfig config, string configName, string predicate, object[] parameters, string successOrFailure)
{
try
{
IQueryable <Entity> entities = _Client.CreateDocumentQuery <Entity>(collectionUri);
IQueryable <Entity> results = entities.Where(config, predicate, parameters);
string querySqlJson = results.AsDocumentQuery().ToString();
JObject querySqlJsonObject = JObject.Parse(querySqlJson);
string querySql = (string)querySqlJsonObject["query"];
Console.WriteLine($"Config {configName} produces the following SQL:");
Console.WriteLine();
Console.WriteLine($"**** {querySql} ****");
Console.WriteLine();
Console.WriteLine($"This request will {successOrFailure}");
Console.WriteLine();
var querySqlSpec = new SqlQuerySpec(querySql);
results = _Client.CreateDocumentQuery <Entity>(collectionUri, querySqlSpec, new FeedOptions()
{
EnableCrossPartitionQuery = true
});
IList <Entity> output = results.ToList();
Console.WriteLine($"Successfully returned {output.Count} entities");
Console.WriteLine();
}
catch (Exception ex)
{
Console.WriteLine($"Exception thrown: {ex.Message}");
Console.WriteLine();
}
Console.WriteLine();
}
public static void Execute()
{
var externals = new Dictionary <string, object>
{
{ "Users", false },
{ "x", new[] { "a", "b", "c" } },
{ "y", 2 },
};
//var t1 = Utils.ConvertToArray(null);
//string query = "Utils.ConvertToArray()";
//LambdaExpression expression = DynamicExpressionParser.ParseLambda(null, query, externals);
//Delegate del = expression.Compile();
//var result = del.DynamicInvoke();
var config = new ParsingConfig();
var list = new[] { new X {
}, new X {
Values = new[] { "a", "b" }
} }.AsQueryable();
var result = list.Select("Utils.ConvertToArray(Values)").ToDynamicList <string[]>();
}
/// <summary>
///
/// </summary>
public static void AssertExpTextCanBeConvertedToLambda <TResult>(
this ExpressionText expText)
{
ParsingConfig pc = ParsingConfig.Default;
pc.AllowNewToEvaluateAnyType = true;
pc.CustomTypeProvider = new CustomTypeProvider();
// Build the parameters...
List <ParameterExpression> parameters = new List <ParameterExpression>();
foreach (var p in expText.Parameters2.Values)
{
parameters.Add(p);
}
DynamicExpressionParser.ParseLambda(
pc,
true,
parameters.ToArray(),
typeof(TResult),
expText.Expression,
new object[] { expText.Arguments });
}
public void Is_Dynamic_ActingOnIt_WithSimpleName()
{
// Assign
var config = new ParsingConfig
{
ResolveTypesBySimpleName = true
};
var qry = new BaseEmployee[]
{
new Worker {
Name = "1"
}, new Boss {
Name = "b"
}
}.AsQueryable();
// Act
int countOfType = qry.Count(c => c is Worker);
int countOfTypeDynamic = qry.Count(config, "is(\"Worker\")");
// Assert
Check.That(countOfTypeDynamic).Equals(countOfType);
}
public ProjectCommitParser(ParsingConfig parsingConfig) : base(parsingConfig)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="NumberParser"/> class.
/// </summary>
/// <param name="config">The ParsingConfig.</param>
public NumberParser(ParsingConfig config)
{
_config = config;
}
internal ExpressionHelper([NotNull] ParsingConfig parsingConfig)
{
Check.NotNull(parsingConfig, nameof(parsingConfig));
_parsingConfig = parsingConfig;
}
