Merge pull request #56 from josdeweger/dev

Merge to master v2.4.0

appveyor.yml

@@ -4,4 +4,13 @@ build_script:
 - ps: .\build.ps1
 test: off
 artifacts:
-- path: 'src\**\*.nupkg'
+- path: 'src\**\*.nupkg'
+deploy:
+  - provider: NuGet
+    on:
+      branch: master
+      APPVEYOR_REPO_TAG: true 
+    symbol_server: https://ci.appveyor.com/nuget/josdeweger-7u3d88pyya90/api/v2/package
+    api_key:
+      secure: d1CMBHpVrKHJOZxYueO4x/ROshtrPzJ8vPqKjxCT0NI=
+    artifact: /.*\.symbols\.nupkg/

src/Common.props

@@ -1,5 +1,5 @@
 <Project>
   <PropertyGroup>
-    <Version>2.3.0</Version>
+    <Version>2.4.0</Version>
   </PropertyGroup>
 </Project>

src/SheetToObjects.Core/MaybeExtensions.cs

@@ -0,0 +1,24 @@
+using System;
+using CSharpFunctionalExtensions;
+
+namespace SheetToObjects.Core
+{
+    internal static class MaybeExtensions
+    {
+        public static Maybe<T> OnEmpty<T>(this Maybe<T> maybe, Func<T> resultFunc)
+        {
+            if(maybe.HasNoValue)
+                return Maybe<T>.From(resultFunc());
+
+            return maybe;
+        }
+
+        public static Maybe<TResult> OnValue<T, TResult>(this Maybe<T> maybe, Func<T, TResult> resultFunc)
+        {
+            if(maybe.HasNoValue)
+                return Maybe<TResult>.None;
+
+            return Maybe<TResult>.From(resultFunc(maybe.Value));
+        }
+    }
+}

src/SheetToObjects.Core/SheetToObjects.Core.csproj

@@ -13,8 +13,8 @@
 	<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
 	<RepositoryUrl>https://github.com/josdeweger/SheetToObjects</RepositoryUrl>
   </PropertyGroup>
-
   <ItemGroup>
+    <PackageReference Include="CSharpFunctionalExtensions" Version="1.14.0" />
     <PackageReference Include="System.ValueTuple" Version="4.5.0" />
   </ItemGroup>
 </Project>

src/SheetToObjects.Lib/Extensions/ResultExtensions.cs

@@ -0,0 +1,26 @@
+using System;
+using CSharpFunctionalExtensions;
+
+namespace SheetToObjects.Lib.Extensions
+{
+    internal static class ResultExtensions
+    {
+        public static Result<TResult, TError> OnValidationSuccess<TResult, TError>(this Result<TResult, TError> result, Func<TResult, TResult> func)
+            where TError : class
+        {
+            if (result.IsSuccess)
+                return Result.Ok<TResult, TError>(func(result.Value));
+
+            return Result.Fail<TResult, TError>(result.Error);
+        }
+
+        public static Result<TResult, TError> OnValidationFailure<TResult, TError>(this Result<TResult, string> result, Func<string, TError> func) 
+            where TError : class
+        {
+            if (result.IsFailure)
+                return Result.Fail<TResult, TError>(func(result.Error));
+
+            return Result.Ok<TResult, TError>(result.Value);
+        }
+    }
+}

src/SheetToObjects.Lib/IMapRow.cs

@@ -7,7 +7,7 @@ namespace SheetToObjects.Lib
 {
     public interface IMapRow
     {
-        Result<ParsedModelResult<TModel>, List<IValidationError>> Map<TModel>(Row row, MappingConfig mappingConfig)
+        Result<ParsedModel<TModel>, List<IValidationError>> Map<TModel>(Row row, MappingConfig mappingConfig)
             where TModel : new();
     }
 }

src/SheetToObjects.Lib/IMapValue.cs

@@ -10,7 +10,6 @@ internal interface IMapValue
         Result<object, IValidationError> Map(
             string value,
             Type propertyType,
-            int columnIndex,
             int rowIndex,
             ColumnMapping columnMapping);
     }

src/SheetToObjects.Lib/MappingResult.cs

