Add usage printer overload (#40)

* Create base exception class that exposes the failed argument

* Add PrintUsage(IArgument)

* Throw exception instead of just creating a new instance

* Add exception testing

Author: Matthiee

CommandLineParser.Tests/CommandLineParser.Tests.csproj

@@ -5,7 +5,7 @@
 
     <IsPackable>false</IsPackable>
 
-    <RootNamespace>MatthiWare.CommandLineParser.Tests</RootNamespace>
+    <RootNamespace>MatthiWare.CommandLine.Tests</RootNamespace>
 
     <LangVersion>7.3</LangVersion>
   </PropertyGroup>

CommandLineParser.Tests/Exceptions/ExceptionsTest.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using MatthiWare.CommandLine;
+using MatthiWare.CommandLine.Core.Attributes;
+using MatthiWare.CommandLine.Core.Exceptions;
+using Xunit;
+
+namespace MatthiWare.CommandLine.Tests.Exceptions
+{
+    public class ExceptionsTest
+    {
+        [Fact]
+        public void CommandNotFoundTest()
+        {
+            var parser = new CommandLineParser();
+
+            parser.AddCommand().Name("missing").Required();
+
+            var result = parser.Parse(new string[] { });
+
+            Assert.True(result.HasErrors);
+
+            Assert.IsType<CommandNotFoundException>(result.Errors.First());
+
+            Assert.Same(parser.Commands.First(), result.Errors.Cast<CommandNotFoundException>().First().Command);
+        }
+
+        [Fact]
+        public void OptionNotFoundTest()
+        {
+            var parser = new CommandLineParser<Options>();
+
+            var result = parser.Parse(new string[] { });
+
+            Assert.True(result.HasErrors);
+
+            Assert.IsType<OptionNotFoundException>(result.Errors.First());
+
+            Assert.Same(parser.Options.First(), result.Errors.Cast<OptionNotFoundException>().First().Option);
+        }
+
+        [Fact]
+        public void CommandParseExceptionTest()
+        {
+            var parser = new CommandLineParser();
+
+            parser.AddCommand<Options>()
+                .Name("missing")
+                .Required()
+                .Configure(opt => opt.MissingOption)
+                .Name("o")
+                .Required();
+
+            var result = parser.Parse(new string[] { "missing", "-o", "bla" });
+
+            Assert.True(result.HasErrors);
+
+            Assert.IsType<CommandParseException>(result.Errors.First());
+
+            Assert.Same(parser.Commands.First(), result.Errors.Cast<CommandParseException>().First().Command);
+        }
+
+        [Fact]
+        public void OptionParseExceptionTest()
+        {
+            var parser = new CommandLineParser<Options>();
+
+            var result = parser.Parse(new string[] { "-m", "bla" });
+
+            Assert.True(result.HasErrors);
+
+            Assert.IsType<OptionParseException>(result.Errors.First());
+
+            Assert.Same(parser.Options.First(), result.Errors.Cast<OptionParseException>().First().Option);
+        }
+
+        private class Options
+        {
+            [Required, Name("m", "missing")]
+            public int MissingOption { get; set; }
+        }
+    }
+}

CommandLineParser.Tests/Usage/HelpDisplayCommandTests.cs

@@ -25,6 +25,7 @@ public void TestHelpDisplayFiresCorrectly(string[] args, bool fires)
             var usagePrinterMock = new Mock<IUsagePrinter>();
 
             usagePrinterMock.Setup(mock => mock.PrintUsage()).Callback(() => calledFlag = true);
+            usagePrinterMock.Setup(mock => mock.PrintUsage(It.IsAny<IArgument>())).Callback(() => calledFlag = true);
             usagePrinterMock.Setup(mock => mock.PrintUsage(It.IsAny<ICommandLineCommand>())).Callback(() => calledFlag = true);
             usagePrinterMock.Setup(mock => mock.PrintUsage(It.IsAny<ICommandLineOption>())).Callback(() => calledFlag = true);
 

CommandLineParser.Tests/Usage/UsagePrinterTests.cs

@@ -1,8 +1,10 @@
-using MatthiWare.CommandLine;
+using System.Linq;
 using MatthiWare.CommandLine.Abstractions;
 using MatthiWare.CommandLine.Abstractions.Command;
 using MatthiWare.CommandLine.Abstractions.Usage;
 using MatthiWare.CommandLine.Core.Attributes;
+using MatthiWare.CommandLine.Core.Exceptions;
+using MatthiWare.CommandLine.Core.Usage;
 using Moq;
 using Xunit;
 
@@ -52,7 +54,7 @@ public void UsagePrinterPrintsOptionCorrectly()
 
             parser.Parse(new[] { "-o", "--help" });
 
-            printerMock.Verify(mock => mock.PrintUsage(It.IsAny<ICommandLineOption>()), Times.Once());
+            printerMock.Verify(mock => mock.PrintUsage(It.IsAny<IArgument>()), Times.Once());
         }
 
         [Fact]
