private static MemberDeclarationSyntax CreateClass(string name, IndexDefinition definition)
{
var statements = new List <StatementSyntax>();
var maps = definition.Maps.ToList();
var fieldNamesValidator = new FieldNamesValidator();
var methodDetector = new MethodDetectorRewriter();
var members = new SyntaxList <MemberDeclarationSyntax>();
for (var i = 0; i < maps.Count; i++)
{
var map = maps[i];
statements.AddRange(HandleMap(map, fieldNamesValidator, methodDetector, ref members));
}
if (string.IsNullOrWhiteSpace(definition.Reduce) == false)
{
statements.Add(HandleReduce(definition.Reduce, fieldNamesValidator, methodDetector, out string[] groupByFields));
var groupByFieldsArray = GetArrayCreationExpression(groupByFields);
statements.Add(RoslynHelper.This(nameof(StaticIndexBase.GroupByFields)).Assign(groupByFieldsArray).AsExpressionStatement());
}
var fields = GetIndexedFields(definition, fieldNamesValidator);
var outputFieldsArray = GetArrayCreationExpression(fields);
statements.Add(RoslynHelper.This(nameof(StaticIndexBase.OutputFields)).Assign(outputFieldsArray).AsExpressionStatement());
var methods = methodDetector.Methods;
if (methods.HasCreateField)
{
statements.Add(RoslynHelper.This(nameof(StaticIndexBase.HasDynamicFields)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement());
}
if (methods.HasBoost)
{
statements.Add(RoslynHelper.This(nameof(StaticIndexBase.HasBoostedFields)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement());
}
var ctor = RoslynHelper.PublicCtor(name)
.AddBodyStatements(statements.ToArray());
return(RoslynHelper.PublicClass(name)
.WithBaseClass <StaticIndexBase>()
.WithMembers(members.Add(ctor)));
}
private static MemberDeclarationSyntax CreateClass(string name, TransformerDefinition definition)
{
var statements = new List <StatementSyntax>();
var methodDetector = new MethodDetectorRewriter();
statements.Add(HandleTransformResults(definition.TransformResults, methodDetector));
var methods = methodDetector.Methods;
if (methods.HasGroupBy)
{
statements.Add(RoslynHelper.This(nameof(TransformerBase.HasGroupBy)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement());
}
if (methods.HasLoadDocument)
{
statements.Add(RoslynHelper.This(nameof(TransformerBase.HasLoadDocument)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement());
}
if (methods.HasTransformWith)
{
statements.Add(RoslynHelper.This(nameof(TransformerBase.HasTransformWith)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement());
}
if (methods.HasInclude)
{
statements.Add(RoslynHelper.This(nameof(TransformerBase.HasInclude)).Assign(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)).AsExpressionStatement());
}
var ctor = RoslynHelper.PublicCtor(name).AddBodyStatements(statements.ToArray());
return(RoslynHelper.PublicClass(name)
.WithBaseClass <TransformerBase>()
.WithMembers(SyntaxFactory.SingletonList <MemberDeclarationSyntax>(ctor)));
}
private static StatementSyntax HandleReduce(string reduce, FieldNamesValidator fieldNamesValidator, MethodDetectorRewriter methodsDetector, out string[] groupByFields)
{
try
{
reduce = NormalizeFunction(reduce);
var expression = SyntaxFactory.ParseExpression(reduce).NormalizeWhitespace();
fieldNamesValidator?.Validate(reduce, expression);
methodsDetector.Visit(expression);
StatementSyntax result;
switch (expression)
{
case QueryExpressionSyntax queryExpression:
result = HandleSyntaxInReduce(
new ReduceFunctionProcessor(
ResultsVariableNameRewriter.QuerySyntax,
GroupByFieldsRetriever.QuerySyntax,
SelectManyRewriter.QuerySyntax),
MethodsInGroupByValidator.QuerySyntaxValidator,
queryExpression, out groupByFields);
break;
case InvocationExpressionSyntax invocationExpression:
result = HandleSyntaxInReduce(
new ReduceFunctionProcessor(
ResultsVariableNameRewriter.MethodSyntax,
GroupByFieldsRetriever.MethodSyntax,
SelectManyRewriter.MethodSyntax),
MethodsInGroupByValidator.MethodSyntaxValidator,
invocationExpression, out groupByFields);
break;
default:
throw new InvalidOperationException("Not supported expression type.");
}
foreach (var groupByField in groupByFields)
{
if (fieldNamesValidator?.Fields.Contains(groupByField) == false)
{
throw new InvalidOperationException($"Group by field '{groupByField}' was not found on the list of index fields ({string.Join(", ",fieldNamesValidator.Fields)})");
}
}
return(result);
}
catch (Exception ex)
{
throw new IndexCompilationException(ex.Message, ex)
{
IndexDefinitionProperty = nameof(IndexDefinition.Reduce),
ProblematicText = reduce
};
}
}
private static List <StatementSyntax> HandleMap(string map, FieldNamesValidator fieldNamesValidator, MethodDetectorRewriter methodsDetector,
ref SyntaxList <MemberDeclarationSyntax> members)
{
try
{
map = NormalizeFunction(map);
var expression = SyntaxFactory.ParseExpression(map).NormalizeWhitespace();
fieldNamesValidator.Validate(map, expression);
methodsDetector.Visit(expression);
var queryExpression = expression as QueryExpressionSyntax;
if (queryExpression != null)
{
return(HandleSyntaxInMap(fieldNamesValidator, new MapFunctionProcessor(CollectionNameRetriever.QuerySyntax, SelectManyRewriter.QuerySyntax), queryExpression, ref members));
}
var invocationExpression = expression as InvocationExpressionSyntax;
if (invocationExpression != null)
{
return(HandleSyntaxInMap(fieldNamesValidator, new MapFunctionProcessor(CollectionNameRetriever.MethodSyntax, SelectManyRewriter.MethodSyntax), invocationExpression, ref members));
}
throw new InvalidOperationException("Not supported expression type.");
}
catch (Exception ex)
{
throw new IndexCompilationException(ex.Message, ex)
{
IndexDefinitionProperty = nameof(IndexDefinition.Maps),
ProblematicText = map
};
}
}
private static StatementSyntax HandleReduce(string reduce, FieldNamesValidator fieldNamesValidator, MethodDetectorRewriter methodsDetector, out string[] groupByFields)
{
try
{
reduce = NormalizeFunction(reduce);
var expression = SyntaxFactory.ParseExpression(reduce).NormalizeWhitespace();
fieldNamesValidator?.Validate(reduce, expression);
methodsDetector.Visit(expression);
var queryExpression = expression as QueryExpressionSyntax;
if (queryExpression != null)
{
return
HandleSyntaxInReduce(
new ReduceFunctionProcessor(
ResultsVariableNameRewriter.QuerySyntax,
GroupByFieldsRetriever.QuerySyntax,
SelectManyRewriter.QuerySyntax),
MethodsInGroupByValidator.QuerySyntaxValidator,
queryExpression, out groupByFields);
}
var invocationExpression = expression as InvocationExpressionSyntax;
if (invocationExpression != null)
{
return
HandleSyntaxInReduce(
new ReduceFunctionProcessor(
ResultsVariableNameRewriter.MethodSyntax,
GroupByFieldsRetriever.MethodSyntax,
SelectManyRewriter.MethodSyntax),
MethodsInGroupByValidator.MethodSyntaxValidator,
invocationExpression, out groupByFields);
}
throw new InvalidOperationException("Not supported expression type.");
}
catch (Exception ex)
{
throw new IndexCompilationException(ex.Message, ex)
{
IndexDefinitionProperty = nameof(IndexDefinition.Reduce),
ProblematicText = reduce
};
}
}
private static StatementSyntax HandleTransformResults(string transformResults, MethodDetectorRewriter methodsDetector)
{
try
{
transformResults = NormalizeFunction(transformResults);
var expression = SyntaxFactory.ParseExpression(transformResults).NormalizeWhitespace();
methodsDetector.Visit(expression);
var queryExpression = expression as QueryExpressionSyntax;
if (queryExpression != null)
{
return(HandleSyntaxInTransformResults(new TransformFunctionProcessor(SelectManyRewriter.QuerySyntax), queryExpression));
}
var invocationExpression = expression as InvocationExpressionSyntax;
if (invocationExpression != null)
{
return(HandleSyntaxInTransformResults(new TransformFunctionProcessor(SelectManyRewriter.MethodSyntax), invocationExpression));
}
throw new InvalidOperationException("Not supported expression type.");
}
catch (Exception ex)
{
throw new IndexCompilationException(ex.Message, ex)
{
IndexDefinitionProperty = "TransformResults",
ProblematicText = transformResults
};
}
}
