Incorporated IJ4JLogger into Binder

markolbert · markolbert · commit de501be435e4 · 2020-12-30T12:29:06.000-08:00
diff --git a/Binder.Tests/MiscTests.cs b/Binder.Tests/MiscTests.cs
@@ -15,9 +15,8 @@ public void StringHandling( CommandLineStyle style, string cmdLine, params strin
 
             var option = Options.Bind<MiscTarget, string?>( x => x.AStringValue, "x" );
             option.Should().NotBeNull();
-            Options.Log.HasMessages().Should().BeFalse();
 
-            var parser = new Parser(Options, Logger);
+            var parser = new Parser(Options, LoggerFactory);
             parser.Parse( cmdLine ).Should().BeTrue();
 
             Options.UnknownKeys.Should().BeEmpty();
diff --git a/Binder.Tests/ParserTests.cs b/Binder.Tests/ParserTests.cs
@@ -15,13 +15,11 @@ public class ParserTests : BaseTest
         [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) );
+                AvailableTokens.GetDefault(CommandLineStyle.Windows, LoggerFactory), 
+                LoggerFactory,
+                new ConsolidateQuotedText(StringComparison.OrdinalIgnoreCase, LoggerFactory()),
+                new MergeSequentialSeparators(LoggerFactory()) );
 
             var tokens = tokenizer.Tokenize( config.CommandLine );
 
