✅ Makes parsing work

Author: Matthiee

CommandLineParser.Tests/CommandLineArgumentOptionTest.cs

@@ -3,7 +3,7 @@
 using System.Text;
 using Xunit;
 
-namespace CommandLineParser.Tests
+namespace MatthiWare.CommandLineParser.Tests
 {
 
     public class CommandLineArgumentOptionTest

CommandLineParser.Tests/UnitTest1.cs …mmandLineParser.Tests/ExtensionsTests.csCommandLineParser.Tests/UnitTest1.cs renamed to CommandLineParser.Tests/ExtensionsTests.cs CommandLineParser.Tests/UnitTest1.cs renamed to CommandLineParser.Tests/ExtensionsTests.cs

@@ -5,9 +5,9 @@
 using Moq;
 using Xunit;
 
-namespace CommandLineParser.Tests
+namespace MatthiWare.CommandLineParser.Tests
 {
-    public class UnitTest1
+    public class ExtensionsTests
     {
         [Fact]
         public void Test1()
@@ -72,7 +72,7 @@ public void TestV1()
         {
             var testString = "this is my test string \"with some quotes\" the end. '\"Here is some literal\"' ";
 
-            var resultArr = new string[] { "this", "is", "my", "test", "string", "with some quotes", "the", "end.", "\"Here is some literal\"" };
+            var resultArr = new string[] { "this", "is", "my", "test", "string", "with some quotes", "the", "end.", "\"Here is some literal\"", " " };
 
             int i = 0;
             foreach (var token in Extensions.SplitOnWhitespace(testString))
@@ -86,6 +86,7 @@ public void TestV1()
         [Theory]
         [InlineData("\"with some quotes\"", "with some quotes")]
         [InlineData("'\"with some quotes\"'", "\"with some quotes\"")]
+        [InlineData("test", "test")]
         public void TestRemoveLiteralAndDoubleQuotes(string input, string result)
         {
             Assert.Equal(result, input.AsSpan().RemoveLiteralsAndQuotes());

CommandLineParser.Tests/OptionBuilderTest.cs

@@ -7,7 +7,7 @@
 using Moq;
 using Xunit;
 
-namespace CommandLineParser.Tests
+namespace MatthiWare.CommandLineParser.Tests
 {
     public class OptionBuilderTest
     {

CommandLineParser.Tests/Parsing/Resolvers/StringResovlerTests.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using MatthiWare.CommandLine.Abstractions.Models;
+using MatthiWare.CommandLine.Core.Parsing.Resolvers;
+using Xunit;
+
+namespace MatthiWare.CommandLineParser.Tests.Parsing.Resolvers
+{
+    public class StringResovlerTests
+    {
+
+        [Theory]
+        [InlineData(true, "-m", "test")]
+        public void TestCanResolve(bool expected, string key, string value)
+        {
+            var resolver = new StringResolver();
+            var model = new ArgumentModel(key, value);
+
+            Assert.Equal(expected, resolver.CanResolve(model));
+        }
+
+        [Theory]
+        [InlineData("test", "-m", "test")]
+        public void TestResolve(string expected, string key, string value)
+        {
+            var resolver = new StringResolver();
+            var model = new ArgumentModel(key, value);
+
+            Assert.Equal(expected, resolver.Resolve(model));
+        }
+
+    }
+}

CommandLineParser/Abstractions/Models/ArgumentModel.cs

@@ -4,35 +4,24 @@
 
 namespace MatthiWare.CommandLine.Abstractions.Models
 {
-    public class ArgumentModel
+    public struct ArgumentModel
     {
-        private string m_value = null;
-
-
         public string Key { get; set; }
 
+        public string Value { get; set; }
 
-        public string Value
-        {
-            get => m_value;
-            set
-            {
-                HasValue = true;
-                m_value = value;
-            }
-        }
-
-        public bool HasValue { get; private set; }
+        public bool HasValue => Value != null;
 
         public ArgumentModel(string key, string value)
         {
             this.Key = key;
             this.Value = value;
         }
 
-        public ArgumentModel()
+        public ArgumentModel(string key)
         {
-
+            this.Key = key;
+            this.Value = null;
         }
 
     }

CommandLineParser/Abstractions/Parsing/IParser.cs

@@ -7,6 +7,7 @@ namespace MatthiWare.CommandLine.Abstractions.Parsing
 {
     public interface IParser
     {
+        bool CanParse(ArgumentModel model);
         void Parse(ArgumentModel model);
     }
 }

CommandLineParser/CommandLineParser.cs

@@ -5,6 +5,7 @@
 using System.Runtime.CompilerServices;
 using System.Text;
 using MatthiWare.CommandLine.Abstractions;
+using MatthiWare.CommandLine.Abstractions.Models;
 using MatthiWare.CommandLine.Abstractions.Parsing;
 using MatthiWare.CommandLine.Core;
 using MatthiWare.CommandLine.Core.Parsing;
@@ -66,13 +67,27 @@ public IParserResult<TSource> Parse(string[] args)
                     (option.HasShortName && string.Equals(option.ShortName, arg, StringComparison.InvariantCultureIgnoreCase)) ||
                     (option.HasLongName && string.Equals(option.LongName, arg, StringComparison.InvariantCultureIgnoreCase)));
 
-                if (idx < 0 && option.IsRequired)
+                if ((idx < 0 || idx > lstArgs.Count) && option.IsRequired)
                 {
                     errors.Add(new KeyNotFoundException($"Required argument '{option.HasShortName}' or '{option.LongName}' not found"));
                     continue;
                 }
 
-                var argument = lstArgs[idx];
+                var key = lstArgs[idx];
+                var value = ++idx < lstArgs.Count ? lstArgs[idx] : null;
+
+                var argModel = new ArgumentModel(key, value);
+
+                var parser = option as IParser;
+
+                if (!parser.CanParse(argModel))
+                {
+                    errors.Add(new ArgumentException($"Cannot parse option '{argModel.Key}:{argModel.Value ?? "NULL"}'"));
+
+                    continue;
+                }
+
+                parser.Parse(argModel);
             }
 
             if (errors.Any())

CommandLineParser/Core/CommandLineArgumentOption.cs

@@ -44,12 +44,11 @@ public TProperty DefaultValue
 
         public bool HasLongName => !string.IsNullOrWhiteSpace(LongName);
 
-        public void Parse(ArgumentModel model)
-        {
-            if (!resolver.CanResolve(model)) throw new ArgumentException("Invalid argument option", nameof(model));
-
+        public bool CanParse(ArgumentModel model)
+            => resolver.CanResolve(model);
 
-        }
+        public void Parse(ArgumentModel model)
+            => AssignValue(resolver.Resolve(model));
 
         IOptionBuilder<TProperty> IOptionBuilder<TProperty>.Default(TProperty defaultValue)
         {

CommandLineParser/Core/Extensions.cs

@@ -78,7 +78,7 @@ private static string FindNextWord(ReadOnlySpan<char> src, out int read)
                 }
             }
 
-            return null;
+            return src.ToString();
         }
 
         public static ReadOnlySpan<char> Substring(this ReadOnlySpan<char> src, int start, int len)
@@ -95,12 +95,16 @@ public static string RemoveLiteralsAndQuotes(this ReadOnlySpan<char> value)
             int startTrim = 0, endTrim = 0;
             int len = value.Length - 1;
 
+            if (value.Length == 0) return new string(value.ToArray());
+
             if (value[0] == DoubleQuote || value[0] == SingleQuote)
                 startTrim = 1;
 
             if (value[len] == DoubleQuote || value[len] == SingleQuote)
                 endTrim = 1;
 
+            if (startTrim == 0 && endTrim == 0) return new string(value.ToArray());
+
             return new string(value.Substring(startTrim, len - endTrim).ToArray());
         }