internal static string SwitchCaseToString(SwitchCase node)
{
#pragma warning disable SA1405 // Debug.Assert should provide message text
Debug.Assert(node != null);
#pragma warning restore SA1405 // Debug.Assert should provide message text
ExpressionStringBuilder esb = new ExpressionStringBuilder();
#pragma warning disable IDE0058 // Expression value is never used
#pragma warning disable CS8604 // Possible null reference argument.
esb.VisitSwitchCase(node);
#pragma warning restore CS8604 // Possible null reference argument.
#pragma warning restore IDE0058 // Expression value is never used
return(esb.ToString());
}
internal static string ToStringAwesomely(this object value)
{
if (value == null)
{
return("null");
}
if (value is string)
{
return("\"" + value + "\"");
}
if (value is IEnumerable)
{
var objects = value.As <IEnumerable>().Cast <object>();
var inspect = "[" + objects.Select(o => o.ToStringAwesomely()).CommaDelimited() + "]";
if (inspect == "[]" && value.ToString() != value.GetType().FullName)
{
inspect += " (" + value + ")";
}
return(inspect);
}
if (value is Enum)
{
return(value.As <Enum>().ToStringAwesomely());
}
if (value is ConstantExpression)
{
return(value.As <ConstantExpression>().Value.ToStringAwesomely());
}
if (value is MemberExpression)
{
var member = value.As <MemberExpression>();
var constant = member.Expression.As <ConstantExpression>();
var info = member.Member.As <FieldInfo>();
return(info.GetValue(constant.Value).ToStringAwesomely());
}
if (value is BinaryExpression)
{
return(ExpressionStringBuilder.ToString(value.As <BinaryExpression>()));
}
return(value == null ? "null" : value.ToString());
}
/// <summary>
/// Perform the actual generation
/// </summary>
public static string PruneToFailureLinqQueryAsStringToWorkableCode(
LambdaExpression expr,
DocumentConvention convention,
string querySource, bool translateIdentityProperty)
{
if (expr == null)
{
return(null);
}
var expression = expr.Body;
switch (expression.NodeType)
{
case ExpressionType.ConvertChecked:
case ExpressionType.Convert:
expression = ((UnaryExpression)expression).Operand;
break;
}
#if !NET_3_5
var linqQuery = ExpressionStringBuilder.ExpressionToString(convention, translateIdentityProperty, expression);
#else
var linqQuery = expression.ToString();
#endif
var querySourceName = expr.Parameters.First(x => x.Type != typeof(IClientSideDatabase)).Name;
if (linqQuery.StartsWith(querySourceName))
{
linqQuery = querySource + linqQuery.Substring(querySourceName.Length);
}
else if (linqQuery.StartsWith("(" + querySourceName + ")"))
{
linqQuery = querySource + linqQuery.Substring(querySourceName.Length + 2);
}
else
{
throw new InvalidOperationException("Canot understand how to parse the query");
}
linqQuery = ReplaceAnonymousTypeBraces(linqQuery);
linqQuery = Regex.Replace(linqQuery, @"new ((VB\$)|(<>))[\w_]+`\d+", "new "); // remove anonymous types
linqQuery = Regex.Replace(linqQuery, @"<>([a-z])_", "__$1_"); // replace <>h_ in transperant identifiers
const string pattern = @"(\.Where\(|\.Select\(|\.GroupBy\(|\.SelectMany)";
linqQuery = Regex.Replace(linqQuery, pattern, "\r\n\t$1"); // formatting
return(linqQuery);
}
public void BuildQuery_SetValueFlagToTrue_IfPathHasValueSegment(string path, string expectedQuery)
{
var model = ODataPathQueryModel.GetModel();
var pathHandler = new DefaultODataPathHandler();
var odataPath = pathHandler.Parse(model, "http://any/", path);
IQueryable source = Array.CreateInstance(typeof(ODataPathQuery_Customer), 0).AsQueryable();
var queryBuilder = new ODataPathQueryBuilder(source, odataPath);
ODataPathQueryResult result = queryBuilder.BuildQuery();
string queryExpression = ExpressionStringBuilder.ToString(result.Result.Expression);
queryExpression = RemoveNameSpace(queryExpression);
Assert.Equal(expectedQuery, queryExpression);
Assert.True(result.HasValueSegment);
Assert.False(result.HasCountSegment);
}
private List <SelectListItem> PopulateTaskSelector(int selectedValue)
{
var items = new List <SelectListItem>();
for (var i = 0; i < TaskExpressions.Length; i++)
{
items.Add(
new SelectListItem {
Text = ExpressionStringBuilder.ToString(TaskExpressions[i]),
Value = i.ToString(),
Selected = (i == selectedValue)
}
);
}
return(items);
}
public void ApplyTo_DoesnotPickDefaultOrder_IfOrderByIsPresent(string oDataQuery, string expectedExpression)
{
var model = new ODataModelBuilder().Add_Customer_EntityType().Add_Customers_EntitySet().GetEdmModel();
var message = new HttpRequestMessage(
HttpMethod.Get,
new Uri("http://server/service/Customers?" + oDataQuery)
);
var options = new ODataQueryOptions(new ODataQueryContext(model, typeof(Customer)), message);
IQueryable finalQuery = options.ApplyTo(Customers);
string queryExpression = ExpressionStringBuilder.ToString(finalQuery.Expression);
queryExpression = queryExpression.Substring(queryExpression.IndexOf("OrderBy"));
Assert.Equal(queryExpression, expectedExpression);
}
/// <summary>
/// Perform the actual generation
/// </summary>
public static string PruneToFailureLinqQueryAsStringToWorkableCode <TQueryRoot, TReduceResult>(
LambdaExpression expr,
DocumentConventions conventions,
string querySource, bool translateIdentityProperty)
{
if (expr == null)
{
return(null);
}
var expression = expr.Body;
string queryRootName = null;
bool isReduce = false;
switch (expression.NodeType)
{
case ExpressionType.ConvertChecked:
case ExpressionType.Convert:
expression = ((UnaryExpression)expression).Operand;
break;
case ExpressionType.Call:
var methodCallExpression = GetFirstMethodCallExpression(expression);
switch (methodCallExpression.Method.Name)
{
case "Select":
queryRootName = TryCaptureQueryRoot(methodCallExpression.Arguments.FirstOrDefault(x => x.NodeType == ExpressionType.Call || x.NodeType == ExpressionType.Lambda) ?? methodCallExpression.Arguments[0]);
break;
case "SelectMany":
queryRootName = TryCaptureQueryRoot(methodCallExpression.Arguments[1]);
break;
case "GroupBy":
isReduce = true;
break;
}
break;
}
var linqQuery = ExpressionStringBuilder.ExpressionToString(conventions, translateIdentityProperty, typeof(TQueryRoot), queryRootName, expression, isReduce);
return(FormatLinqQuery(expr, querySource, linqQuery));
}
public void CreateArgumentExpression_DictionaryInterfaceGiven_ShouldReturnDictionaryCreationExpression()
{
var decimalConstantExpression = Expression.Constant(5m);
valueExpressionProvider.Stub(m => m.CreateValueExpression(typeof(decimal)))
.IgnoreArguments()
.Return(decimalConstantExpression);
var stringConstantExpression = Expression.Constant("abc");
valueExpressionProvider.Stub(m => m.CreateValueExpression(typeof(string)))
.IgnoreArguments()
.Return(stringConstantExpression);
var resultExpression = testee.CreateArgumentExpression(typeof(IDictionary <string, decimal>));
var expressionAsString = ExpressionStringBuilder.ExpressionToString(resultExpression);
expressionAsString.Should().Be(@"new Dictionary<string, decimal>()");
//expressionAsString.Should().Be(@"new Dictionary<string, decimal>(new [] {{""abc"",5},{""abc"",5}})");
}
public ModelTest <TModel> WithModel <TModel>(Expression <Func <TModel, bool> > predicate) where TModel : class
{
var test = WithModel <TModel>();
var model = _viewResult.Model as TModel;
var modelLex = Json.Encode(model);
var predicateLex = ExpressionStringBuilder.ToString(predicate);
var compiledPredicate = predicate.Compile();
if (!compiledPredicate(model))
{
throw new ViewResultModelAssertionException(string.Format(
"Expected view model {0} to pass the given condition ({1}), but it failed.",
modelLex,
predicateLex));
}
return(test);
}
public void ApplyTo_Picks_DefaultOrder(string oDataQuery, Type elementType, string expectedExpression)
{
IQueryable query = Array.CreateInstance(elementType, 0).AsQueryable();
var modelBuilder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>();
modelBuilder.AddEntitySet("entityset", modelBuilder.AddEntityType(elementType));
var model = modelBuilder.GetEdmModel();
var message = new HttpRequestMessage(
HttpMethod.Get,
new Uri("http://server/service/entityset?" + oDataQuery)
);
var options = new ODataQueryOptions(new ODataQueryContext(model, elementType), message);
IQueryable finalQuery = options.ApplyTo(query);
string queryExpression = ExpressionStringBuilder.ToString(finalQuery.Expression);
queryExpression = queryExpression.Substring(queryExpression.IndexOf("OrderBy"));
Assert.Equal(queryExpression, expectedExpression);
}
public void ApplyTo_Builds_Default_OrderBy_No_Keys(string oDataQuery, bool ensureStableOrdering, string expectedExpression)
{
var model = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>().Add_Customer_No_Keys_EntityType().Add_Customers_No_Keys_EntitySet().GetEdmModel();
var message = new HttpRequestMessage(
HttpMethod.Get,
new Uri("http://server/service/Customers?" + oDataQuery)
);
var options = new ODataQueryOptions(new ODataQueryContext(model, typeof(Customer)), message);
ODataQuerySettings querySettings = new ODataQuerySettings
{
EnsureStableOrdering = ensureStableOrdering
};
IQueryable finalQuery = options.ApplyTo(new Customer[0].AsQueryable(), querySettings);
string queryExpression = ExpressionStringBuilder.ToString(finalQuery.Expression);
queryExpression = queryExpression.Substring(queryExpression.IndexOf("]") + 2);
Assert.Equal(queryExpression, expectedExpression);
}
public IActionResult Processing()
{
var context = Hosting.GetHttpContext();
int selectedValue;
int.TryParse(context.Request["taskSelector"], out selectedValue);
var model = new ProcessingViewModel
{
ExampleFileSelector = new ExampleFileSelector
{
Id = "exampleFileSelector",
InitialFile = "JPG Image.jpg",
FormWrapped = false
},
TaskSelectList = PopulateTaskSelector(selectedValue)
};
model.ImagePath = model.ExampleFileSelector.SelectedFile;
var expression = TaskExpressions[selectedValue];
var lambda = expression.Compile();
model.TaskAction = task =>
{
task.ResizeWidth(400);
lambda(task);
};
model.CodeString = string.Format(
"@this.ImageTag(\"{0}\", {1})",
model.ExampleFileSelector.SelectedFile.FileName,
ExpressionStringBuilder.ToString(expression)
);
return(View(model));
}
protected void Page_Load(object sender, EventArgs e)
{
ImagePath = exampleFileSelector.SelectedFile;
if (!IsPostBack)
{
PopulateTaskSelector();
}
var expression = TaskExpressions[int.Parse(TaskSelector.SelectedValue)];
var lambda = expression.Compile();
TaskAction = task =>
{
task.ResizeWidth(400);
lambda(task);
};
CodeString = string.Format(
"<%=this.ImageTag(\"{0}\", {1})%>",
exampleFileSelector.SelectedFile.FileName,
ExpressionStringBuilder.ToString(expression)
);
}
public static string GetExpressionString(Expression expression)
{
var builder = new ExpressionStringBuilder();
builder.Visit(expression);
return builder.stringBuilder.ToString();
}
/// <summary>
/// Creates a <see cref="String"/> representation of the node.
/// </summary>
/// <returns>A <see cref="String"/> representation of the node.</returns>
public override string ToString()
{
return(ExpressionStringBuilder.ElementInitBindingToString(this));
}
/// <summary>
/// Returns a <see cref="String"/> that represents the current <see cref="Object"/>.
/// </summary>
/// <returns>A <see cref="String"/> that represents the current <see cref="Object"/>. </returns>
public override string ToString()
{
return(ExpressionStringBuilder.CatchBlockToString(this));
}
public void ElementInitBindingToString_NodeNullValueGiven_ShouldThrowArgumentNullException()
{
ExpressionStringBuilder.ElementInitBindingToString(null);
}
private void VerifyExpressionWithTruncate(Expression <Action> func, string expression)
{
ExpressionStringBuilder.ToString(func, trimLongArgumentList: true).ShouldBe(expression);
}
public ExpressionDefinition(Expression expression, NodeType nodeType, string nodeName, string pathOverride = null)
{
NodeType = nodeType;
NodeName = nodeName;
FullPath = pathOverride ?? ExpressionStringBuilder.ToString(expression);
}
void VerifyExpression(Expression <Action> func, string expression)
{
ExpressionStringBuilder.ToString(func).ShouldBe(expression);
}
void VerifyExpression <T>(Expression <Func <T> > func, string expression)
{
ExpressionStringBuilder.ToString(func).ShouldBe(expression);
}
/// <summary>
/// Produces string representation of <see cref="Expression"/>.
/// </summary>
/// <param name="expression">The expression to convert.</param>
/// <returns>Returns a string representation of <see cref="Expression"/>.</returns>
public string ExpressionToString(Expression expression)
{
return(ExpressionStringBuilder.ExpressionToString(expression));
}
/// <summary>
/// Returns a <see cref="String"/> that represents the current <see cref="Object"/>.
/// </summary>
/// <returns>A <see cref="String"/> that represents the current <see cref="Object"/>. </returns>
public override string ToString()
{
return(ExpressionStringBuilder.MemberBindingToString(this));
}
public void CatchBlockToString_NodeNullValueGiven_ShouldThrowArgumentNullException()
{
ExpressionStringBuilder.CatchBlockToString(null);
}
/// <summary>
/// Creates a <see cref="String"/> representation of the Expression.
/// </summary>
/// <returns>A <see cref="String"/> representation of the Expression.</returns>
public override string ToString()
{
return(ExpressionStringBuilder.ExpressionToString(this));
}
public void SwitchCaseToString_NodeNullValueGiven_ShouldThrowArgumentNullException()
{
ExpressionStringBuilder.SwitchCaseToString(null);
}
/// <summary>
/// Returns a <see cref="String"/> that represents the current <see cref="Object"/>.
/// </summary>
/// <returns>A <see cref="String"/> that represents the current <see cref="Object"/>. </returns>
public override string ToString()
{
return(ExpressionStringBuilder.SwitchCaseToString(this));
}
private void Same(Expression <Action> expression, string str)
{
Xunit.Assert.Equal(ExpressionStringBuilder.ExpressionToString(expression.Body), str);
}