@@ -43,8 +41,7 @@ public void Parser( TestConfig config )
         {
             Initialize(config);
 
-            var cmdLogger = new CommandLineLogger();
-            var parser = new Parser( Options, cmdLogger );
+            var parser = new Parser( Options, LoggerFactory );
 
             parser.Options.CreateOptionsFromContextKeys( config.OptionConfigurations );
 
diff --git a/Binder.Tests/support/BaseTest.cs b/Binder.Tests/support/BaseTest.cs
@@ -3,21 +3,28 @@
 using System.Linq.Expressions;
 using FluentAssertions;
 using J4JSoftware.Configuration.CommandLine;
+using J4JSoftware.Logging;
 using Microsoft.Extensions.Configuration;
 using Xunit;
 
 namespace J4JSoftware.Binder.Tests
 {
     public class BaseTest
     {
+        protected BaseTest()
+        {
+            LoggerFactory = CompositionRoot.Default.LoggerFactory;
+            Logger = LoggerFactory();
+        }
+
+        protected Func<IJ4JLogger> LoggerFactory { get; }
         protected TestConfig? TestConfig { get; private set; }
         protected IOptionCollection Options { get; private set; }
-        protected CommandLineLogger Logger => Options.Log;
+        protected IJ4JLogger Logger { get; }
 
-        protected void Initialize(CommandLineStyle style)
+        protected void Initialize( CommandLineStyle style )
         {
-            Options = new OptionCollectionNG(style);
-            Options.Log.HasMessages().Should().BeFalse();
+            Options = new OptionCollectionNG(style, LoggerFactory);
         }
 
         protected void Initialize( TestConfig testConfig )
@@ -49,7 +56,7 @@ protected void Bind<TTarget, TProp>( Expression<Func<TTarget, TProp>> propSelect
 
         protected void ValidateTokenizing()
         {
-            var parser = new Parser(Options, Logger);
+            var parser = new Parser(Options, LoggerFactory);
             parser.Parse( TestConfig!.CommandLine ).Should().Be( Options.UnknownKeys.Count == 0 );
 
             Options.UnknownKeys.Count.Should().Be( TestConfig.UnknownKeys );
@@ -68,8 +75,6 @@ protected void ValidateConfiguration<TParsed>()
                 .AddJ4JCommandLine( TestConfig!.CommandLine, Options )
                 .Build();
 
-            Options.Log.HasMessages().Should().BeFalse();
-
             TParsed? parsed = null;
 
             if( TestConfig!.OptionConfigurations.Any( x => x.ConversionWillFail ) )
diff --git a/Binder.Tests/support/CompositionRoot.cs b/Binder.Tests/support/CompositionRoot.cs
@@ -39,6 +39,6 @@ private void ConfigureDependencyInjection( HostBuilderContext context, Container
                 .As<IJ4JLoggerConfiguration>();
         }
 
-        public IJ4JLogger Logger => Host!.Services.GetRequiredService<IJ4JLogger>();
+        public Func<IJ4JLogger> LoggerFactory => () => Host!.Services.GetRequiredService<IJ4JLogger>();
     }
 }
diff --git a/Binder/Binder.csproj b/Binder/Binder.csproj
@@ -7,8 +7,16 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Remove="CommandLineLogger.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Configuration" Version="5.0.0" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\..\J4JLogging\J4JLogging\J4JLogging.csproj" />
+  </ItemGroup>
+
 </Project>
diff --git a/Binder/J4JCommandLineSource.cs b/Binder/J4JCommandLineSource.cs
@@ -1,4 +1,7 @@
-﻿using Microsoft.Extensions.Configuration;
+﻿using System;
+using J4JSoftware.Logging;
+using Microsoft.Extensions.Configuration;
+using Serilog.Core;
 
 namespace J4JSoftware.Configuration.CommandLine
 {
@@ -9,29 +12,28 @@ public class J4JCommandLineSource : IConfigurationSource
 
         public J4JCommandLineSource(
             IOptionCollection options,
-            string cmdLine
+            string cmdLine,
+            Func<IJ4JLogger>? loggerFactory = null
         )
         {
             Options = options;
             _cmdLine = cmdLine;
-            Logger = new CommandLineLogger();
 
-            var tokenizer = new Tokenizer( Logger, options.CommandLineStyle, options.MasterText.TextComparison );
-            var parsingTable = new ParsingTable( options, Logger );
+            var tokenizer = new Tokenizer( options.CommandLineStyle, options.MasterText.TextComparison, loggerFactory );
+            var parsingTable = new ParsingTable( options, loggerFactory);
 
-            _parser = new Parser( options, tokenizer, parsingTable, Logger );
+            _parser = new Parser( options, tokenizer, parsingTable, loggerFactory?.Invoke() );
         }
 
         public J4JCommandLineSource(
             IOptionCollection options,
             string[] args,
-            CommandLineLogger logger
+            Func<IJ4JLogger>? loggerFactory
         )
-            : this( options, string.Join( " ", args ) )
+            : this( options, string.Join( " ", args ), loggerFactory )
         {
         }
 
-        public CommandLineLogger Logger { get; }
         public IOptionCollection Options { get; }
 
         public IConfigurationProvider Build( IConfigurationBuilder builder )
diff --git a/Binder/grammar/ConsolidateQuotedText.cs b/Binder/grammar/ConsolidateQuotedText.cs
@@ -2,19 +2,20 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using J4JSoftware.Logging;
+
 #pragma warning disable 8618
 
 namespace J4JSoftware.Configuration.CommandLine
 {
     public class ConsolidateQuotedText : ICleanupTokens
     {
-        private readonly CommandLineLogger _logger;
-
         private readonly StringComparison _textComparison;
+        private readonly IJ4JLogger? _logger;
 
         public ConsolidateQuotedText(
             StringComparison textComparison,
-            CommandLineLogger logger )
+            IJ4JLogger? logger )
         {
             _textComparison = textComparison;
             _logger = logger;
@@ -33,8 +34,8 @@ public void Process( List<Token> tokens )
                 // "quoted" tokens
                 if( curPair.End == null )
                 {
-                    _logger.LogError(
-                        $"Unclosed quoter encountered, command line truncated at token #{curPair.Start.Index}" );
+                    _logger?.Error( "Unclosed quoter encountered, command line truncated at token #{0}", 
+                        curPair.Start.Index );
 
                     tokens.RemoveFrom( curPair.Start.Index );
 
diff --git a/Binder/grammar/MergeSequentialSeparators.cs b/Binder/grammar/MergeSequentialSeparators.cs
@@ -1,12 +1,13 @@
 ﻿using System.Collections.Generic;
+using J4JSoftware.Logging;
 
 namespace J4JSoftware.Configuration.CommandLine
 {
     public class MergeSequentialSeparators : ICleanupTokens
     {
-        private readonly CommandLineLogger _logger;
+        private readonly IJ4JLogger? _logger;
 
-        public MergeSequentialSeparators( CommandLineLogger logger )
+        public MergeSequentialSeparators( IJ4JLogger? logger )
         {
             _logger = logger;
         }
diff --git a/Binder/grammar/Parser.cs b/Binder/grammar/Parser.cs
@@ -1,35 +1,38 @@
-﻿namespace J4JSoftware.Configuration.CommandLine
+﻿using System;
+using J4JSoftware.Logging;
+
+namespace J4JSoftware.Configuration.CommandLine
 {
     public class Parser
     {
-        private readonly CommandLineLogger _logger;
+        private readonly IJ4JLogger? _logger;
         private readonly ITokenizer _tokenizer;
 
         public Parser(
-            CommandLineLogger logger,
-            CommandLineStyle style = CommandLineStyle.Windows
+            CommandLineStyle style = CommandLineStyle.Windows,
+            Func<IJ4JLogger>? loggerFactory = null
         )
-            : this( new OptionCollectionNG( style ), logger )
+            : this( new OptionCollectionNG( style ), loggerFactory )
         {
         }
 
         public Parser(
             IOptionCollection options,
-            CommandLineLogger logger
+            Func<IJ4JLogger>? loggerFactory = null
         )
             : this(
                 options,
-                new Tokenizer( logger, options.CommandLineStyle, options.MasterText.TextComparison ),
-                new ParsingTable( options, logger ),
-                logger )
+                new Tokenizer( options.CommandLineStyle, options.MasterText.TextComparison, loggerFactory ),
+                new ParsingTable( options, loggerFactory ),
+                loggerFactory?.Invoke() )
         {
         }
 
         public Parser(
             IOptionCollection options,
             ITokenizer tokenizer,
             IParsingTable parsingTable,
-            CommandLineLogger logger
+            IJ4JLogger? logger = null
         )
         {
             Options = options;
@@ -45,7 +48,7 @@ public bool Parse( string cmdLine )
         {
             if( !ParsingTable.IsValid )
             {
-                _logger.LogError( "ParsingTable is invalid" );
+                _logger?.Error( "ParsingTable is invalid" );
                 return false;
             }
 
diff --git a/Binder/grammar/ParsingTable.cs b/Binder/grammar/ParsingTable.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Linq;
+using J4JSoftware.Logging;
 
 namespace J4JSoftware.Configuration.CommandLine
 {
@@ -11,9 +12,13 @@ public class ParsingTable : IParsingTable
         private readonly Dictionary<TokenType, Dictionary<TokenType, ParsingAction?>> _table =
             new();
 
-        public ParsingTable( IOptionCollection options, CommandLineLogger logger )
+        private readonly IJ4JLogger? _logger;
+
+        public ParsingTable( IOptionCollection options, Func<IJ4JLogger>? loggerFactory = null )
         {
-            Entries = new TokenEntry.TokenEntries( options, logger );
+            _logger = loggerFactory?.Invoke();
+
+            Entries = new TokenEntry.TokenEntries( options, loggerFactory?.Invoke() );
 
             foreach( var row in Enum.GetValues( typeof(TokenType) )
                 .Cast<TokenType>() )
diff --git a/Binder/grammar/TokenEntry.TokenEntries.cs b/Binder/grammar/TokenEntry.TokenEntries.cs
@@ -1,16 +1,17 @@
 ﻿using System.Linq;
+using J4JSoftware.Logging;
 
 namespace J4JSoftware.Configuration.CommandLine
 {
     public partial class TokenEntry
     {
         public class TokenEntries
         {
-            private readonly CommandLineLogger _logger;
+            private readonly IJ4JLogger? _logger;
 
             public TokenEntries(
                 IOptionCollection options,
-                CommandLineLogger logger
+                IJ4JLogger? logger
             )
             {
                 Options = options;
@@ -29,8 +30,8 @@ public bool Create( Token prevToken, Token curToken, params string[] args )
 
             public bool TerminateWithPrejuidice( Token prevToken, Token curToken, params string[] args )
             {
-                _logger.LogError(
-                    $"{curToken.Type} ('{curToken.Text}') follows {prevToken} ('{prevToken.Text}'), which is not allowed" );
+                _logger?.Error( "{0} ('{1}') follows {2} ('{3}'), which is not allowed",
+                    new object[] { curToken.Type, curToken.Text, prevToken.Type, prevToken.Text } );
 
                 Current = null;
 
@@ -41,13 +42,13 @@ public bool Commit( Token prevToken, Token curToken, params string[] args )
             {
                 if( Current == null )
                 {
-                    _logger.LogError( "Attempted to commit undefined TokenEntry" );
+                    _logger?.Error( "Attempted to commit undefined TokenEntry" );
                     return false;
                 }
 
                 if( Current.Option == null )
                 {
-                    _logger.LogError( $"Found entry with unexpected key '{Current.Key}'" );
+                    _logger?.Error<string>( "Found entry with unexpected key '{0}'", Current.Key ?? string.Empty );
                     Options.UnknownKeys.Add( Current );
 
                     // create a new TokenEntry
@@ -77,8 +78,11 @@ public bool ProcessText( Token prevToken, Token curToken, params string[] args )
             {
                 if( args.Length != 1 )
                 {
-                    _logger.LogError(
-                        $"Invalid number of text arguments ({args.Length}) process {curToken.Type} ('{curToken.Text}')" );
+                    _logger?.Error<int, TokenType, string>(
+                        "Invalid number of text arguments ({0}) process {1} ('{2}')",
+                        args.Length,
+                        curToken.Type,
+                        curToken.Text );
 
                     Current = null;
 
diff --git a/Binder/grammar/tokenizer/AvailableTokens.cs b/Binder/grammar/tokenizer/AvailableTokens.cs
@@ -1,15 +1,16 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Linq;
+using J4JSoftware.Logging;
 
 namespace J4JSoftware.Configuration.CommandLine
 {
     public partial class AvailableTokens
     {
         private readonly Dictionary<TokenType, List<string>> _available = new();
-        private readonly CommandLineLogger _logger;
+        private readonly IJ4JLogger? _logger;
 
-        public AvailableTokens( StringComparison textComp, CommandLineLogger logger )
+        public AvailableTokens( StringComparison textComp, IJ4JLogger? logger )
         {
             TextComparison = textComp;
             _logger = logger;
@@ -33,14 +34,14 @@ public bool Add( TokenType type, string text )
         {
             if( type == TokenType.Text || type == TokenType.StartOfInput )
             {
-                _logger.LogError( $"Cannot include {type} tokens" );
+                _logger?.Error( "Cannot include {0} tokens", type );
                 return false;
             }
 
             if( _available.SelectMany( kvp => kvp.Value )
                 .Any( t => t.Equals( text, TextComparison ) ) )
             {
-                _logger.LogError( $"Duplicate token text '{text}' ({type})" );
+                _logger?.Error( "Duplicate token text '{0}' ({1})", text, type);
                 return false;
             }
 
@@ -60,7 +61,7 @@ public bool Remove( string text )
 
             if( idx < 0 )
             {
-                _logger.LogError( $"Couldn't find '{text}' among tokens to delete" );
+                _logger?.Error<string>( "Couldn't find '{0}' among tokens to delete", text );
                 return false;
             }
 
diff --git a/Binder/grammar/tokenizer/AvailableTokens.static.cs b/Binder/grammar/tokenizer/AvailableTokens.static.cs
diff --git a/Binder/grammar/tokenizer/Tokenizer.cs b/Binder/grammar/tokenizer/Tokenizer.cs
diff --git a/Binder/master-text/MasterTextCollection.cs b/Binder/master-text/MasterTextCollection.cs
diff --git a/Binder/master-text/MasterTextCollection.static.cs b/Binder/master-text/MasterTextCollection.static.cs
diff --git a/Binder/options/IOptionCollection.cs b/Binder/options/IOptionCollection.cs
diff --git a/Binder/options/OptionCollectionNG.cs b/Binder/options/OptionCollectionNG.cs

Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,6 @@ private void ConfigureDependencyInjection( HostBuilderContext context, Container`
`39`	`39`	`.As<IJ4JLoggerConfiguration>();`
`40`	`40`	`}`
`41`	`41`
`42`		`- public IJ4JLogger Logger => Host!.Services.GetRequiredService<IJ4JLogger>();`
	`42`	`+ public Func<IJ4JLogger> LoggerFactory => () => Host!.Services.GetRequiredService<IJ4JLogger>();`
`43`	`43`	`}`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,7 @@`
`1`		`-using Microsoft.Extensions.Configuration;`
	`1`	`+using System;`
	`2`	`+using J4JSoftware.Logging;`
	`3`	`+using Microsoft.Extensions.Configuration;`
	`4`	`+using Serilog.Core;`
`2`	`5`
`3`	`6`	`namespace J4JSoftware.Configuration.CommandLine`
`4`	`7`	`{`
`@@ -9,29 +12,28 @@ public class J4JCommandLineSource : IConfigurationSource`
`9`	`12`
`10`	`13`	`public J4JCommandLineSource(`
`11`	`14`	`IOptionCollection options,`
`12`		`- string cmdLine`
	`15`	`+ string cmdLine,`
	`16`	`+ Func<IJ4JLogger>? loggerFactory = null`
`13`	`17`	`)`
`14`	`18`	`{`
`15`	`19`	`Options = options;`
`16`	`20`	`_cmdLine = cmdLine;`
`17`		`- Logger = new CommandLineLogger();`
`18`	`21`
`19`		`- var tokenizer = new Tokenizer( Logger, options.CommandLineStyle, options.MasterText.TextComparison );`
`20`		`- var parsingTable = new ParsingTable( options, Logger );`
	`22`	`+ var tokenizer = new Tokenizer( options.CommandLineStyle, options.MasterText.TextComparison, loggerFactory );`
	`23`	`+ var parsingTable = new ParsingTable( options, loggerFactory);`
`21`	`24`
`22`		`- _parser = new Parser( options, tokenizer, parsingTable, Logger );`
	`25`	`+ _parser = new Parser( options, tokenizer, parsingTable, loggerFactory?.Invoke() );`
`23`	`26`	`}`
`24`	`27`
`25`	`28`	`public J4JCommandLineSource(`
`26`	`29`	`IOptionCollection options,`
`27`	`30`	`string[] args,`
`28`		`- CommandLineLogger logger`
	`31`	`+ Func<IJ4JLogger>? loggerFactory`
`29`	`32`	`)`
`30`		`- : this( options, string.Join( " ", args ) )`
	`33`	`+ : this( options, string.Join( " ", args ), loggerFactory )`
`31`	`34`	`{`
`32`	`35`	`}`
`33`	`36`
`34`		`- public CommandLineLogger Logger { get; }`
`35`	`37`	`public IOptionCollection Options { get; }`
`36`	`38`
`37`	`39`	`public IConfigurationProvider Build( IConfigurationBuilder builder )`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,13 @@`
`1`	`1`	`using System.Collections.Generic;`
	`2`	`+using J4JSoftware.Logging;`
`2`	`3`
`3`	`4`	`namespace J4JSoftware.Configuration.CommandLine`
`4`	`5`	`{`
`5`	`6`	`public class MergeSequentialSeparators : ICleanupTokens`
`6`	`7`	`{`
`7`		`- private readonly CommandLineLogger _logger;`
	`8`	`+ private readonly IJ4JLogger? _logger;`
`8`	`9`
`9`		`- public MergeSequentialSeparators( CommandLineLogger logger )`
	`10`	`+ public MergeSequentialSeparators( IJ4JLogger? logger )`
`10`	`11`	`{`
`11`	`12`	`_logger = logger;`
`12`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,35 +1,38 @@`
`1`		`-namespace J4JSoftware.Configuration.CommandLine`
	`1`	`+using System;`
	`2`	`+using J4JSoftware.Logging;`
	`3`	`+`
	`4`	`+namespace J4JSoftware.Configuration.CommandLine`
`2`	`5`	`{`
`3`	`6`	`public class Parser`
`4`	`7`	`{`
`5`		`- private readonly CommandLineLogger _logger;`
	`8`	`+ private readonly IJ4JLogger? _logger;`
`6`	`9`	`private readonly ITokenizer _tokenizer;`
`7`	`10`
`8`	`11`	`public Parser(`
`9`		`- CommandLineLogger logger,`
`10`		`- CommandLineStyle style = CommandLineStyle.Windows`
	`12`	`+ CommandLineStyle style = CommandLineStyle.Windows,`
	`13`	`+ Func<IJ4JLogger>? loggerFactory = null`
`11`	`14`	`)`
`12`		`- : this( new OptionCollectionNG( style ), logger )`
	`15`	`+ : this( new OptionCollectionNG( style ), loggerFactory )`
`13`	`16`	`{`
`14`	`17`	`}`
`15`	`18`
`16`	`19`	`public Parser(`
`17`	`20`	`IOptionCollection options,`
`18`		`- CommandLineLogger logger`
	`21`	`+ Func<IJ4JLogger>? loggerFactory = null`
`19`	`22`	`)`
`20`	`23`	`: this(`
`21`	`24`	`options,`
`22`		`- new Tokenizer( logger, options.CommandLineStyle, options.MasterText.TextComparison ),`
`23`		`- new ParsingTable( options, logger ),`
`24`		`- logger )`
	`25`	`+ new Tokenizer( options.CommandLineStyle, options.MasterText.TextComparison, loggerFactory ),`
	`26`	`+ new ParsingTable( options, loggerFactory ),`
	`27`	`+ loggerFactory?.Invoke() )`
`25`	`28`	`{`
`26`	`29`	`}`
`27`	`30`
`28`	`31`	`public Parser(`
`29`	`32`	`IOptionCollection options,`
`30`	`33`	`ITokenizer tokenizer,`
`31`	`34`	`IParsingTable parsingTable,`
`32`		`- CommandLineLogger logger`
	`35`	`+ IJ4JLogger? logger = null`
`33`	`36`	`)`
`34`	`37`	`{`
`35`	`38`	`Options = options;`
`@@ -45,7 +48,7 @@ public bool Parse( string cmdLine )`
`45`	`48`	`{`
`46`	`49`	`if( !ParsingTable.IsValid )`
`47`	`50`	`{`
`48`		`- _logger.LogError( "ParsingTable is invalid" );`
	`51`	`+ _logger?.Error( "ParsingTable is invalid" );`
`49`	`52`	`return false;`
`50`	`53`	`}`
`51`	`54`