Merge branch 'develop' into ViktorHofer-netstandard20

 Conflicts:
	.paket/Paket.Restore.targets
	paket.lock
	src/CommandLine/CommandLine.csproj
	src/CommandLine/Core/ReflectionExtensions.cs
	tests/CommandLine.Tests.Properties/CommandLine.Tests.Properties.csproj
	tests/CommandLine.Tests/CommandLine.Tests.csproj
	tests/CommandLine.Tests/Unit/Core/InstanceBuilderTests.cs
	tests/CommandLine.Tests/Unit/Text/HelpTextTests.cs

Author: ericnewton76

README.md

@@ -46,6 +46,43 @@ You can utilize the parser library in several ways:
 1. Create a class to define valid options, and to receive the parsed options.
 2. Call ParseArguments with the args string array.
 
+C# Quick Start:
+
+```csharp
+using System;
+using CommandLine;
+
+namespace QuickStart
+{
+    class Program
+    {
+        public class Options
+        {
+            [Option('v', "verbose", Required = false, HelpText = "Set output to verbose messages.")]
+            public bool Verbose { get; set; }
+        }
+
+        static void Main(string[] args)
+        {
+            Parser.Default.ParseArguments<Options>(args)
+                   .WithParsed<Options>(o =>
+                   {
+                       if (o.Verbose)
+                       {
+                           Console.WriteLine($"Verbose output enabled. Current Arguments: -v {o.Verbose}");
+                           Console.WriteLine("Quick Start Example! App is in Verbose mode!");
+                       }
+                       else
+                       {
+                           Console.WriteLine($"Current Arguments: -v {o.Verbose}");
+                           Console.WriteLine("Quick Start Example!");
+                       }
+                   });
+        }
+    }
+}
+```
+
 C# Examples:
 
 ```csharp
@@ -55,10 +92,14 @@ class Options
   public IEnumerable<string> InputFiles { get; set; }
 
   // Omitting long name, defaults to name of property, ie "--verbose"
-  [Option(Default = false, HelpText = "Prints all messages to standard output.")]
+  [Option(
+	Default = false,
+	HelpText = "Prints all messages to standard output.")]
   public bool Verbose { get; set; }
-
-  [Option("stdin", Default = false, HelpText = "Read from stdin")]
+  
+  [Option("stdin",
+	Default = false
+	HelpText = "Read from stdin")]
   public bool stdin { get; set; }
 
   [Value(0, MetaName = "offset", HelpText = "File offset.")]
@@ -79,7 +120,7 @@ F# Examples:
 type options = {
   [<Option('r', "read", Required = true, HelpText = "Input files.")>] files : seq<string>;
   [<Option(HelpText = "Prints all messages to standard output.")>] verbose : bool;
-  [<Option(DefaultValue = "русский", HelpText = "Content language.")>] language : string;
+  [<Option(Default = "русский", HelpText = "Content language.")>] language : string;
   [<Value(0, MetaName="offset", HelpText = "File offset.")>] offset : int64 option;
 }
 
@@ -94,18 +135,22 @@ VB.Net:
 
 ```VB.NET
 Class Options
-    <CommandLine.Option("r", "read", Required:=True, HelpText:="Input files to be processed.")>
-    Public Property InputFiles As IEnumerable(Of String)
-
-    ' Omitting long name, defaults to name of property, ie "--verbose"
-    <CommandLine.Option(HelpText:="Prints all messages to standard output.")>
-    Public Property Verbose As Boolean
-
-    <CommandLine.Option([Default]:="中文", HelpText:="Content language.")>
-    Public Property Language As String
-
-    <CommandLine.Value(0, MetaName:="offset", HelpText:="File offset.")>
-    Public Property Offset As Long?
+	<CommandLine.Option('r', "read", Required := true,
+	HelpText:="Input files to be processed.")>
+	Public Property InputFiles As IEnumerable(Of String)
+
+	' Omitting long name, defaults to name of property, ie "--verbose"
+	<CommandLine.Option(
+	HelpText:="Prints all messages to standard output.")>
+	Public Property Verbose As Boolean
+
+	<CommandLine.Option(Default:="中文",
+	HelpText:="Content language.")>
+	Public Property Language As String
+
+	<CommandLine.Value(0, MetaName:="offset",
+	HelpText:="File offset.")>
+	Public Property Offset As Long?
 End Class
 
 Sub Main(ByVal args As String())