@@ -7,19 +7,19 @@ namespace SheetToObjects.Lib
     public class MappingResult<T>
         where T : new()
     {
-        public List<ParsedModelResult<T>> ParsedModels { get; set; }
+        public List<ParsedModel<T>> ParsedModels { get; set; }
         public List<IValidationError> ValidationErrors { get; set; }
 
         public bool IsFailure => ValidationErrors.Any();
         public bool IsSuccess => !IsFailure;
 
-        private MappingResult(List<ParsedModelResult<T>> parsedModels, List<IValidationError> validationErrors)
+        private MappingResult(List<ParsedModel<T>> parsedModels, List<IValidationError> validationErrors)
         {
             ParsedModels = parsedModels;
             ValidationErrors = validationErrors;
         }
 
-        public static MappingResult<T> Create(List<ParsedModelResult<T>> parsedModels,List<IValidationError> validationErrors)
+        public static MappingResult<T> Create(List<ParsedModel<T>> parsedModels,List<IValidationError> validationErrors)
         {
             return new MappingResult<T>(parsedModels, validationErrors);
         }

src/SheetToObjects.Lib/ParsedModel.cs

@@ -0,0 +1,14 @@
+namespace SheetToObjects.Lib
+{
+    public class ParsedModel<TModel> where TModel : new()
+    {
+        public TModel Value { get; }
+        public int RowIndex { get; }
+
+        public ParsedModel(TModel value, int rowIndex)
+        {
+            Value = value;
+            RowIndex = rowIndex;
+        }
+    }
+}

src/SheetToObjects.Lib/RowMapper.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using CSharpFunctionalExtensions;
 using SheetToObjects.Core;
 using SheetToObjects.Lib.FluentConfiguration;
@@ -16,55 +17,71 @@ public RowMapper(IMapValue valueMapper)
             _valueMapper = valueMapper;
         }
 
-        public Result<ParsedModelResult<TModel>, List<IValidationError>> Map<TModel>(Row row, MappingConfig mappingConfig)
-            where TModel : new()
+        public Result<ParsedModel<T>, List<IValidationError>> Map<T>(Row row, MappingConfig mappingConfig)
+            where T : new()
         {
-            var rowIValidationErrors = new List<IValidationError>();
-            var obj = new TModel();
+            var rowValidationErrors = new List<IValidationError>();
+            var obj = new T();
             var properties = obj.GetType().GetProperties().ToList();
 
             properties.ForEach(property =>
             {
-                var columnMapping = mappingConfig.GetColumnMappingByPropertyName(property.Name);
+                rowValidationErrors.AddRange(MapRow(row, mappingConfig, property, obj));
+            });
 
-                if (columnMapping.IsNull())
-                    return;
+            if (rowValidationErrors.Any())
+                return Result.Fail<ParsedModel<T>, List<IValidationError>>(rowValidationErrors);
+
+            return Result.Ok<ParsedModel<T>, List<IValidationError>>(new ParsedModel<T>(obj, row.RowIndex));
+        }
 
-                var cell = row.GetCellByColumnIndex(columnMapping.ColumnIndex);
+        private IEnumerable<IValidationError> MapRow<TModel>(
+            Row row, 
+            MappingConfig mappingConfig, 
+            PropertyInfo property, 
+            TModel obj) where TModel : new()
+        {
+            var columnMapping = mappingConfig.GetColumnMappingByPropertyName(property.Name);
 
-                if (cell == null)
-                {
-                    var parsingValidationError = ParsingValidationError.CellNotFound(columnMapping.ColumnIndex, row.RowIndex,
-                        columnMapping.DisplayName, property.Name);
+            if (columnMapping.IsNull())
+                return new List<IValidationError>();
 
-                    if (columnMapping.IsRequired)
-                        rowIValidationErrors.Add(parsingValidationError);
+            var cell = row.GetCellByColumnIndex(columnMapping.ColumnIndex);
 
-                    return;
-                }
+            if (cell == null)
+            {
+                return HandleEmptyCell(columnMapping, row.RowIndex, property.Name)
+                    .OnValue(error => new List<IValidationError> { error })
+                    .OnEmpty(() => new List<IValidationError>())
+                    .Unwrap();
+            }
 
-                _valueMapper.Map(
-                        cell.Value.ToString(), 
-                        property.PropertyType, 
-                        columnMapping.ColumnIndex, 
-                        row.RowIndex,
-                        columnMapping)
-                    .OnSuccess(value =>
-                    {
-                        if (value.ToString().IsNotNullOrEmpty())
-                        {
-                            property.SetValue(obj, value);
-                        }
-                    })
-                    .OnFailure(validationError => { rowIValidationErrors.Add(validationError); });
-            });
+            var validationErrors = new List<IValidationError>();
 
