Binder, using tokenized "LL(1)" grammar approach, now passes all current tests. Cleanup of old/unneeded files. Moved Binder project into J4JSoftware.Configuration.CommandLine namespace.

Author: markolbert

Binder.Tests/Binder.Tests.csproj

@@ -47,13 +47,16 @@
 	  <None Update="appConfig.json">
 	    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
 	  </None>
-	  <None Update="embeddedProperties.json">
+	  <None Update="test-files\embeddedProperties.json">
 	    <CopyToOutputDirectory>Always</CopyToOutputDirectory>
 	  </None>
-	  <None Update="singleProperties.json">
+	  <None Update="test-files\singleProperties.json">
 	    <CopyToOutputDirectory>Always</CopyToOutputDirectory>
 	  </None>
-	  <None Update="tokenizer.json">
+	  <None Update="test-files\parser.json">
+	    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+	  </None>
+	  <None Update="test-files\tokenizer.json">
 	    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
 	  </None>
 	</ItemGroup>

Binder.Tests/EmbeddedProperties.cs

@@ -17,7 +17,7 @@ public void Allocations( TestConfig config )
             Bind<EmbeddedTarget, TestFlagEnum>(x => x.Target1.AFlagEnumValue);
             Bind<EmbeddedTarget, List<string>>(x => x.Target1.ACollection);
 
-            ValidateAllocations();
+            ValidateTokenizing();
         }
 
         [Theory]

Binder.Tests/MiscAllocation.cs

@@ -0,0 +1,34 @@
+using FluentAssertions;
+using J4JSoftware.Configuration.CommandLine;
+using Xunit;
+
+namespace J4JSoftware.Binder.Tests
+{
+    public class MiscTests : BaseTest
+    {
+        [ Theory ]
+        [ InlineData( CommandLineStyle.Linux, "-x abc", "abc" ) ]
+        [ InlineData(CommandLineStyle.Linux, "-x \"abc\"", "abc" ) ]
+        public void StringHandling( CommandLineStyle style, string cmdLine, params string[] result )
+        {
+            Initialize(style);
+
+            var option = Options.Bind<MiscTarget, string?>( x => x.AStringValue, "x" );
+            option.Should().NotBeNull();
+            Options.Log.HasMessages().Should().BeFalse();
+
+            var parser = new Parser(Options, Logger);
+            parser.Parse( cmdLine ).Should().BeTrue();
+
+            Options.UnknownKeys.Should().BeEmpty();
+            Options.UnkeyedValues.Should().BeEmpty();
+
+            option!.Values.Count.Should().Be( result.Length );
+
+            for( var idx = 0; idx < result.Length; idx++ )
+            {
+                option.Values[ idx ].Should().Be( result[ idx ] );
+            }
+        }
+    }
+}

Binder.Tests/MiscTests.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using FluentAssertions;
+using J4JSoftware.Configuration.CommandLine;
+using Xunit;
+
+namespace J4JSoftware.Binder.Tests
+{
+    public class ParserTests : BaseTest
+    {
+        [Theory]
+        [MemberData(nameof(TestDataSource.GetTokenizerData), MemberType = typeof(TestDataSource))]
+        public void Tokenizer( TokenizerConfig config )
+        {
+            var cmdLogger = new CommandLineLogger();
+
+            var tokenizer = new Tokenizer(
+                AvailableTokens.GetDefault(CommandLineStyle.Windows, cmdLogger), 
+                cmdLogger,
+                new ConsolidateQuotedText(StringComparison.OrdinalIgnoreCase, cmdLogger),
+                new MergeSequentialSeparators(cmdLogger) );
+
+            var tokens = tokenizer.Tokenize( config.CommandLine );
+
+            tokens.Count.Should().Be( config.Data.Count );
+
+            for( var idx = 0; idx < tokens.Count; idx++ )
+            {
+                var token = tokens[ idx ];
+                token.Should().NotBeNull();
+
+                token!.Type.Should().Be( config.Data[ idx ].Type );
+                token!.Text.Should().Be( config.Data[ idx ].Text );
+            }
+        }
+
+        [ Theory ]
+        [ MemberData( nameof(TestDataSource.GetParserData), MemberType = typeof(TestDataSource) ) ]
+        public void Parser( TestConfig config )
+        {
+            Initialize(config);
+
+            var cmdLogger = new CommandLineLogger();
+            var parser = new Parser( Options, cmdLogger );
+
+            parser.Options.CreateOptionsFromContextKeys( config.OptionConfigurations );
+
+            parser.Parse( config.CommandLine ).Should().BeTrue();
+
+            ValidateConfiguration<BasicTarget>();
+        }
+    }
+}

Binder.Tests/ParserTests.cs

@@ -12,7 +12,7 @@ public void Allocations( TestConfig config )
 
             Options.CreateOptionsFromContextKeys( config.OptionConfigurations);
 
-            ValidateAllocations();
+            ValidateTokenizing();
         }
 
         [ Theory ]

Binder.Tests/SingleProperties.cs

@@ -2,7 +2,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using FluentAssertions;
-using J4JSoftware.CommandLine;
+using J4JSoftware.Configuration.CommandLine;
 using Microsoft.Extensions.Configuration;
 using Xunit;
 
