Implemented AllocationResult class. Fixed problem in test caused by MasterTextCollection being a single instance.

markolbert · markolbert · commit 648160a66e3b · 2020-12-15T19:56:43.000-08:00
diff --git a/Binder.Tests/CompositionRoot.cs b/Binder.Tests/CompositionRoot.cs
@@ -51,15 +51,14 @@ private void ConfigureDependencyInjection( HostBuilderContext context, Container
                 .AsSelf();
 
             builder.RegisterType<MasterTextCollection>()
-                .OnActivated( x =>
+                .OnActivating( x =>
                 {
                     x.Instance.Initialize( StringComparison.OrdinalIgnoreCase );
                     x.Instance.AddRange( TextUsageType.Prefix, "-", "--" );
                     x.Instance.AddRange( TextUsageType.Quote, "\"", "'" );
                     x.Instance.AddRange( TextUsageType.ValueEncloser, "=" );
                 } )
-                .AsSelf()
-                .SingleInstance();
+                .AsSelf();
 
             builder.RegisterType<DefaultTypeInitializer>()
                 .AsImplementedInterfaces();
diff --git a/Binder.Tests/SwitchTests.cs b/Binder.Tests/SwitchTests.cs
@@ -0,0 +1,49 @@
+﻿using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Binder.Tests;
+using FluentAssertions;
+using J4JSoftware.CommandLine;
+using Xunit;
+
+namespace J4JSoftware.Binder.Tests
+{
+    public class SwitchTests : BaseTest
+    {
+        [Theory]
+        [InlineData("ASwitch", "x", "-x", OptionStyle.Switch, true, true, 0, 0)]
+        [InlineData("ASwitch", "x", "-z", OptionStyle.Switch, false, false, 1, 0)]
+        public void ByContextDefinition( 
+            string contextKey, 
+            string cmdLineKey, 
+            string cmdLine, 
+            OptionStyle style, 
+            bool allocResult,
+            bool valueAssigned,
+            int unknownKeys,
+            int unkeyedParams )
+        {
+            var options = CompositionRoot.Default.Options;
+
+            var option = options.Add( new SimpleContextKey( contextKey ) );
+
+            option.AddCommandLineKey( cmdLineKey )
+                .SetStyle( style );
+
+            var allocator = CompositionRoot.Default.Allocator;
+
+            var result = allocator.AllocateCommandLine( cmdLine, options );
+            
+            ( (bool) result ).Should().Be( allocResult );
+
+            option.WasAssignedValue.Should().Be( valueAssigned );
+
+            result.UnknownKeys.Count.Should().Be( unknownKeys );
+            result.UnkeyedParameters.Count.Should().Be( unkeyedParams );
+        }
+    }
+}
diff --git a/Binder.Tests/TestOne.cs b/Binder.Tests/TestOne.cs
diff --git a/Binder/allocating/AllocationResult.cs b/Binder/allocating/AllocationResult.cs
@@ -0,0 +1,12 @@
+﻿using System.Collections.Generic;
+
+namespace J4JSoftware.CommandLine
+{
+    public class AllocationResult
+    {
+        public static implicit operator bool( AllocationResult result ) => result.UnknownKeys.Count <= 0;
+
+        public List<string> UnkeyedParameters { get; } = new List<string>();
+        public List<string> UnknownKeys { get; } = new List<string>();
+    }
+}
diff --git a/Binder/allocating/Allocator.cs b/Binder/allocating/Allocator.cs
@@ -1,10 +1,10 @@
 ﻿using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices.ComTypes;
 using System.Text;
 using J4JSoftware.Logging;
+using Microsoft.VisualBasic;
 
 #pragma warning disable 8618
 
@@ -29,23 +29,13 @@ IJ4JLogger logger
             _logger.SetLoggedType( GetType() );
         }
 
-        public bool AllocateCommandLine( string[] args, Options options, out List<string>? unkeyed )
-        {
-            unkeyed = null;
-
-            if( !AllocateCommandLine( string.Join( " ", args ), options, out var temp ) )
-                return false;
+        public AllocationResult AllocateCommandLine( string[] args, Options options ) =>
+            AllocateCommandLine( string.Join( " ", args ), options );
 
-            unkeyed = temp;
-
-            return true;
-        }
-
-        public bool AllocateCommandLine( string cmdLine, Options options, out List<string>? unkeyed )
+        public AllocationResult AllocateCommandLine( string cmdLine, Options options )
         {
-            unkeyed = null;
-            var unkeyedInternal = new List<string>();
-
+            var retVal = new AllocationResult();
+            
             var accumulator = new StringBuilder();
             Option? curOption = null;
             var charsProcessed = 0;
@@ -78,23 +68,24 @@ public bool AllocateCommandLine( string cmdLine, Options options, out List<strin
 
                     // if the key (contained in element) isn't among the keys defined
                     // in the options collection we have a problem
-                    if( !options.UsesCommandLineKey( element ) )
+                    if( options.UsesCommandLineKey( element ) )
                     {
-                        _logger.Error<string>( "Unknown key '{0}'", element );
-                        return false;
-                    }
+                        curOption = options[element];
+                        curOption!.CommandLineKeyProvided = element;
 
-                    curOption = options[ element ];
-
-                    curOption!.CommandLineKeyUsed = element;
-
-                    lastElementWasKey = true;
+                        lastElementWasKey = true;
+                    }
+                    else
+                    {
+                        retVal.UnknownKeys.Add( element );
+                        _logger.Error<string>("Unknown key '{0}'", element);
+                    }
                 }
                 else
                 {
                     // element is parameter value
                     if( curOption == null || !lastElementWasKey )
-                        unkeyedInternal.Add( element );
+                        retVal.UnkeyedParameters.Add( element );
                     else curOption.AddAllocatedValue( element );
 
                     lastElementWasKey = false;
@@ -104,9 +95,7 @@ public bool AllocateCommandLine( string cmdLine, Options options, out List<strin
                 accumulator.Clear();
             }
 
-            unkeyed = unkeyedInternal;
-
-            return true;
+            return retVal;
         }
     }
 }
