protected override bool TargetCannotBeMapped(IObjectMappingData mappingData, out Expression nullMappingBlock)
{
if (mappingData.MapperData.TargetCouldBePopulated())
{
// If a target complex type is readonly or unconstructable
// we still try to map to it using an existing non-null value:
return(base.TargetCannotBeMapped(mappingData, out nullMappingBlock));
}
if (mappingData.IsTargetConstructable())
{
return(base.TargetCannotBeMapped(mappingData, out nullMappingBlock));
}
var targetType = mappingData.MapperData.TargetType;
if (targetType.IsAbstract() && DerivedTypesExistForTarget(mappingData))
{
return(base.TargetCannotBeMapped(mappingData, out nullMappingBlock));
}
nullMappingBlock = Expression.Block(
ReadableExpression.Comment("Cannot construct an instance of " + targetType.GetFriendlyName()),
targetType.ToDefaultExpression());
return(true);
}
private QuotedLambdaTranslation(UnaryExpression quotedLambda, ITranslationContext context)
{
var comment = ReadableExpression.Comment("Quoted to induce a closure:");
var quotedLambdaBlock = Expression.Block(comment, quotedLambda.Operand);
_quotedLambdaTranslation = context.GetTranslationFor(quotedLambdaBlock);
}
public override string Translate(Expression expression, TranslationContext context)
{
var debugInfo = (DebugInfoExpression)expression;
string debugInfoText;
if (debugInfo.IsClear)
{
debugInfoText = $"Clear debug info from {debugInfo.Document.FileName}";
}
else
{
debugInfoText = string.Format(
CultureInfo.InvariantCulture,
"Debug to {0}, {1}, {2} -> {3}, {4}",
debugInfo.Document.FileName,
debugInfo.StartLine,
debugInfo.StartColumn,
debugInfo.EndLine,
debugInfo.EndColumn);
}
var debugInfoComment = ReadableExpression.Comment(debugInfoText);
return(context.Translate(debugInfoComment));
}
public void ShouldTranslateASingleLineComment()
{
var comment = ReadableExpression.Comment("Not worth commenting on");
var translated = ToReadableString(comment);
translated.ShouldBe("// Not worth commenting on");
}
public Expression GetExpression()
{
var description = GetMappingDescription();
return(Expression.Block(
ReadableExpression.Comment(description),
_mapping));
}
private static IDataSourceSet CreateNullDataSourceSet(
IMemberMapperData mapperData,
Func <QualifiedMember, string> commentFactory)
{
return(DataSourceSet.For(
new NullDataSource(
ReadableExpression.Comment(commentFactory.Invoke(mapperData.TargetMember))),
mapperData));
}
private static IMemberPopulation CreateNullMemberPopulation(
IMemberMapperData mapperData,
Func <IQualifiedMember, string> commentFactory)
{
return(new MemberPopulation(
mapperData,
new DataSourceSet(
new NullDataSource(
ReadableExpression.Comment(commentFactory.Invoke(mapperData.TargetMember))))));
}
private Expression CreateWarnings()
{
var warningsText = _mappingMismatches
.Project(mm => mm.Warning)
.Join(Environment.NewLine + Environment.NewLine);
return((warningsText != string.Empty)
? ReadableExpression.Comment(warningsText)
: Constants.EmptyExpression);
}
private EnumMappingMismatchSet(IEnumerable <EnumMappingMismatch> mappingMismatches)
{
var warningsText = string.Join(
Environment.NewLine + Environment.NewLine,
mappingMismatches.Where(mm => mm.Any).Select(mm => mm.Warning));
if (warningsText != string.Empty)
{
Warnings = ReadableExpression.Comment(warningsText);
}
}
public void ShouldTranslateAMultipleLineComment()
{
var comment = ReadableExpression.Comment(@"
Not worth commenting on
but I will anyway");
var translated = ToReadableString(comment);
const string EXPECTED = @"
// Not worth commenting on
// but I will anyway";
translated.ShouldBe(EXPECTED.TrimStart());
}
protected override bool TargetCannotBeMapped(IObjectMappingData mappingData, out Expression nullMappingBlock)
{
if (mappingData.MapperData.SourceMember.IsEnumerable)
{
nullMappingBlock = null;
return(false);
}
nullMappingBlock = Expression.Block(
ReadableExpression.Comment("No source enumerable available"),
mappingData.MapperData.EnumerablePopulationBuilder.ExistingOrNewEmptyInstance());
return(true);
}
public void ShouldTranslateABlockWithAComment()
{
var comment = ReadableExpression.Comment("Anyone listening?");
var beep = CreateLambda(() => Console.Beep());
var commentedBeep = Block(comment, beep.Body);
var translated = ToReadableString(commentedBeep);
const string EXPECTED = @"
// Anyone listening?
Console.Beep();";
translated.ShouldBe(EXPECTED.TrimStart());
}
public void ShouldTranslateMultilineBlockSingleMethodArguments()
{
var intVariable = Variable(typeof(int), "i");
var variableInit = Assign(intVariable, Constant(3));
var variableMultiplyFive = Multiply(intVariable, Constant(5));
var variableAdditionOne = Assign(intVariable, variableMultiplyFive);
var variableDivideThree = Divide(intVariable, Constant(3));
var variableAdditionTwo = Assign(intVariable, variableDivideThree);
var argumentBlock = Block(
new[] { intVariable },
variableInit,
variableAdditionOne,
variableAdditionTwo,
intVariable);
var catchBlock = Catch(
typeof(Exception),
Block(ReadableExpression.Comment("So what!"), Constant(0)));
var tryCatch = TryCatch(argumentBlock, catchBlock);
var collectionVariable = Variable(typeof(ICollection <int>), "ints");
var addMethod = collectionVariable.Type.GetPublicInstanceMethod("Add");
var addMethodCall = Call(collectionVariable, addMethod, tryCatch);
var translated = ToReadableString(addMethodCall);
const string EXPECTED = @"
ints.Add(
{
try
{
var i = 3;
i = i * 5;
i = i / 3;
return i;
}
catch
{
// So what!
return 0;
}
})";
translated.ShouldBe(EXPECTED.TrimStart());
}
public void ShouldTranslateAConditionalBranchWithAComment()
{
var comment = ReadableExpression.Comment("Maths works");
var one = Constant(1);
var oneEqualsOne = Equal(one, one);
var ifOneEqualsOneComment = IfThen(oneEqualsOne, comment);
var translated = ToReadableString(ifOneEqualsOneComment);
const string EXPECTED = @"
if (1 == 1)
{
// Maths works
}";
translated.ShouldBe(EXPECTED.TrimStart());
}
public void ShouldFormatAConditionalBranchWithAComment()
{
var comment = ReadableExpression.Comment("Maths works");
var one = Constant(1);
var oneEqualsOne = Equal(one, one);
var ifOneEqualsOneComment = IfThen(oneEqualsOne, comment);
var translated = ToReadableHtmlString(ifOneEqualsOneComment);
const string EXPECTED = @"
<span class=""cs"">if </span>(<span class=""nm"">1</span> == <span class=""nm"">1</span>)
{
<span class=""cm"">// Maths works</span>
}";
translated.ShouldBe(EXPECTED.TrimStart());
}
protected override bool TargetCannotBeMapped(IObjectMappingData mappingData, out Expression nullMappingBlock)
{
if (mappingData.MapperData.SourceMember.IsEnumerable)
{
return(base.TargetCannotBeMapped(mappingData, out nullMappingBlock));
}
if (HasConfiguredRootDataSources(mappingData.MapperData, out var configuredRootDataSources) &&
configuredRootDataSources.Any(ds => ds.SourceMember.IsEnumerable))
{
return(base.TargetCannotBeMapped(mappingData, out nullMappingBlock));
}
nullMappingBlock = Expression.Block(
ReadableExpression.Comment("No source enumerable available"),
mappingData.MapperData.GetFallbackCollectionValue());
return(true);
}
public string Translate(Expression expression, TranslationContext context)
{
var quote = (UnaryExpression)expression;
if (context.Settings.DoNotCommentQuotedLambdas)
{
return(context.TranslateAsCodeBlock(quote.Operand));
}
var comment = ReadableExpression.Comment("Quoted to induce a closure:");
var quotedLambdaBlock = Expression.Block(comment, quote.Operand);
var translatedLambda = context
.TranslateCodeBlock(quotedLambdaBlock)
.Indented()
.WithoutCurlyBraces();
return(Environment.NewLine + translatedLambda);
}
public Expression Create(IObjectMappingData mappingData)
{
var mapperData = mappingData.MapperData;
if (TargetCannotBeMapped(mappingData, out var reason))
{
return(Expression.Block(
ReadableExpression.Comment(reason),
GetNullMappingFallbackValue(mapperData)));
}
var context = new MappingCreationContext(mappingData);
if (ShortCircuitMapping(context))
{
if (context.MappingComplete)
{
return(context.GetMappingExpression());
}
goto CompleteMappingBlock;
}
AddPopulationsAndCallbacks(context);
if (context.RemoveEmptyMappings && NothingIsBeingMapped(context))
{
return(mapperData.IsEntryPoint ? mapperData.TargetObject : Constants.EmptyExpression);
}
CompleteMappingBlock:
InsertShortCircuitReturns(context);
var mappingBlock = GetMappingBlock(context);
if (mapperData.Context.UseMappingTryCatch)
{
mappingBlock = mappingBlock.WrapInTryCatch(mapperData);
}
return(mappingBlock);
}
protected override bool TargetCannotBeMapped(IObjectMappingData mappingData, out Expression nullMappingBlock)
{
if (mappingData.MappingTypes.SourceType.IsDictionary())
{
return(base.TargetCannotBeMapped(mappingData, out nullMappingBlock));
}
var targetMember = (DictionaryTargetMember)mappingData.MapperData.TargetMember;
if ((targetMember.KeyType == typeof(string)) || (targetMember.KeyType == typeof(object)))
{
return(base.TargetCannotBeMapped(mappingData, out nullMappingBlock));
}
nullMappingBlock = Expression.Block(
ReadableExpression.Comment("Only string- or object-keyed Dictionaries are supported"),
mappingData.MapperData.GetFallbackCollectionValue());
return(true);
}
public static ITranslation For(DebugInfoExpression debugInfo, ITranslationContext context)
{
string debugInfoText;
if (debugInfo.IsClear)
{
debugInfoText = "Clear debug info from " + debugInfo.Document.FileName;
}
else
{
debugInfoText = string.Format(
CultureInfo.InvariantCulture,
"Debug to {0}, {1}, {2} -> {3}, {4}",
debugInfo.Document.FileName,
debugInfo.StartLine,
debugInfo.StartColumn,
debugInfo.EndLine,
debugInfo.EndColumn);
}
var debugInfoComment = ReadableExpression.Comment(debugInfoText);
return(context.GetTranslationFor(debugInfoComment).WithNodeType(ExpressionType.DebugInfo));
}
private static Expression CreateNullPopulatorDescription(
Func <QualifiedMember, string> commentFactory,
IQualifiedMemberContext context)
{
return(ReadableExpression.Comment(commentFactory.Invoke(context.TargetMember)));
}
private static IDataSource GetMapFromConditionOrDefaultDataSource(
IObjectMappingData declaredTypeMappingData,
Expression condition,
DerivedSourceTypeCheck derivedSourceCheck,
IEnumerable <TypePairGroup> typePairGroups,
Type targetType)
{
var declaredTypeMapperData = declaredTypeMappingData.MapperData;
var typePairDataSources = new List <IDataSource>();
Expression derivedTypeMapping;
IObjectMappingData derivedTypeMappingData;
foreach (var typePairGroup in typePairGroups)
{
var typePairsCondition =
declaredTypeMapperData.GetTypePairsCondition(typePairGroup.TypePairs) ??
declaredTypeMapperData.GetTargetValidCheckOrNull(typePairGroup.DerivedTargetType);
derivedTypeMapping = GetReturnMappingResultExpression(
declaredTypeMappingData,
derivedSourceCheck.TypedVariable,
typePairGroup.DerivedTargetType,
out derivedTypeMappingData);
if (derivedTypeMapping == EmptyExpression)
{
continue;
}
var typePairDataSource = new DerivedComplexTypeDataSource(
derivedTypeMappingData.MapperData.SourceMember,
typePairsCondition,
derivedTypeMapping);
typePairDataSources.Add(typePairDataSource);
}
var derivedTargetTypeDataSources = DataSourceSet.For(
typePairDataSources,
declaredTypeMappingData,
ValueExpressionBuilders.ValueSequence);
derivedTypeMapping = GetReturnMappingResultExpression(
declaredTypeMappingData,
derivedSourceCheck.TypedVariable,
targetType,
out derivedTypeMappingData);
var derivedTypeMappings = derivedTargetTypeDataSources.BuildValue();
if (derivedTypeMappings != EmptyExpression)
{
if (derivedTypeMapping != EmptyExpression)
{
derivedTypeMappings = Block(derivedTypeMappings, derivedTypeMapping);
}
}
else if (derivedTypeMapping != EmptyExpression)
{
derivedTypeMappings = derivedTypeMapping;
}
else
{
return(new NullDataSource(ReadableExpression.Comment("No data sources")));
}
return(new DerivedComplexTypeDataSource(
derivedTypeMappingData.MapperData.SourceMember,
derivedSourceCheck,
condition,
derivedTypeMappings,
declaredTypeMapperData));
}
