Merge branch 'release/v1.0.3'

Author: chriswalpen

README.md

@@ -1,6 +1,8 @@
 # LogSplit
-[![Build Status](https://travis-ci.org/WickedFlame/LogSplit.svg?branch=master)](https://travis-ci.org/WickedFlame/LogSplit)
-[![Build status](https://ci.appveyor.com/api/projects/status/5xsg81nvy8xwval0?svg=true)](https://ci.appveyor.com/project/chriswalpen/logsplit)
+[![Build status](https://img.shields.io/appveyor/build/chriswalpen/LogSplit/master?label=Master&logo=appveyor&style=for-the-badge)](https://ci.appveyor.com/project/chriswalpen/LogSplit/branch/master)
+[![Build status](https://img.shields.io/appveyor/build/chriswalpen/LogSplit/dev?label=Dev&logo=appveyor&style=for-the-badge)](https://ci.appveyor.com/project/chriswalpen/LogSplit/branch/dev)
+[![NuGet Version](https://img.shields.io/nuget/v/LogSplit.svg?style=for-the-badge&label=Latest)](https://www.nuget.org/packages/LogSplit/)
+[![NuGet Version](https://img.shields.io/nuget/vpre/LogSplit.svg?style=for-the-badge&label=RC)](https://www.nuget.org/packages/LogSplit/)
 
 Split string lines into objects
 

appveyor.yml

@@ -2,10 +2,10 @@
 
 
 # version format
-version: 1.0.2.{build}
+version: 1.0.3.{build}
 
 environment:
-  base_version: 1.0.2
+  base_version: 1.0.3
 
 # you can use {branch} name in version format too
 # version: 1.0.{build}-{branch}
@@ -24,6 +24,7 @@ branches:
   # whitelist
   only:
     - master
+    - dev
 #    - somebranch
 
 # Do not build on tags (GitHub only)

src/LogSplit/LogSplit.csproj

@@ -1,31 +1,30 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-		<TargetFrameworks>netstandard2.0;net48</TargetFrameworks>
-	  <TargetFrameworks Condition="'$(OS)' != 'Windows_NT'">netcoreapp2.0</TargetFrameworks>
-    <Authors>Christian Walpen</Authors>
-    <Company>WickedFlame</Company>
-    <Title>LogSplit</Title>
-    <Version>1.0.0</Version>
-    <AssemblyVersion>1.0.0.0</AssemblyVersion>
-    <FileVersion>1.0.0.0</FileVersion>
-	  <PackageVersion>1.0.0-RC01</PackageVersion>
-    <NeutralLanguage>en</NeutralLanguage>
-    <Description>Parse strings into objects</Description>
-    <Copyright>@WickedFlame 2020</Copyright>
-    <PackageTags>Parser, Logging, String</PackageTags>
-	  <PackageLicenseExpression>MIT</PackageLicenseExpression>
-	  <RepositoryUrl>https://github.com/WickedFlame/LogSplit</RepositoryUrl>
-    <PackageProjectUrl>https://github.com/WickedFlame/LogSplit</PackageProjectUrl>
-    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <PropertyGroup>
+        <TargetFrameworks>netstandard2.0;net48</TargetFrameworks>
+        <TargetFrameworks Condition="'$(OS)' != 'Windows_NT'">netcoreapp2.0</TargetFrameworks>
+        <Authors>Christian Walpen</Authors>
+        <Company>WickedFlame</Company>
+        <Title>LogSplit</Title>
+        <Version>1.0.0</Version>
+        <AssemblyVersion>1.0.0.0</AssemblyVersion>
+        <FileVersion>1.0.0.0</FileVersion>
+        <PackageVersion>1.0.0-RC01</PackageVersion>
+        <NeutralLanguage>en</NeutralLanguage>
+        <Description>Parse strings into objects</Description>
+        <Copyright>@WickedFlame 2020</Copyright>
+        <PackageTags>Parser, Logging, String</PackageTags>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
+        <RepositoryUrl>https://github.com/WickedFlame/LogSplit</RepositoryUrl>
+        <PackageProjectUrl>https://github.com/WickedFlame/LogSplit</PackageProjectUrl>
+        <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
 
-    <!--<IncludeBuildOutput>false</IncludeBuildOutput>-->
-    <!--<ContentTargetFolders>content\any\any\App_Packages\LogSplit;contentFiles\cs\netstandard2.0\App_Packages\LogSplit</ContentTargetFolders>-->
-  </PropertyGroup>
+        <!--<IncludeBuildOutput>false</IncludeBuildOutput>-->
+        <!--<ContentTargetFolders>content\any\any\App_Packages\LogSplit;contentFiles\cs\netstandard2.0\App_Packages\LogSplit</ContentTargetFolders>-->
+    </PropertyGroup>
 
-  <!--<ItemGroup>
-    <Compile Update="Parser.cs" pack="true" buildAction="compile" />
-    <None Include="Parser.cs.pp" pack="true" buildAction="compile"/>
-  </ItemGroup>-->
+    <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+        <DocumentationFile>bin\Release\netstandard2.0\LogSplit.xml</DocumentationFile>
+    </PropertyGroup>
 
 </Project>

src/LogSplit/Map/ConvertedValue.cs

@@ -0,0 +1,45 @@
+using System;
+
+namespace LogSplit.Map
+{
+    /// <summary>
+    /// A value that is converted to the concrete type
+    /// </summary>
+    public class ConvertedValue
+    {
+        /// <summary>
+        /// Creates a default value that represents a value that could not be converted
+        /// </summary>
+        public ConvertedValue()
+        {
+            Converted = false;
+        }
+
+        /// <summary>
+        /// Creates a oject containing a converted value and the given type
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="type"></param>
+        public ConvertedValue(object value, Type type)
+        {
+            Value = value;
+            Type = type;
+            Converted = true;
+        }
+
+        /// <summary>
+        /// Gets if the value could be converted
+        /// </summary>
+        public bool Converted { get; }
+
+        /// <summary>
+        /// Gets the converted value
+        /// </summary>
+        public object Value { get; }
+
+        /// <summary>
+        /// Gets the type that the object was converted to
+        /// </summary>
+        public Type Type { get; }
+    }
+}

src/LogSplit/Map/Mapper.cs

@@ -1,4 +1,5 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace LogSplit.Map
 {
@@ -10,6 +11,8 @@ public static T Map<T>(ParserResult result)
 		{
 			var instance = typeof(T).CreateInstance();
 
+			var unconverted = new List<string>();
+
 			foreach (var item in result)
 			{
 				var properties = typeof(T).GetProperties();
@@ -19,13 +22,23 @@ public static T Map<T>(ParserResult result)
 					continue;
 				}
 
-				var converted = PrimitiveTypeConverter.Convert(propertyInfo.PropertyType, item.Value.ToString());
-				if (converted == null)
+				var value = unconverted.Any() ? $"{string.Join(string.Empty, unconverted.Select(v => v))}{item.Raw}" : item.Value;
+				var converted = PrimitiveTypeConverter.Convert(propertyInfo.PropertyType, value);
+				if (!converted.Converted || converted.Value == null)
 				{
-					continue;
+					//try without unconverted values
+					converted = PrimitiveTypeConverter.Convert(propertyInfo.PropertyType, item.Value);
+					if (!converted.Converted || converted.Value == null)
+					{
+						unconverted.Add(item.Raw);
+						continue;
+					}
+
+					// conversion was successful so delete the list with unconverted
+					unconverted.Clear();
 				}
 
-				propertyInfo.SetValue(instance, converted, null);
+				propertyInfo.SetValue(instance, converted.Value, null);
 			}
 
 			return (T)instance;

src/LogSplit/Map/PrimitiveTypeConverter.cs

@@ -5,63 +5,63 @@ namespace LogSplit.Map
 {
 	public class PrimitiveTypeConverter
 	{
-		public static object Convert(Type type, string value)
+		public static ConvertedValue Convert(Type type, string value)
 		{
 			if (type == typeof(string))
 			{
-				return value.Trim();
+				return new ConvertedValue(value.Trim(), type);
 			}
 
 			if (type == typeof(bool) || type == typeof(bool?))
 			{
 				if (value != null)
 				{
-					return ParseBoolean(value);
+					return new ConvertedValue(ParseBoolean(value), type);
 				}
 
-				return null;
+				return new ConvertedValue();
 			}
 
 			if (type == typeof(long) || type == typeof(long?))
 			{
 				if (long.TryParse(value, out var l))
 				{
-					return l;
+					return new ConvertedValue(l, type);
 				}
 
-				return null;
+				return new ConvertedValue();
 			}
 
 			if (type == typeof(int) || type == typeof(int?))
 			{
 				if (int.TryParse(value, out var i))
 				{
-					return i;
+					return new ConvertedValue(i, type);
 				}
 
-				return null;
+				return new ConvertedValue();
 			}
 
 			if (type == typeof(decimal))
 			{
-				return decimal.Parse(value);
+				return new ConvertedValue(decimal.Parse(value), type);
 			}
 
 			if (type == typeof(double) || type == typeof(double?))
 			{
 				if (double.TryParse(value, out var b))
 				{
-					return b;
+					return new ConvertedValue(b, type);
 				}
 
-				return null;
+				return new ConvertedValue();
 			}
 
 			if (type == typeof(DateTime) || type == typeof(DateTime?))
 			{
 				if (DateTime.TryParse(value, out var date))
 				{
-					return date;
+					return new ConvertedValue(date, type);
 				}
 
 				var formats = new string[]
@@ -74,45 +74,45 @@ public static object Convert(Type type, string value)
 
 				if (DateTime.TryParseExact(value, formats, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out date))
 				{
-					return date;
+					return new ConvertedValue(date, type);
 				}
 
-				throw new FormatException($"Value {value} could not be parsed to {type.FullName}. DateTimes have to be in the ISO-8601 format eg. yyyy-MM-dd");
+				return new ConvertedValue();
 			}
 
 			if (type == typeof(Guid))
 			{
 				if (Guid.TryParse(value, out var guid))
 				{
-					return guid;
+					return new ConvertedValue(guid, type);
 				}
 
 				if (Guid.TryParseExact(value, "B", out guid))
 				{
-					return guid;
+					return new ConvertedValue(guid, type);
 				}
 
-				return null;
+				return new ConvertedValue();
 			}
 
 			if (type == typeof(Type))
 			{
-				return Type.GetType(value);
+				return new ConvertedValue(Type.GetType(value), type);
 			}
 
 			if (type.IsEnum)
 			{
 				try
 				{
-					return Enum.Parse(type, value, true);
+					return new ConvertedValue(Enum.Parse(type, value, true), type);
 				}
 				catch (ArgumentException)
 				{
 					// returns null anyway so do nothing
 				}
 			}
 
-			return null;
+			return new ConvertedValue();
 		}
 
 		public static bool ParseBoolean(object value)

src/LogSplit/Map/TypeExtensions.cs

@@ -2,8 +2,17 @@
 
 namespace LogSplit.Map
 {
+	/// <summary>
+	/// Extensions for <see cref="Type"/>
+	/// </summary>
 	public static class TypeExtensions
 	{
+		/// <summary>
+		/// Create a instance of the given type
+		/// </summary>
+		/// <param name="type"></param>
+		/// <returns></returns>
+		/// <exception cref="ArgumentException"></exception>
 		public static object CreateInstance(this Type type)
 		{
 			try

src/LogSplit/Parser.cs

@@ -1,18 +1,29 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace LogSplit
 {
+    /// <summary>
+    /// A parser that separates a string based on the pattern provided
+    /// </summary>
     public class Parser
     {
         private readonly string _pattern;
 
+        /// <summary>
+        /// Creates a new parser that uses the pattern to split a string
+        /// </summary>
+        /// <param name="pattern"></param>
         public Parser(string pattern)
         {
             _pattern = pattern;
         }
 
+        /// <summary>
+        /// Parse the string based on the pattern
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
         public ParserResult Parse(string value)
         {
             var splits = SplitPattern(_pattern);
@@ -46,13 +57,12 @@ public ParserResult Parse(string value)
 
 						if(nextSplit <= 0)
 						{
-							//errors.Add($"Could not split value due to invalid pattern\n - Value: \"{value}\"\n - Invalid delimeter: \"{scan.Separator}\".\n - Preceding pattern: \"{scan.Pattern.Pattern}\"");
 							continue;
 						}
 
                     }
 
-                    items.Add(new Token(key, value.Substring(0, nextSplit - length).Trim()));
+                    items.Add(new Token(key, value.Substring(0, nextSplit == value.Length ? nextSplit : nextSplit - length), value.Substring(0, nextSplit)));
                 }