@@ -204,7 +249,7 @@ let main args =
   | :? CommandLine.NotParsed<obj> -> 1
 ```
 
-# Contibutors
+# Contributors
 First off, _Thank you!_  All contributions are welcome.  
 
 Please consider sticking with the GNU getopt standard for command line parsing.  

src/CommandLine/Core/InstanceBuilder.cs

@@ -77,22 +77,23 @@ public static ParserResult<T> Build<T>(
                 var specPropsWithValue =
                     optionSpecPropsResult.SucceededWith().Concat(valueSpecPropsResult.SucceededWith());
 
-                Func<T> buildMutable = () =>
+                var setPropertyErrors = new List<Error>();                
+
+                Func <T> buildMutable = () =>
                 {
                     var mutable = factory.MapValueOrDefault(f => f(), Activator.CreateInstance<T>());
-                    mutable =
-                        mutable.SetProperties(specPropsWithValue, sp => sp.Value.IsJust(), sp => sp.Value.FromJustOrFail())
-                            .SetProperties(
-                                specPropsWithValue,
-                                sp => sp.Value.IsNothing() && sp.Specification.DefaultValue.IsJust(),
-                                sp => sp.Specification.DefaultValue.FromJustOrFail())
-                            .SetProperties(
-                                specPropsWithValue,
-                                sp =>
-                                    sp.Value.IsNothing() && sp.Specification.TargetType == TargetType.Sequence
-                                    && sp.Specification.DefaultValue.MatchNothing(),
-                                sp => sp.Property.PropertyType.GetTypeInfo().GetGenericArguments().Single().CreateEmptyArray());
-                    return mutable;
+                    setPropertyErrors.AddRange(mutable.SetProperties(specPropsWithValue, sp => sp.Value.IsJust(), sp => sp.Value.FromJustOrFail()));
+                    setPropertyErrors.AddRange(mutable.SetProperties(
+                                                 specPropsWithValue,
+                                                 sp => sp.Value.IsNothing() && sp.Specification.DefaultValue.IsJust(),
+                                                 sp => sp.Specification.DefaultValue.FromJustOrFail()));
+                    setPropertyErrors.AddRange(mutable.SetProperties(
+                                                 specPropsWithValue,
+                                                 sp =>
+                                                     sp.Value.IsNothing() && sp.Specification.TargetType == TargetType.Sequence
+                                                     && sp.Specification.DefaultValue.MatchNothing(),
+                                                 sp => sp.Property.PropertyType.GetTypeInfo().GetGenericArguments().Single().CreateEmptyArray()));
+                     return mutable;
                 };
 
                 Func<T> buildImmutable = () =>
@@ -118,6 +119,7 @@ join sp in specPropsWithValue on prms.Name.ToLower() equals sp.Property.Name.ToL
                         .Concat(optionSpecPropsResult.SuccessfulMessages())
                         .Concat(valueSpecPropsResult.SuccessfulMessages())
                         .Concat(validationErrors)
+                        .Concat(setPropertyErrors)
                         .Memorize();
 
                 var warnings = from e in allErrors where nonFatalErrors.Contains(e.Tag) select e;

src/CommandLine/Core/ReflectionExtensions.cs

@@ -80,49 +80,30 @@ public static TargetType ToTargetType(this Type type)
                                    : TargetType.Scalar;
         }
 
-        public static T SetProperties<T>(
+        public static IEnumerable<Error> SetProperties<T>(
             this T instance,
             IEnumerable<SpecificationProperty> specProps,
             Func<SpecificationProperty, bool> predicate,
             Func<SpecificationProperty, object> selector)
         {
-            return specProps.Where(predicate).Aggregate(
-                instance,
-                (current, specProp) =>
-                    {
-                        specProp.Property.SetValue(current, selector(specProp));
-                        return instance;
-                    });
+            return specProps.Where(predicate).SelectMany(specProp => specProp.SetValue(instance, selector(specProp)));
         }
 
-        private static T SetValue<T>(this PropertyInfo property, T instance, object value)
+        private static IEnumerable<Error> SetValue<T>(this SpecificationProperty specProp, T instance, object value)
         {
-            Action<Exception> fail = inner => {
-                throw new InvalidOperationException("Cannot set value to target instance.", inner);
-            };
-            
             try
             {
-                property.SetValue(instance, value, null);
-            }
-            catch (TargetException e)
-            {
-                fail(e);
-            }
-            catch (TargetParameterCountException e)
-            {
-                fail(e);
+                specProp.Property.SetValue(instance, value, null);
+                return Enumerable.Empty<Error>();
             }
-            catch (MethodAccessException e)
+            catch (TargetInvocationException e)
             {
-                fail(e);
+                return new[] { new SetValueExceptionError(specProp.Specification.FromSpecification(), e.InnerException, value) };
             }
-            catch (TargetInvocationException e)
+            catch (Exception e)
             {
-                fail(e);
+                 return new[] { new SetValueExceptionError(specProp.Specification.FromSpecification(), e, value) };
             }
-
-            return instance;
         }
 
         public static object CreateEmptyArray(this Type type)

src/CommandLine/Core/SpecificationGuards.cs

@@ -13,7 +13,7 @@ static class SpecificationGuards
                 Tuple.Create(GuardAgainstScalarWithRange(), "Scalar option specifications do not support range specification."),
                 Tuple.Create(GuardAgainstSequenceWithWrongRange(), "Bad range in sequence option specifications."),
                 Tuple.Create(GuardAgainstSequenceWithZeroRange(), "Zero is not allowed in range of sequence option specifications."),
-                Tuple.Create(GuardAgainstOneCharLongName(), "Long name should be longest than one character.")
+                Tuple.Create(GuardAgainstOneCharLongName(), "Long name should be longer than one character.")
             };
 
         private static Func<Specification, bool> GuardAgainstScalarWithRange()

src/CommandLine/Core/TypeConverter.cs

@@ -46,6 +46,19 @@ private static Maybe<object> ChangeTypeScalar(string value, Type conversionType,
             return result.ToMaybe();
         }
 
+        private static object ConvertString(string value, Type type, CultureInfo conversionCulture)
+        {
+            try
+            {
+                return Convert.ChangeType(value, type, conversionCulture);
+            }
+            catch (InvalidCastException)
+            {
+                // Required for converting from string to TimeSpan because Convert.ChangeType can't
+                return System.ComponentModel.TypeDescriptor.GetConverter(type).ConvertFrom(null, conversionCulture, value);
+            }
+        }
+
         private static Result<object, Exception> ChangeTypeScalarImpl(string value, Type conversionType, CultureInfo conversionCulture, bool ignoreValueCase)
         {
             Func<object> changeType = () =>
@@ -68,10 +81,9 @@ private static Result<object, Exception> ChangeTypeScalarImpl(string value, Type
                         () =>
 #if !SKIP_FSHARP
                             isFsOption
-                                ? FSharpOptionHelper.Some(type, Convert.ChangeType(value, type, conversionCulture)) :
+                                ? FSharpOptionHelper.Some(type, ConvertString(value, type, conversionCulture)) :
 #endif
-                                Convert.ChangeType(value, type, conversionCulture);
-
+                                ConvertString(value, type, conversionCulture);
 #if !SKIP_FSHARP
                     Func<object> empty = () => isFsOption ? FSharpOptionHelper.None(type) : null;
 #else

src/CommandLine/Error.cs

@@ -60,7 +60,11 @@ public enum ErrorType
         /// <summary>
         /// Value of <see cref="CommandLine.VersionRequestedError"/> type.
         /// </summary>
-        VersionRequestedError
+        VersionRequestedError,
+        /// <summary>
+        /// Value of <see cref="CommandLine.SetValueExceptionError"/> type.
+        /// </summary>
+        SetValueExceptionError
     }
 
     /// <summary>
@@ -471,4 +475,37 @@ internal VersionRequestedError()
         {
         }
     }
+
+    /// <summary>
+    /// Models as error generated when exception is thrown at Property.SetValue
+    /// </summary>
+    public sealed class SetValueExceptionError : NamedError
+    {
+        private readonly Exception exception;
+        private readonly object value;
+
+        internal SetValueExceptionError(NameInfo nameInfo, Exception exception, object value)
+            : base(ErrorType.SetValueExceptionError, nameInfo)
+        {
+            this.exception = exception;
+            this.value = value;
+        }
+
+        /// <summary>
+        /// The expection thrown from Property.SetValue
+        /// </summary>
+        public Exception Exception
+        {
+            get { return exception; }
+        }
+
+        /// <summary>
+        /// The value that had to be set to the property
+        /// </summary>
+        public object Value
+        {
+            get { return value; }
+        }
+
+    }
 }

src/CommandLine/ParserSettings.cs

@@ -35,6 +35,10 @@ public ParserSettings()
             try
             {
                 maximumDisplayWidth = Console.WindowWidth;
+                if (maximumDisplayWidth < 1)
+                {
+                    maximumDisplayWidth = DefaultMaximumLength;
+                }
             }
             catch (IOException)
             {

src/CommandLine/Text/HeadingInfo.cs

@@ -57,8 +57,16 @@ public static HeadingInfo Default
             {
                 var title = ReflectionHelper.GetAttribute<AssemblyTitleAttribute>()
                     .MapValueOrDefault(
-                        titleAttribute => Path.GetFileNameWithoutExtension(titleAttribute.Title),
+                        titleAttribute =>
+                        {
+                            if (titleAttribute.Title.ToLowerInvariant().EndsWith(".dll"))
+                            {
+                                return titleAttribute.Title.Substring(0, titleAttribute.Title.Length - ".dll".Length);
+                            }
+                            return titleAttribute.Title;
+                        },
                         ReflectionHelper.GetAssemblyName());
+
                 var version = ReflectionHelper.GetAttribute<AssemblyInformationalVersionAttribute>()
                     .MapValueOrDefault(
                         versionAttribute => versionAttribute.InformationalVersion,

src/CommandLine/Text/HelpText.cs

@@ -105,6 +105,10 @@ public HelpText(SentenceBuilder sentenceBuilder, string heading, string copyrigh
             try
             {
                 maximumDisplayWidth = Console.WindowWidth;
+                if (maximumDisplayWidth < 1)
+                {
+                    maximumDisplayWidth = DefaultMaximumLength;
+                }
             }
             catch (IOException)
             {
@@ -636,7 +640,7 @@ internal static void AddLine(StringBuilder builder, string value, int maximumLen
                 throw new ArgumentOutOfRangeException(nameof(value));
             }
 
-            value = value.Trim();
+            value = value.TrimEnd();
 
             builder.AppendWhen(builder.Length > 0, Environment.NewLine);
             do

src/CommandLine/Text/SentenceBuilder.cs

@@ -137,6 +137,9 @@ public override Func<Error, string> FormatError
                                 case ErrorType.RepeatedOptionError:
                                     return "Option '".JoinTo(((RepeatedOptionError)error).NameInfo.NameText,
                                         "' is defined multiple times.");
+                                case ErrorType.SetValueExceptionError:
+                                    var setValueError = (SetValueExceptionError)error;
+                                    return "Error setting value to option '".JoinTo(setValueError.NameInfo.NameText, "': ", setValueError.Exception.Message);
                             }
                             throw new InvalidOperationException();
                         };