Add DefaultResolver

CommandLineParser.Tests/CommandLineParserTests.cs

@@ -531,6 +531,47 @@ public void TransformationWorksAsExpectedForCommandOptions(string[] args, int ex
             Assert.Equal(expected, outcome);
         }
 
+        [Theory]
+        [InlineData(new string[] { "cmd" }, "", true)]
+        [InlineData(new string[] { "cmd", "-s", "-s2" }, "", true)]
+        [InlineData(new string[] { "cmd", "-s", "test", "-s2", "test" }, "test", false)]
+        [InlineData(new string[] { "cmd", "--string", "test", "-s2", "test" }, "test", false)]
+        public void CustomTypeWithStringTryParseGetsParsedCorrectly(string[] args, string expected, bool errors)
+        {
+            var parser = new CommandLineParser<StringTryParseTypeOptions>();
+
+            var result = parser.Parse(args);
+
+            Assert.Equal(errors, result.AssertNoErrors(!errors));
+
+            if (!result.HasErrors)
+            {
+                Assert.Equal(expected, result.Result.String.Result);
+                Assert.Equal(expected, result.Result.String2.Result);
+            }
+        }
+
+        [Theory]
+        [InlineData(new string[] { "cmd" }, "", true)]
+        [InlineData(new string[] { "cmd", "-s", "-s2", "-s3" }, "", true)]
+        [InlineData(new string[] { "cmd", "-s", "test", "-s2", "test", "-s3", "test" }, "test", false)]
+        [InlineData(new string[] { "cmd", "--string", "test", "-s2", "test", "-s3", "test" }, "test", false)]
+        public void CustomTypeWithStringConstructorGetsParsedCorrectly(string[] args, string expected, bool errors)
+        {
+            var parser = new CommandLineParser<StringTypeOptions>();
+
+            var result = parser.Parse(args);
+
+            Assert.Equal(errors, result.AssertNoErrors(!errors));
+
+            if (!result.HasErrors)
+            {
+                Assert.Equal(expected, result.Result.String.Result);
+                Assert.Equal(expected, result.Result.String2.Result);
+                Assert.Equal(expected, result.Result.String3.Result);
+            }
+        }
+
         private class ObjOption
         {
             [Name("p"), Required]
@@ -570,5 +611,126 @@ private class IntOptions
         {
             public int SomeInt { get; set; }
         }
+
+        private class StringTypeOptions
+        {
+            [Name("s", "string"), Required]
+            public StringType String { get; set; }
+
+            [Name("s2"), Required]
+            public StringType4 String2 { get; set; }
+
+            [Name("s3"), Required]
+            public StringType5 String3 { get; set; }
+        }
+
+        private class StringTryParseTypeOptions
+        {
+            [Name("s", "string"), Required]
+            public StringType2 String { get; set; }
+
+            [Name("s2"), Required]
+            public StringType3 String2 { get; set; }
+        }
+
+        private class StringType
+        {
+            public StringType(string input)
+            {
+                Result = input;
+            }
+
+            public StringType(string input, string input2)
+            {
+                Result = input;
+            }
+
+            public string Result { get; }
+        }
+
+        private class StringType2
+        {
+            private StringType2(string input)
+            {
+                Result = input;
+            }
+
+            public string Result { get; }
+
+            public static bool TryParse(string input, IFormatProvider format, out StringType2 result)
+            {
+                result = new StringType2(input);
+                return true;
+            }
+
+            public static bool TryParse() => false;
+
+            public static void Tryparse(string input, IFormatProvider format, out StringType2 result)
+            {
+                result = default;
+            }
+
+            public static bool TryParse(string input, StringType2 xd, out StringType2 stringType2)
+            {
+                stringType2 = default;
+                return false;
+            }
+        }
+
+        private class StringType3
+        {
+            private StringType3(string input)
+            {
+                Result = input;
+            }
+
+            public string Result { get; }
+
+            public static bool TryParse(string input, out StringType3 result)
+            {
+                result = new StringType3(input);
+                return true;
+            }
+        }
+
+        private class StringType4
+        {
+            private StringType4(string input)
+            {
+                Result = input;
+            }
+
+            public string Result { get; }
+
+            public static StringType4 Parse(string input)
+            {
+                return new StringType4(input);
+            }
+        }
+
+        private class StringType5
+        {
+            private StringType5(string input)
+            {
+                Result = input;
+            }
+
+            public string Result { get; }
+
+            public static StringType5 Parse(string input, IFormatProvider provider)
+            {
+                return new StringType5(input);
+            }
+
+            public static StringType4 Parse(string input)
+            {
+                return null;
+            }
+
+            public static StringType5 Parse(string input, IFormatProvider provider, IFormatProvider xd)
+            {
+                return null;
+            }
+        }
     }
 }

CommandLineParser.Tests/Parsing/ResolverFactoryTest.cs

@@ -1,13 +1,10 @@
-using System;
-
-using MatthiWare.CommandLine.Abstractions.Models;
+using MatthiWare.CommandLine.Abstractions.Models;
 using MatthiWare.CommandLine.Abstractions.Parsing;
 using MatthiWare.CommandLine.Core;
 using MatthiWare.CommandLine.Core.Parsing;
 using MatthiWare.CommandLine.Core.Parsing.Resolvers;