diff --git a/Binder/allocating/IAllocator.cs b/Binder/allocating/IAllocator.cs
@@ -6,7 +6,7 @@ namespace J4JSoftware.CommandLine
     // defines the interface for an object used to parse a command line
     public interface IAllocator
     {
-        bool AllocateCommandLine(string[] args, Options options, out List<string>? unkeyed);
-        bool AllocateCommandLine(string cmdLine, Options options, out List<string>? unkeyed);
+        AllocationResult AllocateCommandLine( string[] args, Options options );
+        AllocationResult AllocateCommandLine( string cmdLine, Options options );
     }
 }
diff --git a/Binder/options/Option.cs b/Binder/options/Option.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Linq;
 
 namespace J4JSoftware.CommandLine
@@ -9,11 +10,19 @@ public class Option
     {
         private readonly List<string> _cmdLineKeys = new List<string>();
         private readonly List<string> _allocatedValues = new List<string>();
+        private readonly MasterTextCollection _masterText;
 
-        internal Option( Options container, IContextKey contextKey )
+        private int _allowedNumValues;
+
+        internal Option( 
+            Options container, 
+            IContextKey contextKey,
+            MasterTextCollection masterText 
+            )
         {
             Container = container;
             ContextKey = contextKey;
+            _masterText = masterText;
 
             if( Container.UsesContextPath( ContextPath! ) )
                 throw new ArgumentException( $"Duplicate context key path '{ContextPath}'" );
@@ -52,19 +61,43 @@ public List<IContextKey>? ContextPath
         // but they must be unique within the scope of all Options)
         public string FirstKey => _cmdLineKeys.OrderBy( k => k ).First();
 
-        public string? CommandLineKeyUsed { get; set; }
+        public string? CommandLineKeyProvided { get; set; }
+
+        public bool WasAssignedValue
+        {
+            get
+            {
+                if( string.IsNullOrEmpty( CommandLineKeyProvided ) )
+                    return false;
+
+                var numValuesAlloc = _allocatedValues.Count;
+
+                return Style switch
+                {
+                    OptionStyle.Switch => numValuesAlloc == 0,
+                    OptionStyle.SingleValued => numValuesAlloc == 1,
+                    OptionStyle.Collection => numValuesAlloc > 0,
+                    _ => throw new InvalidEnumArgumentException($"Unsupported OptionStyle '{Style}'")
+                };
+            }
+        }
+        
         public ReadOnlyCollection<string> CommandLineValues => _allocatedValues.AsReadOnly();
 
-        public int AllowedNumberOfValues { get; private set; }
+        public OptionStyle Style { get; private set; }
+
         public bool Required { get; private set; }
         public string? Description { get; private set; }
 
         internal void AddAllocatedValue( string value ) => _allocatedValues.Add( value );
 
         public Option AddCommandLineKey(string cmdLineKey)
         {
-            if (!Container.UsesCommandLineKey(cmdLineKey))
+            if( !Container.UsesCommandLineKey( cmdLineKey ) )
+            {
                 _cmdLineKeys.Add(cmdLineKey);
+                _masterText.Add( TextUsageType.OptionKey, cmdLineKey );
+            }
 
             return this;
         }
@@ -79,21 +112,16 @@ public Option AddCommandLineKeys(params string[] cmdLineKeys)
             return this;
         }
 
-        public Option IsSwitch()
-        {
-            AllowedNumberOfValues = 0;
-            return this;
-        }
-
-        public Option IsCollection()
+        public Option SetStyle( OptionStyle style )
         {
-            AllowedNumberOfValues = Int32.MaxValue;
-            return this;
-        }
+            _allowedNumValues = style switch
+            {
+                OptionStyle.Collection => Int32.MaxValue,
+                OptionStyle.SingleValued => 1,
+                OptionStyle.Switch => 0,
+                _ => throw new InvalidEnumArgumentException( $"Unsupported OptionStyle '{style}'" )
+            };
 
-        public Option IsSingleValue()
-        {
-            AllowedNumberOfValues = 1;
             return this;
         }
 
diff --git a/Binder/options/Options.cs b/Binder/options/Options.cs
@@ -69,7 +69,7 @@ public Option? this[ string key ]
 
         public Option Add(IContextKey contextKey )
         {
-            var retVal = new Option( this, contextKey );
+            var retVal = new Option( this, contextKey, _masterText );
 
             _options.Add(retVal);
 
diff --git a/Binder/options/SimpleContextKey.cs b/Binder/options/SimpleContextKey.cs
@@ -0,0 +1,12 @@
+﻿namespace J4JSoftware.CommandLine
+{
+    public class SimpleContextKey : IContextKey
+    {
+        public SimpleContextKey( string contextKey )
+        {
+            Text = contextKey;
+        }
+
+        public string Text { get; }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ namespace J4JSoftware.CommandLine`
`6`	`6`	`// defines the interface for an object used to parse a command line`
`7`	`7`	`public interface IAllocator`
`8`	`8`	`{`
`9`		`- bool AllocateCommandLine(string[] args, Options options, out List<string>? unkeyed);`
`10`		`- bool AllocateCommandLine(string cmdLine, Options options, out List<string>? unkeyed);`
	`9`	`+ AllocationResult AllocateCommandLine( string[] args, Options options );`
	`10`	`+ AllocationResult AllocateCommandLine( string cmdLine, Options options );`
`11`	`11`	`}`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ public Option? this[ string key ]`
`69`	`69`
`70`	`70`	`public Option Add(IContextKey contextKey )`
`71`	`71`	`{`
`72`		`- var retVal = new Option( this, contextKey );`
	`72`	`+ var retVal = new Option( this, contextKey, _masterText );`
`73`	`73`
`74`	`74`	`_options.Add(retVal);`
`75`	`75`