Eliminated IJ4JLogger in favor of a simple message collector.

markolbert · markolbert · commit f9576e723af9 · 2020-12-20T09:52:06.000-08:00
diff --git a/Binder.Tests/support/BaseTest.cs b/Binder.Tests/support/BaseTest.cs
@@ -63,7 +63,7 @@ protected void ValidateConfiguration<TParsed>()
             where TParsed : class, new()
         {
             var configBuilder = new ConfigurationBuilder();
-            configBuilder.AddJ4JCommandLine( Options!, TestConfig!.CommandLine, _allocator! );
+            configBuilder.AddJ4JCommandLine( TestConfig!.CommandLine, out var options, out var logger);
             var config = configBuilder.Build();
 
             TParsed? parsed = null;
diff --git a/Binder/Binder.csproj b/Binder/Binder.csproj
@@ -23,7 +23,11 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\J4JLogging\J4JLogging\J4JLogging.csproj" />
+    <Folder Include="options\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="5.0.0" />
   </ItemGroup>
 
 </Project>
diff --git a/Binder/CommandLineLogger.cs b/Binder/CommandLineLogger.cs
@@ -0,0 +1,15 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace J4JSoftware.CommandLine
+{
+    public class CommandLineLogger
+    {
+        private readonly List<string> _messages = new List<string>();
+
+        public void Log( string mesg ) => _messages.Add( mesg );
+    }
+}
diff --git a/Binder/J4JCommandLineExtensions.cs b/Binder/J4JCommandLineExtensions.cs
@@ -1,15 +1,23 @@
-﻿using Microsoft.Extensions.Configuration;
+﻿using System.Runtime.InteropServices.ComTypes;
+using Microsoft.Extensions.Configuration;
 
 namespace J4JSoftware.CommandLine
 {
     public static class J4JCommandLineExtensions
     {
-        public static IConfigurationBuilder AddJ4JCommandLine( 
-            this IConfigurationBuilder builder, 
+        public static IConfigurationBuilder AddJ4JCommandLine(
+            this IConfigurationBuilder builder,
+            string cmdLine,
             OptionCollection options,
-            string cmdLine, 
-            IAllocator allocator)
+            out CommandLineLogger logger,
+            IAllocator? allocator = null )
         {
+            var masterText = new MasterTextCollection();
+            logger = new CommandLineLogger();
+            
+            allocator ??= new Allocator( new ElementTerminator( masterText, logger ),
+                new KeyPrefixer( masterText, logger ), logger );
+
             builder.Add( new J4JCommandLineSource( options, cmdLine, allocator ) );
             
             return builder;
diff --git a/Binder/J4JCommandLineSource.cs b/Binder/J4JCommandLineSource.cs
@@ -5,7 +5,6 @@
 using System.Threading.Tasks;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Primitives;
-using Twilio.Rest.Api.V2010.Account.Sip.Domain.AuthTypes.AuthTypeCalls;
 
 namespace J4JSoftware.CommandLine
 {
diff --git a/Binder/OptionCollection.cs b/Binder/OptionCollection.cs
@@ -5,7 +5,6 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Text;
-using J4JSoftware.Logging;
 
 namespace J4JSoftware.CommandLine
 {
@@ -34,16 +33,15 @@ public int GetHashCode(ITypeBoundOption obj)
 
         public OptionCollection( 
             MasterTextCollection masterText,
-            IJ4JLogger logger
+            CommandLineLogger logger
         )
         {
             MasterText = masterText;
 
             Logger = logger;
-            Logger.SetLoggedType( GetType() );
         }
 
-        protected IJ4JLogger Logger { get; }
+        protected CommandLineLogger Logger { get; }
         protected MasterTextCollection MasterText { get; }
         protected List<IOption> Options { get; } = new();
 
@@ -105,7 +103,7 @@ public bool Bind<TTarget, TProp>(
 
                         if( !ValidateProperty( propInfo, bindNonPublic, out var curStyle ) )
                         {
-                            Logger.Error<string>( "Property '{0}' is invalid", propInfo.Name );
+                            Logger.Log( $"Property '{propInfo.Name}' is invalid");
                             return false;
                         }
 
@@ -125,7 +123,7 @@ public bool Bind<TTarget, TProp>(
 
                             if (!ValidateProperty(propInfo2, bindNonPublic, out var curStyle2))
                             {
-                                Logger.Error<string>("Property '{0}' is invalid", propInfo2.Name);
+                                Logger.Log($"Property '{propInfo2.Name}' is invalid");
                                 return false;
                             }
 
@@ -168,7 +166,7 @@ public bool UsesContextPath( string contextPath )
         {
             if( !MasterText.IsValid )
             {
-                Logger.Error( "MasterTextCollection is not initialized" );
+                Logger.Log( "MasterTextCollection is not initialized" );
                 return false;
             }
 
@@ -182,7 +180,7 @@ public IOption? this[ string key ]
             {
                 if (!MasterText.IsValid)
                 {
-                    Logger.Error("MasterTextCollection is not initialized");
+                    Logger.Log("MasterTextCollection is not initialized");
                     return null;
                 }
 
@@ -238,7 +236,7 @@ private bool ValidateGenericType(Type genType, out OptionStyle? style)
 
             if (genType.GenericTypeArguments.Length != 1)
             {
-                Logger.Error("Generic type '{0}' does not have just one generic Type argument", genType);
+                Logger.Log($"Generic type '{genType.Name}' does not have just one generic Type argument");
                 return false;
             }
 
@@ -247,7 +245,7 @@ private bool ValidateGenericType(Type genType, out OptionStyle? style)
 
             if (!typeof(List<>).MakeGenericType(genType.GenericTypeArguments[0]).IsAssignableFrom(genType))
             {
-                Logger.Error("Generic type '{0}' is not a List<> type", genType);
+                Logger.Log($"Generic type '{genType}' is not a List<> type");
                 return false;
             }
 
@@ -269,7 +267,7 @@ private bool ValidateType(Type toCheck)
                 || toCheck.GetConstructors().Any( c => c.GetParameters().Length == 0 ) )
                 return true;
 
-            Logger.Error("Unsupported type '{0}'", toCheck);
+            Logger.Log($"Unsupported type '{toCheck}'");
 
             return false;
         }
@@ -278,19 +276,19 @@ private bool ValidateAccessMethod(MethodInfo? methodInfo, bool bindNonPublic, st
         {
             if (methodInfo == null)
             {
-                Logger.Error<string>("Property '{0}' does not have a get or set method", propName);
+                Logger.Log($"Property '{propName}' does not have a get or set method");
                 return false;
             }
 
             if (!methodInfo.IsPublic && !bindNonPublic)
             {
-                Logger.Error<string>("Property '{0}::{1}' is not bindable", propName, methodInfo.Name);
+                Logger.Log($"Property '{propName}::{methodInfo.Name}' is not bindable");
                 return false;
             }
 
             if (methodInfo.GetParameters().Length > allowedParams)
             {
-                Logger.Error<string>("Property '{0}::{1}' is indexed", propName, methodInfo.Name);
+                Logger.Log($"Property '{propName}::{methodInfo.Name}' is indexed");
                 return false;
             }
 
diff --git a/Binder/allocating/Allocator.cs b/Binder/allocating/Allocator.cs
@@ -3,7 +3,6 @@
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices.ComTypes;
 using System.Text;
-using J4JSoftware.Logging;
 using Microsoft.VisualBasic;
 
 #pragma warning disable 8618
@@ -14,19 +13,18 @@ public class Allocator : IAllocator
     {
         private readonly IElementTerminator _terminator;
         private readonly IKeyPrefixer _prefixer;
-        private readonly IJ4JLogger _logger;
+        private readonly CommandLineLogger _logger;
 
         public Allocator( 
             IElementTerminator terminator,
             IKeyPrefixer prefixer,
-            IJ4JLogger logger
+            CommandLineLogger logger
             )
         {
             _terminator = terminator;
             _prefixer = prefixer;
 
             _logger = logger;
-            _logger.SetLoggedType( GetType() );
         }
 
         public AllocationResult AllocateCommandLine( string cmdLine, OptionCollection options )
@@ -72,7 +70,7 @@ public AllocationResult AllocateCommandLine( string cmdLine, OptionCollection op
                     else
                     {
                         retVal.UnknownKeys.Add( element );
-                        _logger.Error<string>("Unknown key '{0}'", element);
+                        _logger.Log($"Unknown key '{element}'");
                     }
                 }
                 else
diff --git a/Binder/allocating/ElementTerminator.cs b/Binder/allocating/ElementTerminator.cs
@@ -3,7 +3,6 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text;
-using J4JSoftware.Logging;
 
 #pragma warning disable 8618
 
@@ -12,24 +11,23 @@ namespace J4JSoftware.CommandLine
     public class ElementTerminator : IElementTerminator
     {
         private readonly MasterTextCollection _masterText;
-        private readonly IJ4JLogger _logger;
+        private readonly CommandLineLogger _logger;
 
         public ElementTerminator( 
             MasterTextCollection masterText,
-            IJ4JLogger logger
+            CommandLineLogger logger
             )
         {
             _masterText = masterText;
 
             _logger = logger;
-            _logger.SetLoggedType( GetType() );
         }
 
         public int GetMaxTerminatorLength( string text, bool isKey )
         {
             if( !_masterText.IsValid )
             {
-                _logger.Error("MasterTextCollection is not initialized"  );
+                _logger.Log("MasterTextCollection is not initialized"  );
                 throw new TypeInitializationException( "MasterTextCollection is not initialized", null );
             }
 
diff --git a/Binder/allocating/KeyPrefixer.cs b/Binder/allocating/KeyPrefixer.cs
@@ -1,6 +1,5 @@
 ﻿using System;
 using System.Linq;
-using J4JSoftware.Logging;
 
 #pragma warning disable 8618
 
@@ -9,23 +8,22 @@ namespace J4JSoftware.CommandLine
     public class KeyPrefixer : IKeyPrefixer
     {
         private readonly MasterTextCollection _masterText;
-        private readonly IJ4JLogger _logger;
+        private readonly CommandLineLogger _logger;
 
         public KeyPrefixer(
             MasterTextCollection masterText,
-            IJ4JLogger logger
+            CommandLineLogger logger
         )
         {
             _masterText = masterText;
 
             _logger = logger;
-            _logger.SetLoggedType(GetType());
 
             if( _masterText[ TextUsageType.Prefix ].Any() ) return;
 
             var mesg =
                 $"{nameof(masterText)} ({typeof(MasterTextCollection)}) does not define any {nameof(TextUsageType.Prefix)} entries";
-            _logger.Fatal( mesg );
+            _logger.Log( mesg );
 
             throw new ArgumentException( mesg );
         }
@@ -34,7 +32,7 @@ public int GetMaxPrefixLength( string text )
         {
             if (!_masterText.IsValid)
             {
-                _logger.Error("MasterTextCollection is not initialized");
+                _logger.Log("MasterTextCollection is not initialized");
                 throw new TypeInitializationException("MasterTextCollection is not initialized", null);
             }
 

Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ protected void ValidateConfiguration<TParsed>()`
`63`	`63`	`where TParsed : class, new()`
`64`	`64`	`{`
`65`	`65`	`var configBuilder = new ConfigurationBuilder();`
`66`		`- configBuilder.AddJ4JCommandLine( Options!, TestConfig!.CommandLine, _allocator! );`
	`66`	`+ configBuilder.AddJ4JCommandLine( TestConfig!.CommandLine, out var options, out var logger);`
`67`	`67`	`var config = configBuilder.Build();`
`68`	`68`
`69`	`69`	`TParsed? parsed = null;`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,6 @@`
`5`	`5`	`using System.Threading.Tasks;`
`6`	`6`	`using Microsoft.Extensions.Configuration;`
`7`	`7`	`using Microsoft.Extensions.Primitives;`
`8`		`-using Twilio.Rest.Api.V2010.Account.Sip.Domain.AuthTypes.AuthTypeCalls;`
`9`	`8`
`10`	`9`	`namespace J4JSoftware.CommandLine`
`11`	`10`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,6 @@`
`5`	`5`	`using System.Linq.Expressions;`
`6`	`6`	`using System.Reflection;`
`7`	`7`	`using System.Text;`
`8`		`-using J4JSoftware.Logging;`
`9`	`8`
`10`	`9`	`namespace J4JSoftware.CommandLine`
`11`	`10`	`{`
`@@ -34,16 +33,15 @@ public int GetHashCode(ITypeBoundOption obj)`
`34`	`33`
`35`	`34`	`public OptionCollection(`
`36`	`35`	`MasterTextCollection masterText,`
`37`		`- IJ4JLogger logger`
	`36`	`+ CommandLineLogger logger`
`38`	`37`	`)`
`39`	`38`	`{`
`40`	`39`	`MasterText = masterText;`
`41`	`40`
`42`	`41`	`Logger = logger;`
`43`		`- Logger.SetLoggedType( GetType() );`
`44`	`42`	`}`
`45`	`43`
`46`		`- protected IJ4JLogger Logger { get; }`
	`44`	`+ protected CommandLineLogger Logger { get; }`
`47`	`45`	`protected MasterTextCollection MasterText { get; }`
`48`	`46`	`protected List<IOption> Options { get; } = new();`
`49`	`47`
`@@ -105,7 +103,7 @@ public bool Bind<TTarget, TProp>(`
`105`	`103`
`106`	`104`	`if( !ValidateProperty( propInfo, bindNonPublic, out var curStyle ) )`
`107`	`105`	`{`
`108`		`- Logger.Error<string>( "Property '{0}' is invalid", propInfo.Name );`
	`106`	`+ Logger.Log( $"Property '{propInfo.Name}' is invalid");`
`109`	`107`	`return false;`
`110`	`108`	`}`
`111`	`109`
`@@ -125,7 +123,7 @@ public bool Bind<TTarget, TProp>(`
`125`	`123`
`126`	`124`	`if (!ValidateProperty(propInfo2, bindNonPublic, out var curStyle2))`
`127`	`125`	`{`
`128`		`- Logger.Error<string>("Property '{0}' is invalid", propInfo2.Name);`
	`126`	`+ Logger.Log($"Property '{propInfo2.Name}' is invalid");`
`129`	`127`	`return false;`
`130`	`128`	`}`
`131`	`129`
`@@ -168,7 +166,7 @@ public bool UsesContextPath( string contextPath )`
`168`	`166`	`{`
`169`	`167`	`if( !MasterText.IsValid )`
`170`	`168`	`{`
`171`		`- Logger.Error( "MasterTextCollection is not initialized" );`
	`169`	`+ Logger.Log( "MasterTextCollection is not initialized" );`
`172`	`170`	`return false;`
`173`	`171`	`}`
`174`	`172`
`@@ -182,7 +180,7 @@ public IOption? this[ string key ]`
`182`	`180`	`{`
`183`	`181`	`if (!MasterText.IsValid)`
`184`	`182`	`{`
`185`		`- Logger.Error("MasterTextCollection is not initialized");`
	`183`	`+ Logger.Log("MasterTextCollection is not initialized");`
`186`	`184`	`return null;`
`187`	`185`	`}`
`188`	`186`
`@@ -238,7 +236,7 @@ private bool ValidateGenericType(Type genType, out OptionStyle? style)`
`238`	`236`
`239`	`237`	`if (genType.GenericTypeArguments.Length != 1)`
`240`	`238`	`{`
`241`		`- Logger.Error("Generic type '{0}' does not have just one generic Type argument", genType);`
	`239`	`+ Logger.Log($"Generic type '{genType.Name}' does not have just one generic Type argument");`
`242`	`240`	`return false;`
`243`	`241`	`}`
`244`	`242`
`@@ -247,7 +245,7 @@ private bool ValidateGenericType(Type genType, out OptionStyle? style)`
`247`	`245`
`248`	`246`	`if (!typeof(List<>).MakeGenericType(genType.GenericTypeArguments[0]).IsAssignableFrom(genType))`
`249`	`247`	`{`
`250`		`- Logger.Error("Generic type '{0}' is not a List<> type", genType);`
	`248`	`+ Logger.Log($"Generic type '{genType}' is not a List<> type");`
`251`	`249`	`return false;`
`252`	`250`	`}`
`253`	`251`
`@@ -269,7 +267,7 @@ private bool ValidateType(Type toCheck)`
`269`	`267`	`\|\| toCheck.GetConstructors().Any( c => c.GetParameters().Length == 0 ) )`
`270`	`268`	`return true;`
`271`	`269`
`272`		`- Logger.Error("Unsupported type '{0}'", toCheck);`
	`270`	`+ Logger.Log($"Unsupported type '{toCheck}'");`
`273`	`271`
`274`	`272`	`return false;`
`275`	`273`	`}`
`@@ -278,19 +276,19 @@ private bool ValidateAccessMethod(MethodInfo? methodInfo, bool bindNonPublic, st`
`278`	`276`	`{`
`279`	`277`	`if (methodInfo == null)`
`280`	`278`	`{`
`281`		`- Logger.Error<string>("Property '{0}' does not have a get or set method", propName);`
	`279`	`+ Logger.Log($"Property '{propName}' does not have a get or set method");`
`282`	`280`	`return false;`
`283`	`281`	`}`
`284`	`282`
`285`	`283`	`if (!methodInfo.IsPublic && !bindNonPublic)`
`286`	`284`	`{`
`287`		`- Logger.Error<string>("Property '{0}::{1}' is not bindable", propName, methodInfo.Name);`
	`285`	`+ Logger.Log($"Property '{propName}::{methodInfo.Name}' is not bindable");`
`288`	`286`	`return false;`
`289`	`287`	`}`
`290`	`288`
`291`	`289`	`if (methodInfo.GetParameters().Length > allowedParams)`
`292`	`290`	`{`
`293`		`- Logger.Error<string>("Property '{0}::{1}' is indexed", propName, methodInfo.Name);`
	`291`	`+ Logger.Log($"Property '{propName}::{methodInfo.Name}' is indexed");`
`294`	`292`	`return false;`
`295`	`293`	`}`
`296`	`294`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`	`using System.Runtime.CompilerServices;`
`4`	`4`	`using System.Runtime.InteropServices.ComTypes;`
`5`	`5`	`using System.Text;`
`6`		`-using J4JSoftware.Logging;`
`7`	`6`	`using Microsoft.VisualBasic;`
`8`	`7`
`9`	`8`	`#pragma warning disable 8618`
`@@ -14,19 +13,18 @@ public class Allocator : IAllocator`
`14`	`13`	`{`
`15`	`14`	`private readonly IElementTerminator _terminator;`
`16`	`15`	`private readonly IKeyPrefixer _prefixer;`
`17`		`- private readonly IJ4JLogger _logger;`
	`16`	`+ private readonly CommandLineLogger _logger;`
`18`	`17`
`19`	`18`	`public Allocator(`
`20`	`19`	`IElementTerminator terminator,`
`21`	`20`	`IKeyPrefixer prefixer,`
`22`		`- IJ4JLogger logger`
	`21`	`+ CommandLineLogger logger`
`23`	`22`	`)`
`24`	`23`	`{`
`25`	`24`	`_terminator = terminator;`
`26`	`25`	`_prefixer = prefixer;`
`27`	`26`
`28`	`27`	`_logger = logger;`
`29`		`- _logger.SetLoggedType( GetType() );`
`30`	`28`	`}`
`31`	`29`
`32`	`30`	`public AllocationResult AllocateCommandLine( string cmdLine, OptionCollection options )`
`@@ -72,7 +70,7 @@ public AllocationResult AllocateCommandLine( string cmdLine, OptionCollection op`
`72`	`70`	`else`
`73`	`71`	`{`
`74`	`72`	`retVal.UnknownKeys.Add( element );`
`75`		`- _logger.Error<string>("Unknown key '{0}'", element);`
	`73`	`+ _logger.Log($"Unknown key '{element}'");`
`76`	`74`	`}`
`77`	`75`	`}`
`78`	`76`	`else`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`	`using System.Collections.ObjectModel;`
`4`	`4`	`using System.Linq;`
`5`	`5`	`using System.Text;`
`6`		`-using J4JSoftware.Logging;`
`7`	`6`
`8`	`7`	`#pragma warning disable 8618`
`9`	`8`
`@@ -12,24 +11,23 @@ namespace J4JSoftware.CommandLine`
`12`	`11`	`public class ElementTerminator : IElementTerminator`
`13`	`12`	`{`
`14`	`13`	`private readonly MasterTextCollection _masterText;`
`15`		`- private readonly IJ4JLogger _logger;`
	`14`	`+ private readonly CommandLineLogger _logger;`
`16`	`15`
`17`	`16`	`public ElementTerminator(`
`18`	`17`	`MasterTextCollection masterText,`
`19`		`- IJ4JLogger logger`
	`18`	`+ CommandLineLogger logger`
`20`	`19`	`)`
`21`	`20`	`{`
`22`	`21`	`_masterText = masterText;`
`23`	`22`
`24`	`23`	`_logger = logger;`
`25`		`- _logger.SetLoggedType( GetType() );`
`26`	`24`	`}`
`27`	`25`
`28`	`26`	`public int GetMaxTerminatorLength( string text, bool isKey )`
`29`	`27`	`{`
`30`	`28`	`if( !_masterText.IsValid )`
`31`	`29`	`{`
`32`		`- _logger.Error("MasterTextCollection is not initialized" );`
	`30`	`+ _logger.Log("MasterTextCollection is not initialized" );`
`33`	`31`	`throw new TypeInitializationException( "MasterTextCollection is not initialized", null );`
`34`	`32`	`}`
`35`	`33`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Linq;`
`3`		`-using J4JSoftware.Logging;`
`4`	`3`
`5`	`4`	`#pragma warning disable 8618`
`6`	`5`
`@@ -9,23 +8,22 @@ namespace J4JSoftware.CommandLine`
`9`	`8`	`public class KeyPrefixer : IKeyPrefixer`
`10`	`9`	`{`
`11`	`10`	`private readonly MasterTextCollection _masterText;`
`12`		`- private readonly IJ4JLogger _logger;`
	`11`	`+ private readonly CommandLineLogger _logger;`
`13`	`12`
`14`	`13`	`public KeyPrefixer(`
`15`	`14`	`MasterTextCollection masterText,`
`16`		`- IJ4JLogger logger`
	`15`	`+ CommandLineLogger logger`
`17`	`16`	`)`
`18`	`17`	`{`
`19`	`18`	`_masterText = masterText;`
`20`	`19`
`21`	`20`	`_logger = logger;`
`22`		`- _logger.SetLoggedType(GetType());`
`23`	`21`
`24`	`22`	`if( _masterText[ TextUsageType.Prefix ].Any() ) return;`
`25`	`23`
`26`	`24`	`var mesg =`
`27`	`25`	`$"{nameof(masterText)} ({typeof(MasterTextCollection)}) does not define any {nameof(TextUsageType.Prefix)} entries";`
`28`		`- _logger.Fatal( mesg );`
	`26`	`+ _logger.Log( mesg );`
`29`	`27`
`30`	`28`	`throw new ArgumentException( mesg );`
`31`	`29`	`}`
`@@ -34,7 +32,7 @@ public int GetMaxPrefixLength( string text )`
`34`	`32`	`{`
`35`	`33`	`if (!_masterText.IsValid)`
`36`	`34`	`{`
`37`		`- _logger.Error("MasterTextCollection is not initialized");`
	`35`	`+ _logger.Log("MasterTextCollection is not initialized");`
`38`	`36`	`throw new TypeInitializationException("MasterTextCollection is not initialized", null);`
`39`	`37`	`}`
`40`	`38`