@@ -71,7 +73,63 @@ public void UsagePrinterPrintsCommandCorrectly()
 
             parser.Parse(new[] { "-o", "bla", "cmd", "--help" });
 
-            printerMock.Verify(mock => mock.PrintUsage(It.IsAny<ICommandLineCommand>()), Times.Once());
+            printerMock.Verify(mock => mock.PrintUsage(It.IsAny<IArgument>()), Times.Once());
         }
+
+        [Theory]
+        [InlineData(new string[] { "-o", "bla", "cmd" }, true, false)]
+        [InlineData(new string[] { "-o", "bla", "cmd", "-x", "bla" }, false, false)]
+        [InlineData(new string[] { "cmd", "-x", "bla" }, false, true)]
+        public void CustomInvokedPrinterWorksCorrectly(string[] args, bool cmdPassed, bool optPassed)
+        {
+            var builderMock = new Mock<IUsageBuilder>();
+
+            var parserOptions = new CommandLineParserOptions
+            {
+                AutoPrintUsageAndErrors = false
+            };
+
+            var parser = new CommandLineParser<UsagePrinterGetsCalledOptions>(parserOptions);
+
+            parser.Printer = new UsagePrinter(parserOptions, parser, builderMock.Object);
+
+            parser.AddCommand<UsagePrinterCommandOptions>()
+                .Name("cmd")
+                .Required();
+
+            var result = parser.Parse(args);
+
+            builderMock.Verify(mock => mock.Print(), Times.Never());
+            builderMock.Verify(mock => mock.PrintCommand(It.IsAny<string>(), It.IsAny<ICommandLineCommandContainer>()), Times.Never());
+            builderMock.Verify(mock => mock.PrintOption(It.IsAny<ICommandLineOption>(), It.IsAny<int>(), It.IsAny<bool>()), Times.Never());
+
+            if (result.HelpRequested)
+                parser.Printer.PrintUsage(result.HelpRequestedFor);
+
+            if (result.HasErrors)
+            {
+                foreach (var err in result.Errors)
+                {
+                    if (!(err is BaseParserException baseParserException)) continue;
+
+                    parser.Printer.PrintUsage(baseParserException.Argument);
+                }
+            }
+
+            builderMock.Verify(
+                mock => mock.Print(),
+                ToTimes(result.HelpRequested || result.HasErrors));
+
+            builderMock.Verify(
+                mock => mock.PrintCommand(It.IsAny<string>(), It.IsAny<ICommandLineCommandContainer>()),
+                ToTimes(cmdPassed));
+
+            builderMock.Verify(
+                mock => mock.PrintOption(It.IsAny<ICommandLineOption>(), It.IsAny<int>(), It.IsAny<bool>()),
+                ToTimes(optPassed));
+        }
+
+        private Times ToTimes(bool input)
+            => input ? Times.Once() : Times.Never();
     }
 }

CommandLineParser/Abstractions/Usage/IUsagePrinter.cs

@@ -2,10 +2,31 @@
 
 namespace MatthiWare.CommandLine.Abstractions.Usage
 {
+    /// <summary>
+    /// CLI Usage Output Printer
+    /// </summary>
     public interface IUsagePrinter
     {
+        /// <summary>
+        /// Print global usage
+        /// </summary>
         void PrintUsage();
+        /// <summary>
+        /// Print an argument
+        /// </summary>
+        /// <param name="argument">The given argument</param>
+        void PrintUsage(IArgument argument);
+
+        /// <summary>
+        /// Print command usage
+        /// </summary>
+        /// <param name="command">The given command</param>
         void PrintUsage(ICommandLineCommand command);
+
+        /// <summary>
+        /// Print option usage
+        /// </summary>
+        /// <param name="option">The given option</param>
         void PrintUsage(ICommandLineOption option);
     }
 }