Releases/0.4 (#79)

* Improve Dependency Injection (#71)

* Rename to BaseArgumentResolver

* Add resolvers as part of DI

* Remove obsolete IArgumentResolverFactory

* Remove IContainerResolver will be replaced with IServiceProvider

* Use IServiceProvider for resolving fixes #70

* Update readme

* Add more services to the ServiceCollection

* Use DI in printer tests

* Add IUsagePrinter to interface

* Improve DI flow

* Use ActivatorUtilities to instantiate CommandLineOption

* Use CreateInstance instead of newing up a new instance.

* Improve extension method to allow chaining

* Add basic logger

* Add logger service in tests

* Add logging in all tests!

* Allow non generic command to be registered (#78)

* Allow non generic commands to be registered (#77)

* Refactor RegisterCommand<TCommand>

* Allow non generic commands to be discovered

* Register non generic command using model (#83)

* Allow non generic commands to be registered using models fixes #82 and improves #77

* Fix issue with registering non generic sub command

* Remove IgnoreAttribute fixes #80 (#84)

* Update version to 0.4

* Bump FluentValidation from 8.5.1 to 9.2.2 (#86)

* Bump FluentValidation from 8.5.1 to 9.2.2

Bumps [FluentValidation](https://github.com/JeremySkinner/fluentvalidation) from 8.5.1 to 9.2.2.
- [Release notes](https://github.com/JeremySkinner/fluentvalidation/releases)
- [Changelog](https://github.com/FluentValidation/FluentValidation/blob/master/Changelog.txt)
- [Commits](FluentValidation/FluentValidation@8.5.1...9.2.2)

Signed-off-by: dependabot[bot] <support@github.com>

* Fix build, upgrade fluent validation https://docs.fluentvalidation.net/en/latest/upgrading-to-9.html

* bump version in nuspec

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Matthias Beerens <3512339+Matthiee@users.noreply.github.com>

* Cleanup 0.4 release (#85)

* Refactor InitializeModel into seperate class

* Split complex ParseOptions method

* Add braces

* Split complex ParseCommands and ParseCommandsAsync method

* Refactor if statements in HelpRequested method

* Remove redundant assignment

* Remove unused usings

* Revert returning help requested state to caller

* Improve if statements

* Add xml comment

* Add more xml documentation

* Add validator xml comments

* Update sample app

* Improve test coverage

* Add xml comment

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Author: Matthiee

CommandLineParser.Tests/BasicDITests.cs

@@ -0,0 +1,81 @@
+using MatthiWare.CommandLine.Abstractions.Command;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace MatthiWare.CommandLine.Tests
+{
+    public class BasicDITests : TestBase
+    {
+        public BasicDITests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
+        {
+        }
+
+        [Fact]
+        public void CommandLineParserUsesInjectedServiceCorrectly()
+        {
+            var mockedService = new Mock<MySerice>();
+
+            mockedService
+                .Setup(_ => _.Call())
+                .Verifiable();
+
+            Services.AddSingleton(mockedService.Object);
+
+            var parser = new CommandLineParser(Services);
+
+            parser.RegisterCommand<MyCommandThatUsesService>();
+
+            var result = parser.Parse(new[] { "app.exe", "cmd" });
+
+            result.AssertNoErrors();
+
+            mockedService.Verify(_ => _.Call(), Times.Once());
+        }
+
+        [Fact]
+        public void CommandLineParserServiceResolvesCorrectly()
+        {
+            var mockedService = Mock.Of<MySerice>();
+
+            Services.AddSingleton(mockedService);
+
+            var parser = new CommandLineParser(Services);
+
+            var resolved = parser.Services.GetRequiredService<MySerice>();
+
+            Assert.Equal(mockedService, resolved);
+        }
+
+        public class MyCommandThatUsesService : Command<object>
+        {
+            private readonly MySerice serice;
+
+            public MyCommandThatUsesService(MySerice serice)
+            {
+                this.serice = serice ?? throw new System.ArgumentNullException(nameof(serice));
+            }
+
+            public override void OnConfigure(ICommandConfigurationBuilder builder)
+            {
+                builder
+                    .Name("cmd")
+                    .AutoExecute(true)
+                    .Required(true);
+            }
+
+            public override void OnExecute()
+            {
+                base.OnExecute();
+
+                serice.Call();
+            }
+        }
+
+        public interface MySerice
+        {
+            void Call();
+        }
+    }
+}

CommandLineParser.Tests/Command/CommandDiscoveryTests.cs

@@ -2,17 +2,30 @@
 using Xunit;
 using MatthiWare.CommandLine.Abstractions.Command;
 using System.Reflection;
+using System.Threading.Tasks;
+using System.Threading;
+using MatthiWare.CommandLine.Abstractions.Usage;
+using Moq;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit.Abstractions;
+using TestAssembly;
+using MatthiWare.CommandLine.Abstractions.Parsing;
+using MatthiWare.CommandLine.Abstractions.Models;
 
 namespace MatthiWare.CommandLine.Tests.Command
 {
-    public class CommandDiscoveryTests
+    public class CommandDiscoveryTests : TestBase
     {
+        public CommandDiscoveryTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
+        {
+        }
+
         [Fact]
         public void DiscoverCommandFromAssemblyContainsCorrectTypes()
         {
             var cmdDiscovery = new CommandDiscoverer();
 
-            var resultTypes = cmdDiscovery.DiscoverCommandTypes(typeof(CommandDiscoveryTests), new[] { Assembly.GetExecutingAssembly() });
+            var resultTypes = cmdDiscovery.DiscoverCommandTypes(typeof(SomeBaseType), new[] { Assembly.GetExecutingAssembly() });
 
             var invalidAbstractCommand = typeof(AbstractCommand);
             var wrongGenericTypeCommand = typeof(WrongGenericTypeCommand);
@@ -28,27 +41,117 @@ public void DiscoverCommandFromAssemblyContainsCorrectTypes()
         [Fact]
         public void DiscoveredCommandsAreRegisteredCorrectly()
         {
-            var parser = new CommandLineParser<CommandDiscoveryTests>();
+            var parser = new CommandLineParser<SomeBaseType>(Services);
 
             parser.DiscoverCommands(Assembly.GetExecutingAssembly());
 
-            Assert.Equal(2, parser.Commands.Count);
+            Assert.Equal(3, parser.Commands.Count);
+        }
+
+        [Fact]
+        public async Task CommandDiscoveryWithInjectedServices()
+        {
+            var envMock = new Mock<IEnvironmentVariablesService>();
+            envMock
+                .SetupGet(_ => _.NoColorRequested)
+                .Returns(true);
+
+            var myServiceMock = new Mock<IMyService>();
+            myServiceMock
+                .Setup(_ => _.Call())
+                .Verifiable();
+
+            Services.AddSingleton(envMock.Object);
+            Services.AddSingleton(myServiceMock.Object);
+
+            var parser = new CommandLineParser<MyCommandWithInjectionsOptions>(Services);
+
+            parser.DiscoverCommands(Assembly.GetExecutingAssembly());
+
+            var result = await parser.ParseAsync(new[] { "app.exe", "cmd" });
+
+            myServiceMock.Verify(_ => _.Call(), Times.Once());
+        }
+
+        [Fact]
+        public async Task NonGenericCommandCanBeDiscovered()
+        {
+            var argResolverMock = new Mock<IArgumentResolver<NonGenericDiscoverableCommand>>();
+            argResolverMock
+                .Setup(_ => _.CanResolve(It.IsAny<ArgumentModel>()))
+                .Verifiable();
+
+            Services.AddSingleton(argResolverMock.Object);
+
+            var parser = new CommandLineParser(Services);
+
+            parser.DiscoverCommands(typeof(NonGenericDiscoverableCommand).Assembly);
+
+            var result = await parser.ParseAsync(new[] { "app.exe", "cmd" });
+
+            Assert.True(parser.Commands.Count == 1);
+
+            argResolverMock.Verify(_ => _.CanResolve(It.IsAny<ArgumentModel>()), Times.Once());
+        }
+
+        public abstract class AbstractCommand : Command<SomeBaseType>
+        {
         }
 
-        public abstract class AbstractCommand : Command<CommandDiscoveryTests>
+        public class WrongGenericTypeCommand : Command<object>
         {
         }
 
-        public abstract class WrongGenericTypeCommand : Command<object>
+        public class ValidCommand : Command<SomeBaseType>
         {
         }
 
-        public class ValidCommand : Command<CommandDiscoveryTests>
+        public class ValidCommand2 : Command<SomeBaseType, object>
         {
         }
 
-        public class ValidCommand2 : Command<CommandDiscoveryTests, object>
-        {  
+        public class MyCommandWithInjectionsOptions 
+        {
+        }
+
+        public class SomeBaseType
+        {
+        }
+
+        public interface IMyService
+        {
+            void Call();
+        }
+
+        public class MyCommandWithInjections : Command<MyCommandWithInjectionsOptions>
+        {
+            private readonly IMyService service;
+            private readonly IUsagePrinter usagePrinter;
+            private readonly IEnvironmentVariablesService environment;
+
+            public MyCommandWithInjections(IMyService service, IUsagePrinter usagePrinter, IEnvironmentVariablesService environment)
+            {
+                this.service = service ?? throw new System.ArgumentNullException(nameof(service));
+                this.usagePrinter = usagePrinter ?? throw new System.ArgumentNullException(nameof(usagePrinter));
+                this.environment = environment ?? throw new System.ArgumentNullException(nameof(environment));
+            }
+
+            public override void OnConfigure(ICommandConfigurationBuilder builder)
+            {
+                builder
+                    .Name("cmd")
+                    .AutoExecute(true);
+            }
+
+            public override Task OnExecuteAsync(MyCommandWithInjectionsOptions options, CancellationToken cancellationToken)
+            {
+                service.Call();
+                usagePrinter.PrintUsage();
+
+                Assert.True(environment.NoColorRequested);
+
+                return base.OnExecuteAsync(options, cancellationToken);
+            }
         }
     }
 }

CommandLineParser.Tests/Command/CommandInModelTests.cs

@@ -0,0 +1,109 @@
+using MatthiWare.CommandLine.Abstractions.Command;
+using MatthiWare.CommandLine.Core.Attributes;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace MatthiWare.CommandLine.Tests.Command
+{
+    public class CommandInModelTests : TestBase
+    {
+        public CommandInModelTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
+        {
+        }
+
+        #region FindCommandsInModel
+
+        [Fact]
+        public async Task FindCommandsInModel()
+        {
+            var parser = new CommandLineParser<ModelWithCommands>(Services);
+
+            Assert.Equal(3, parser.Commands.Count);
+        }
+
+        public class ModelWithCommands
+        {
+            public NonGenericCommand NonGenericCommand { get; set; }
+            public GenericCommandWithParentOptions GenericCommandWithParentOptions { get; set; }
+            public GenericCommandWithOwnOptions GenericCommandWithOwnOptions { get; set; }
+        }
+
+        public class ModelWithOptions
+        {
+            [Name("i", "input")]
+            public string MyOption { get; set; }
+        }
+
+        public class NonGenericCommand : Abstractions.Command.Command
+        {
+            public override void OnConfigure(ICommandConfigurationBuilder builder)
+            {
+                builder.Name(nameof(NonGenericCommand));
+            }
+        }
+
+        public class GenericCommandWithParentOptions : Command<ModelWithCommands>
+        {
+            public override void OnConfigure(ICommandConfigurationBuilder builder)
+            {
+                builder.Name(nameof(GenericCommandWithParentOptions));
+            }
+        }
+
+        public class GenericCommandWithOwnOptions : Command<ModelWithCommands, ModelWithOptions>
+        {
+            public override void OnConfigure(ICommandConfigurationBuilder builder)
+            {
+                builder.Name(nameof(GenericCommandWithOwnOptions));
+            }
+        }
+
+        #endregion
+
+        #region SubCommandFindCommandsInModel
+
+        [Fact]
+        public async Task FindCommandsInCommandModel()
+        {
+            var parser = new CommandLineParser(Services);
+
+            parser.RegisterCommand<GenericSubCommandWithOwnOptions, SubCommandModelWithCommands>();
+
+            Assert.Equal(3, ((ICommandLineCommandContainer)parser.Commands[0]).Commands.Count);
+        }
+
+        public class SubCommandModelWithCommands
+        {
+            public NonGenericCommand NonGenericCommand { get; set; }
+            public SubCommandWithModelOptions SubCommandWithModelOptions { get; set; }
+            public SimpleGenericCommand SimpleGenericCommand { get; set; }
+        }
+
+        public class GenericSubCommandWithOwnOptions : Command<object, SubCommandModelWithCommands>
+        {
+            public override void OnConfigure(ICommandConfigurationBuilder builder)
+            {
+                builder.Name(nameof(GenericSubCommandWithOwnOptions));
+            }
+        }
+
+        public class SubCommandWithModelOptions : Command<object, ModelWithOptions>
+        {
+            public override void OnConfigure(ICommandConfigurationBuilder builder)
+            {
+                builder.Name(nameof(SubCommandWithModelOptions));
+            }
+        }
+
+        public class SimpleGenericCommand : Command<object>
+        {
+            public override void OnConfigure(ICommandConfigurationBuilder builder)
+            {
+                builder.Name(nameof(SimpleGenericCommand));
+            }
+        }
+
+        #endregion
+    }
+}