public IEnumerable <AssignmentExpressionSyntax> MapUsingSimpleAssignment(IReadOnlyCollection <IObjectField> targets,
IMappingMatcher mappingMatcher,
MappingContext mappingContext,
MappingPath mappingPath = null, SyntaxNode globalTargetAccessor = null)
{
if (mappingPath == null)
{
mappingPath = new MappingPath();
}
return(mappingMatcher.MatchAll(targets, syntaxGenerator, mappingContext, globalTargetAccessor)
.Select(match =>
{
var sourceMappingElement = MapExpression(match.Source, match.Target.ExpressionType, mappingContext, mappingPath.Clone());
var sourceExpression = sourceMappingElement.Expression;
if (sourceMappingElement.ExpressionType != match.Target.ExpressionType)
{
mappingContext.AddMissingConversion(sourceMappingElement.ExpressionType.Type, match.Target.ExpressionType.Type);
if (mappingContext.WrapInCustomConversion)
{
var customConversionMethodName = syntaxGenerator.IdentifierName($"MapFrom{sourceMappingElement.ExpressionType.Type.Name}To{match.Target.ExpressionType.Type.Name}");
sourceExpression = (ExpressionSyntax)syntaxGenerator.InvocationExpression(customConversionMethodName, sourceExpression);
}
}
return AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, match.Target.Expression, sourceExpression);
}).ToList());
}
public MappingMatcherTests()
{
_optionsMock = new Mock <IWireMockMiddlewareOptions>();
_optionsMock.SetupAllProperties();
_optionsMock.Setup(o => o.Mappings).Returns(new ConcurrentDictionary <Guid, IMapping>());
_optionsMock.Setup(o => o.LogEntries).Returns(new ConcurrentObservableCollection <LogEntry>());
_optionsMock.Setup(o => o.Scenarios).Returns(new ConcurrentDictionary <string, ScenarioState>());
_sut = new MappingMatcher(_optionsMock.Object);
}
public async Task <ObjectCreationExpressionSyntax> AddInitializerWithMappingAsync(
ObjectCreationExpressionSyntax objectCreationExpression, IMappingMatcher mappingMatcher,
ITypeSymbol createdObjectTyp,
MappingContext mappingContext,
MappingPath mappingPath = null)
{
var propertiesToSet = _mappingTargetHelper.GetFieldsThaCanBeSetPublicly(createdObjectTyp, mappingContext);
var assignments = await MapUsingSimpleAssignment(propertiesToSet, mappingMatcher, mappingContext, mappingPath).ConfigureAwait(false);
return(SyntaxFactoryExtensions.WithMembersInitialization(objectCreationExpression, assignments));
}
private static async Task<Document> ReplaceEmptyInitializationBlock(Document document,
InitializerExpressionSyntax objectInitializer, SemanticModel semanticModel,
IMappingMatcher mappingMatcher, CancellationToken cancellationToken)
{
var oldObjCreation = objectInitializer.FindContainer<ObjectCreationExpressionSyntax>();
var createdObjectType = ModelExtensions.GetTypeInfo(semanticModel, oldObjCreation).Type;
var mappingEngine = await MappingEngine.Create(document, cancellationToken);
var newObjectCreation = mappingEngine.AddInitializerWithMapping(oldObjCreation, mappingMatcher, createdObjectType, new MappingContext(objectInitializer, semanticModel ));
return await document.ReplaceNodes(oldObjCreation, newObjectCreation, cancellationToken);
}
public ObjectCreationExpressionSyntax AddInitializerWithMapping(
ObjectCreationExpressionSyntax objectCreationExpression, IMappingMatcher mappingMatcher,
ITypeSymbol createdObjectTyp,
MappingContext mappingContext,
MappingPath mappingPath = null)
{
var propertiesToSet = MappingTargetHelper.GetFieldsThaCanBeSetPublicly(createdObjectTyp, mappingContext);
var assignments = MapUsingSimpleAssignment(propertiesToSet, mappingMatcher, mappingContext, mappingPath).ToList();
return(SyntaxFactoryExtensions.WithMembersInitialization(objectCreationExpression, assignments));
}
public WireMockMiddleware(Next next, IWireMockMiddlewareOptions options, IOwinRequestMapper requestMapper, IOwinResponseMapper responseMapper, IMappingMatcher mappingMatcher)
{
Check.NotNull(options, nameof(options));
Check.NotNull(requestMapper, nameof(requestMapper));
Check.NotNull(responseMapper, nameof(responseMapper));
Check.NotNull(mappingMatcher, nameof(mappingMatcher));
_options = options;
_requestMapper = requestMapper;
_responseMapper = responseMapper;
_mappingMatcher = mappingMatcher;
}
private static async Task <Document> ReplaceEmptyInitializationBlock(Document document,
InitializerExpressionSyntax objectInitializer, SemanticModel semanticModel,
IMappingMatcher mappingMatcher, CancellationToken cancellationToken)
{
var oldObjCreation = objectInitializer.FindContainer <ObjectCreationExpressionSyntax>();
var createdObjectType = ModelExtensions.GetTypeInfo(semanticModel, oldObjCreation).Type;
var syntaxGenerator = SyntaxGenerator.GetGenerator(document);
var mappingEngine = new MappingEngine(semanticModel, syntaxGenerator);
var mappingContext = new MappingContext(objectInitializer, semanticModel);
var newObjectCreation = await mappingEngine.AddInitializerWithMappingAsync(oldObjCreation, mappingMatcher, createdObjectType, mappingContext).ConfigureAwait(false);
return(await document.ReplaceNodes(oldObjCreation, newObjectCreation, cancellationToken).ConfigureAwait(false));
}
public ObjectCreationExpressionSyntax AddInitializerWithMapping(
ObjectCreationExpressionSyntax objectCreationExpression, IMappingMatcher mappingMatcher,
ITypeSymbol createdObjectTyp,
MappingPath mappingPath = null)
{
var propertiesToSet = ObjectHelper.GetFieldsThaCanBeSetPublicly(createdObjectTyp, contextAssembly);
var assignments = MapUsingSimpleAssignment(propertiesToSet, mappingMatcher, mappingPath).ToList();
if (assignments.Count == 0)
{
return(objectCreationExpression);
}
var initializerExpressionSyntax = SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, new SeparatedSyntaxList <ExpressionSyntax>().AddRange(assignments)).FixInitializerExpressionFormatting(objectCreationExpression);
return(objectCreationExpression.WithInitializer(initializerExpressionSyntax));
}
public IEnumerable <ExpressionSyntax> MapUsingSimpleAssignment(IEnumerable <IPropertySymbol> targets, IMappingMatcher mappingMatcher,
MappingPath mappingPath = null, SyntaxNode globalTargetAccessor = null)
{
if (mappingPath == null)
{
mappingPath = new MappingPath();
}
return(mappingMatcher.MatchAll(targets, syntaxGenerator, globalTargetAccessor)
.Select(match =>
{
var sourceExpression = this.MapExpression(match.Source, match.Target.ExpressionType, mappingPath.Clone()).Expression;
return (ExpressionSyntax)syntaxGenerator.AssignmentStatement(match.Target.Expression, sourceExpression);
}).ToList());
}
private static async Task <Document> ReplaceWithMappingBody(Document document, LambdaExpressionSyntax lambda, SemanticModel semanticModel, IMappingMatcher mappingMatcher, CancellationToken cancellationToken)
{
var methodSymbol = (IMethodSymbol)semanticModel.GetSymbolInfo(lambda).Symbol;
var createdObjectType = methodSymbol.Parameters.First().Type;
var mappingEngine = await MappingEngine.Create(document, cancellationToken);
var mappingContext = new MappingContext(lambda, semanticModel);
var propertiesToSet = MappingTargetHelper.GetFieldsThaCanBeSetPublicly(createdObjectType, mappingContext);
var statements = mappingEngine.MapUsingSimpleAssignment(propertiesToSet, mappingMatcher, mappingContext, globalTargetAccessor: SyntaxFactory.IdentifierName(GetParameterIdentifier(lambda)))
.Select(x => x.AsStatement().WithTrailingTrivia(SyntaxFactory.EndOfLine("\r\n")));
var newLambda = UpdateLambdaBody(lambda, SyntaxFactory.Block(statements)).WithAdditionalAnnotations(Formatter.Annotation);
return(await document.ReplaceNodes(lambda, newLambda, cancellationToken));
}
public async Task <IReadOnlyList <AssignmentExpressionSyntax> > MapUsingSimpleAssignment(IReadOnlyCollection <IObjectField> targets,
IMappingMatcher mappingMatcher,
MappingContext mappingContext,
MappingPath mappingPath = null, SyntaxNode globalTargetAccessor = null)
{
if (mappingPath == null)
{
mappingPath = new MappingPath();
}
var results = new List <AssignmentExpressionSyntax>();
foreach (var match in await mappingMatcher.MatchAll(targets, syntaxGenerator, mappingContext, globalTargetAccessor).ConfigureAwait(false))
{
var sourceMappingElement = await MapExpression(match.Source, match.Target.ExpressionType, mappingContext, mappingPath.Clone()).ConfigureAwait(false);
var sourceExpression = sourceMappingElement.Expression;
if (sourceMappingElement.ExpressionType != match.Target.ExpressionType)
{
mappingContext.AddMissingConversion(sourceMappingElement.ExpressionType.Type, match.Target.ExpressionType.Type);
if (mappingContext.WrapInCustomConversion)
{
var customConversionMethodName = syntaxGenerator.IdentifierName($"MapFrom{sourceMappingElement.ExpressionType.Type.Name}To{match.Target.ExpressionType.Type.Name}");
sourceExpression = (ExpressionSyntax)syntaxGenerator.InvocationExpression(customConversionMethodName, sourceExpression);
}
}
var assignmentExpression = AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, match.Target.Expression, sourceExpression);
results.Add(assignmentExpression);
}
return(results);
}