-            if (rowIValidationErrors.Any())
-                return Result.Fail<ParsedModelResult<TModel>, List<IValidationError>>(rowIValidationErrors);
+            _valueMapper
+                .Map(cell.Value.ToString(), property.PropertyType, row.RowIndex, columnMapping)
+                .OnSuccess(value =>
+                {
+                    if (value.ToString().IsNotNullOrEmpty())
+                        property.SetValue(obj, value);
+                })
+                .OnFailure(validationError => { validationErrors.Add(validationError); });
+
+            return validationErrors;
+        }
+
+        private static Maybe<IValidationError> HandleEmptyCell(ColumnMapping columnMapping, int rowIndex, string propertyName)
+        {
+            if (!columnMapping.IsRequired)
+                return Maybe<IValidationError>.None;
 
-            var parsedModelResult = new ParsedModelResult<TModel>(obj, row.RowIndex);
+            var parsingValidationError = ParsingValidationError.CellNotFound(
+                columnMapping.ColumnIndex,
+                rowIndex,
+                columnMapping.DisplayName,
+                propertyName);
 
-            return Result.Ok<ParsedModelResult<TModel>, List<IValidationError>>(parsedModelResult);
+            return Maybe<IValidationError>.From(parsingValidationError);
         }
     }
 }

src/SheetToObjects.Lib/SheetMapper.cs

@@ -45,7 +45,7 @@ public SheetMapper AddConfigFor<T>(Func<MappingConfigBuilder<T>, MappingConfigBu
         public MappingResult<T> Map<T>(Sheet sheet)
             where T : new()
         {
-            var parsedModels = new List<ParsedModelResult<T>>();
+            var parsedModels = new List<ParsedModel<T>>();
             var validationErrors = new List<IValidationError>();
 
             var mappingConfig = GetMappingConfig<T>();
@@ -72,7 +72,7 @@ public MappingResult<T> Map<T>(Sheet sheet)
             );
         }
 
-        private void MapRows<T>(Sheet sheet, MappingConfig mappingConfig, List<ParsedModelResult<T>> parsedModels, List<IValidationError> validationErrors)
+        private void MapRows<T>(Sheet sheet, MappingConfig mappingConfig, List<ParsedModel<T>> parsedModels, List<IValidationError> validationErrors)
             where T : new()
         {
             var dataRows = mappingConfig.HasHeaders ? sheet.Rows.Skip(1).ToList() : sheet.Rows;

src/SheetToObjects.Lib/SheetToObjects.Lib.csproj

@@ -19,7 +19,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="CSharpFunctionalExtensions" Version="1.10.0" />
+    <PackageReference Include="CSharpFunctionalExtensions" Version="1.14.0" />
   </ItemGroup>
 
   <ItemGroup>

src/SheetToObjects.Lib/Validation/IValidateColumn.cs

@@ -5,8 +5,8 @@ namespace SheetToObjects.Lib.Validation
 {
     internal interface IValidateColumn
     {
-        ValidationResult<ParsedModelResult<TModel>> Validate<TModel>(
-            List<ParsedModelResult<TModel>> parsedModels, 
+        ValidationResult<ParsedModel<TModel>> Validate<TModel>(
+            List<ParsedModel<TModel>> parsedModels, 
             List<ColumnMapping> columnMappings) 
             where TModel : new();
     }

src/SheetToObjects.Lib/Validation/IValidateModels.cs

@@ -5,8 +5,8 @@ namespace SheetToObjects.Lib.Validation
 {
     internal interface IValidateModels
     {
-        ValidationResult<ParsedModelResult<TModel>> Validate<TModel>(
-            List<ParsedModelResult<TModel>> parsedModels, 
+        ValidationResult<ParsedModel<TModel>> Validate<TModel>(
+            List<ParsedModel<TModel>> parsedModels, 
             List<ColumnMapping> columnMappings) 
             where TModel : new();
     }