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)); }