@@ -11,12 +11,19 @@ namespace J4JSoftware.Binder.Tests
     public class BaseTest
     {
         protected TestConfig? TestConfig { get; private set; }
-        protected OptionCollection Options { get; } = new();
+        protected IOptionCollection Options { get; private set; }
+        protected CommandLineLogger Logger => Options.Log;
+
+        protected void Initialize(CommandLineStyle style)
+        {
+            Options = new OptionCollectionNG(style);
+            Options.Log.HasMessages().Should().BeFalse();
+        }
 
         protected void Initialize( TestConfig testConfig )
         {
+            Initialize( testConfig.Style );
             TestConfig = testConfig;
-            Options.Log.HasMessages().Should().BeFalse();
         }
 
         protected void Bind<TTarget, TProp>( Expression<Func<TTarget, TProp>> propSelector )
@@ -40,12 +47,13 @@ protected void Bind<TTarget, TProp>( Expression<Func<TTarget, TProp>> propSelect
             optConfig.Option = option;
         }
 
-        protected void ValidateAllocations()
+        protected void ValidateTokenizing()
         {
-            var result = Options.Allocator.AllocateCommandLine(TestConfig!.CommandLine!, Options!);
+            var parser = new Parser(Options, Logger);
+            parser.Parse( TestConfig!.CommandLine ).Should().Be( Options.UnknownKeys.Count == 0 );
 
-            result.UnknownKeys.Count.Should().Be( TestConfig.UnknownKeys );
-            result.UnkeyedParameters.Count.Should().Be( TestConfig.UnkeyedParameters );
+            Options.UnknownKeys.Count.Should().Be( TestConfig.UnknownKeys );
+            Options.UnkeyedValues.Count.Should().Be( TestConfig.UnkeyedValues );
 
             foreach( var optConfig in TestConfig.OptionConfigurations )
             {
@@ -64,7 +72,7 @@ protected void ValidateConfiguration<TParsed>()
 
             TParsed? parsed = null;
 
-            if( TestConfig!.OptionConfigurations.Any( x => x.ParsingWillFail ) )
+            if( TestConfig!.OptionConfigurations.Any( x => x.ConversionWillFail ) )
             {
                 var exception = Assert.Throws<InvalidOperationException>( () => config.Get<TParsed>() );
                 return;
@@ -73,7 +81,7 @@ protected void ValidateConfiguration<TParsed>()
             parsed = config.Get<TParsed>();
 
             if( TestConfig.OptionConfigurations.TrueForAll( x => !x.ValuesSatisfied )
-                && TestConfig.OptionConfigurations.All( x => x.Style != OptionStyle.Switch ) )
+                /*&& TestConfig.OptionConfigurations.All( x => x.Style != OptionStyle.Switch )*/ )
             {
                 parsed.Should().BeNull();
                 return;

Binder.Tests/new-alloc/TokenizerTests.cs

@@ -12,7 +12,7 @@ public static class TestDataSource
     {
         public static IEnumerable<object[]> GetSinglePropertyData()
         {
-            foreach ( var config in GetConfigurations<TestConfig>("singleProperties.json") )
+            foreach ( var config in GetConfigurations<TestConfig>("singleProperties.json").Skip(0) )
             {
                 yield return new object[] { config };
             }
@@ -28,17 +28,24 @@ public static IEnumerable<object[]> GetEmbeddedPropertyData()
 
         public static IEnumerable<object[]> GetTokenizerData()
         {
-            //yield return new object[] { GetConfigurations<TokenizerConfig>( "tokenizer.json" ).Last() };
             foreach (var config in GetConfigurations<TokenizerConfig>("tokenizer.json"))
             {
                 yield return new object[] { config };
             }
         }
 
+        public static IEnumerable<object[]> GetParserData()
+        {
+            foreach (var config in GetConfigurations<TestConfig>("parser.json"))
+            {
+                yield return new object[] { config };
+            }
+        }
+
         private static List<T> GetConfigurations<T>( string jsonFile )
             where T: class, new()
         {
-            var text = File.ReadAllText(Path.Combine(Environment.CurrentDirectory, jsonFile));
+            var text = File.ReadAllText(Path.Combine(Environment.CurrentDirectory,"test-files", jsonFile));
 
             return JsonSerializer.Deserialize<List<T>>(
                 text,

Binder.Tests/support/BaseTest.cs

@@ -1,5 +1,5 @@
 using System.Collections.Generic;
-using J4JSoftware.CommandLine;
+using J4JSoftware.Configuration.CommandLine;
 #pragma warning disable 8618
 
 namespace J4JSoftware.Binder.Tests
@@ -10,7 +10,7 @@ public class OptionConfig
         public string ContextPath { get; set; }
         public OptionStyle Style { get; set; }
         public bool Required { get; set; }
-        public bool ParsingWillFail { get; set; }
+        public bool ConversionWillFail { get; set; }
         public bool ValuesSatisfied { get; set; }
         public string? CorrectText { get; set; }
         public List<string> CorrectTextArray { get; set; }