-
 using Moq;
-
+using System;
 using Xunit;
 
 namespace MatthiWare.CommandLine.Tests.Parsing
@@ -84,6 +81,7 @@ public void RegisterOverrideWorks()
 
             factory.Register(typeof(string), mockResolver.Object.GetType(), true);
             factory.Register<string, StringResolver>(true);
+            factory.Register<string, StringResolver>(true);
         }
 
         [Fact]
@@ -96,6 +94,14 @@ public void RegisterThrowsException()
             Assert.Throws<ArgumentException>(() => factory.Register<string, StringResolver>());
         }
 
+        [Fact]
+        public void NonAssignableTypeThrowsException()
+        {
+            var factory = new DefaultArgumentResolverFactory(new DefaultContainerResolver());
+
+            Assert.Throws<InvalidCastException>(() => factory.Register(typeof(string), typeof(Mock), true));
+        }
+
         [Fact]
         public void RegisterObjectResolver()
         {

CommandLineParser.Tests/Parsing/Resolvers/DefaultResolverTests.cs

@@ -0,0 +1,60 @@
+using MatthiWare.CommandLine.Abstractions.Models;
+using MatthiWare.CommandLine.Core.Parsing.Resolvers;
+using Xunit;
+
+namespace MatthiWare.CommandLine.Tests.Parsing.Resolvers
+{
+    public class DefaultResolverTests
+    {
+        [Theory]
+        [InlineData(true, "-m", "test")]
+        [InlineData(true, "-m", "my string")]
+        public void TestCanResolve(bool expected, string key, string value)
+        {
+            var resolver = new DefaultResolver<MyTestType>();
+            var model = new ArgumentModel(key, value);
+
+            Assert.Equal(expected, resolver.CanResolve(model));
+        }
+
+        [Theory]
+        [InlineData(false, "-m", "test")]
+        [InlineData(false, "-m", "my string")]
+        public void TestCanResolveWithWrongCtor(bool expected, string key, string value)
+        {
+            var resolver = new DefaultResolver<MyTestType2>();
+            var model = new ArgumentModel(key, value);
+
+            Assert.Equal(expected, resolver.CanResolve(model));
+        }
+
+        [Theory]
+        [InlineData("test", "-m", "test")]
+        [InlineData("my string", "-m", "my string")]
+        public void TestResolve(string expected, string key, string value)
+        {
+            var resolver = new DefaultResolver<MyTestType>();
+            var model = new ArgumentModel(key, value);
+
+            Assert.Equal(expected, resolver.Resolve(model).Result);
+        }
+
+        public class MyTestType
+        {
+            public MyTestType(string ctor)
+            {
+                Result = ctor;
+            }
+
+            public string Result { get; }
+        }
+
+        public class MyTestType2
+        {
+            public MyTestType2(int someInt)
+            {
+
+            }
+        }
+    }
+}

CommandLineParser.Tests/Parsing/Resolvers/EnumResolverTests.cs

@@ -21,7 +21,9 @@ public void TestCanResolve(bool expected, string key, string value)
 
         [Theory]
         [InlineData(TestEnum.Error, "-m", "Error")]
+        [InlineData(TestEnum.Error, "-m", "error")]
         [InlineData(TestEnum.Verbose, "-m", "Verbose")]
+        [InlineData(TestEnum.Verbose, "-m", "verbose")]
         public void TestResolve(TestEnum expected, string key, string value)
         {
             var resolver = new EnumResolver<TestEnum>();

CommandLineParser/Core/Parsing/DefaultArgumentResolverFactory.cs

@@ -1,9 +1,9 @@
-using System;
-using System.Collections.Generic;
-using MatthiWare.CommandLine.Abstractions;
+using MatthiWare.CommandLine.Abstractions;
 using MatthiWare.CommandLine.Abstractions.Parsing;
 using MatthiWare.CommandLine.Core.Parsing.Resolvers;
 using MatthiWare.CommandLine.Core.Utils;
+using System;
+using System.Collections.Generic;
 
 namespace MatthiWare.CommandLine.Core.Parsing
 {
@@ -42,9 +42,17 @@ public ICommandLineArgumentResolver CreateResolver(Type type)
             {
                 bool isEnum = type.IsEnum;
 
-                var instance = isEnum ?
-                    (ICommandLineArgumentResolver)containerResolver.Resolve(m_types[typeof(Enum)].MakeGenericType(type)) :
-                    (ICommandLineArgumentResolver)containerResolver.Resolve(m_types[type]);
+                ICommandLineArgumentResolver instance = null;
+
+                if (!isEnum && !m_types.ContainsKey(type))
+                    instance = (ICommandLineArgumentResolver)containerResolver.Resolve(typeof(DefaultResolver<>).MakeGenericType(type));
+
+                if (instance == null)
+                {
+                    instance = isEnum ?
+                        (ICommandLineArgumentResolver)containerResolver.Resolve(m_types[typeof(Enum)].MakeGenericType(type)) :
+                        (ICommandLineArgumentResolver)containerResolver.Resolve(m_types[type]);
+                }
 
                 m_cache.Add(type, instance);
             }