Fix error in handling HelpOption and VersionOption (#28)

* Fix #26 - fix error in handling HelpOption and VersionOption when StopParsingAfterVersionOption/StopParsingAfterHelpOption is set
* Add additional tests for StopParsingAfterHelp/VersionOption

Author: natemcmaster

src/CommandLineUtils/CommandLineApplication.cs

@@ -153,13 +153,13 @@ private CommandLineApplication(CommandLineApplication parent, string name, bool
 
         /// <summary>
         /// Stops the parsing argument when <see cref="OptionHelp"/> is matched. Defaults to <c>true</c>.
-        /// This will prevent any <see cref="Invoke" /> methods from being called.
+        /// This will prevent <see cref="Invoke" /> or <see cref="ValidationErrorHandler" /> from being called.
         /// </summary>
         public bool StopParsingAfterHelpOption { get; set; } = true;
 
         /// <summary>
         /// Stops the parsing argument when <see cref="OptionVersion"/> is matched. Defaults to <c>true</c>.
-        /// This will prevent any <see cref="Invoke" /> methods from being called.
+        /// This will prevent <see cref="Invoke" /> or <see cref="ValidationErrorHandler" /> from being called.
         /// </summary>
         public bool StopParsingAfterVersionOption { get; set; } = true;
 
@@ -525,12 +525,26 @@ private int Execute(List<string> args)
                         if (command.OptionHelp == option)
                         {
                             command.ShowHelp();
-                            return 0;
+                            option.TryParse(null);
+                            var parent = command;
+                            while (parent.Parent != null) parent = parent.Parent;
+                            parent.SelectedCommand = command;
+                            if (StopParsingAfterHelpOption)
+                            {
+                                return 0;
+                            }
                         }
                         else if (command.OptionVersion == option)
                         {
                             command.ShowVersion();
-                            return 0;
+                            option.TryParse(null);
+                            var parent = command;
+                            while (parent.Parent != null) parent = parent.Parent;
+                            parent.SelectedCommand = command;
+                            if (StopParsingAfterVersionOption)
+                            {
+                                return 0;
+                            }
                         }
 
                         if (shortOption.Length == 2)

src/CommandLineUtils/Internal/ReflectionAppBuilder.cs

@@ -80,6 +80,11 @@ private void EnsureInitialized()
             var parsingOptionsAttr = typeInfo.GetCustomAttribute<CommandAttribute>();
             parsingOptionsAttr?.Configure(App);
 
+            if (App.Name == null)
+            {
+                App.Name = type.Name;
+            }
+
             if (parsingOptionsAttr?.ThrowOnUnexpectedArgument == false)
             {
                 AddRemainingArgsProperty(typeInfo);

test/CommandLineUtils.Tests/CommandLineApplicationTests.cs

@@ -736,5 +736,29 @@ public void PathCanBeRelativeOrAbsolute()
             new CommandLineApplication(NullConsole.Singleton, "C:/path", false);
             new CommandLineApplication(NullConsole.Singleton, "../path", false);
         }
+
+        [Fact]
+        public void ShortOptionsCanHaveMultipleCharacters()
+        {
+            var app = new CommandLineApplication();
+            var optOne = app.Option("-o1|--option1", "Option1", CommandOptionType.NoValue);
+            var optTwo = app.Option("-o2|--option2", "Option2", CommandOptionType.NoValue);
+
+            app.Execute("-o2");
+            Assert.False(optOne.HasValue(), "Option1 should not be set");
+            Assert.True(optTwo.HasValue(), "Option2 should be set");
+        }
+
+        [Fact]
+        public void OptionsCanVaryByCase()
+        {
+            var app = new CommandLineApplication();
+            var optBig = app.Option("-F|--file", "File", CommandOptionType.NoValue);
+            var optLittle = app.Option("-f|--force", "force", CommandOptionType.NoValue);
+
+            app.Execute("-f");
+            Assert.False(optBig.HasValue(), "File should not be set");
+            Assert.True(optLittle.HasValue(), "force should be set");
+        }
     }
 }

test/CommandLineUtils.Tests/HelpOptionAttributeTests.cs

@@ -4,11 +4,19 @@
 using System;
 using System.Reflection;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace McMaster.Extensions.CommandLineUtils.Tests
 {
     public class HelpOptionTests
     {
+        private readonly ITestOutputHelper _output;
+
+        public HelpOptionTests(ITestOutputHelper output)
+        {
+            _output = output;
+        }
+
         private class NoHelpOptionClass
         {
             [Option]
@@ -121,5 +129,44 @@ public void SetsHelpOptionOnProp()
             Assert.Equal("help", builder.App.OptionHelp.LongName);
             Assert.Equal("My help info", builder.App.OptionHelp.Description);
         }
+
+        [HelpOption]
+        private class SimpleHelpApp
+        {
+            private void OnExecute()
+            {
+                throw new InvalidOperationException("This method should not be invoked");
+            }
+        }
+
+        [Theory]
+        [InlineData("-h")]
+        [InlineData("-?")]
+        [InlineData("--help")]
+        public void OnExecuteIsNotInvokedWhenHelpOptionSpecified(string arg)
+        {
+            Assert.Equal(0, CommandLineApplication.Execute<SimpleHelpApp>(new TestConsole(_output), arg));
+        }
+
+        [Command(StopParsingAfterHelpOption = false)]
+        private class KeepParsingHelpApp
+        {
+            [HelpOption]
+            public bool IsHelp { get; }
+
+            private int OnExecute()
+            {
+                return 15;
+            }
+        }
+
+        [Theory]
+        [InlineData("-h")]
+        [InlineData("-?")]
+        [InlineData("--help")]
+        public void InvokesOnExecuteWhenStopParsingHelpDisabled(string arg)
+        {
+            Assert.Equal(15, CommandLineApplication.Execute<KeepParsingHelpApp>(new TestConsole(_output), arg));
+        }
     }
 }

test/CommandLineUtils.Tests/ValidationTests.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Nate McMaster.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
 using System.ComponentModel.DataAnnotations;
 using Xunit;
 using Xunit.Abstractions;
@@ -168,5 +169,37 @@ public void ValidatesEmailOption(string[] args, int exitCode)
         {
             Assert.Equal(exitCode, CommandLineApplication.Execute<EmailOptionApp>(args));
         }
+
+        private class ValidationErrorApp
+        {
+            [Required, Option]
+            public string Name { get; }
+            private int OnValidationError()
+            {
+                return 7;
+            }
+        }
+
+        [Fact]
+        public void OnValidationErrorIsInvokedOnError()
+        {
+            Assert.Equal(7, CommandLineApplication.Execute<ValidationErrorApp>(new TestConsole(_output)));
+        }
+
+        private class ThrowOnExecuteApp
+        {
+            [Option, Required]
+            public string Name { get; }
+            private int OnExecute()
+            {
+                throw new InvalidOperationException("This method should not be invoked");
+            }
+        }
+
+        [Fact]
+        public void OnExecuteIsNotInvokedOnValidationError()
+        {
+            Assert.Equal(1, CommandLineApplication.Execute<ThrowOnExecuteApp>(new TestConsole(_output)));
+        }
     }
 }

test/CommandLineUtils.Tests/VersionOptionAttributeTests.cs

@@ -4,11 +4,19 @@
 using System;
 using System.Reflection;
 using Xunit;
+using Xunit.Abstractions;
 
 namespace McMaster.Extensions.CommandLineUtils.Tests
 {
     public class VersionOptionTests
     {
+        private readonly ITestOutputHelper _output;
+
+        public VersionOptionTests(ITestOutputHelper output)
+        {
+            _output = output;
+        }
+
         private class NoVersionOptionClass
         {
             [Option]
@@ -138,5 +146,41 @@ public void SetsVersionOptionOnProp()
             Assert.Equal("version", builder.App.OptionVersion.LongName);
             Assert.Equal("My version info", builder.App.OptionVersion.Description);
         }
+
+        [VersionOption("-?|-V|--version", "1.0.0")]
+        private class SimpleVersionApp
+        {
+            private void OnExecute()
+            {
+                throw new InvalidOperationException("This method should not be invoked");
+            }
+        }
+
+        [Theory]
+        [InlineData("-?")]
+        [InlineData("-V")]
+        [InlineData("--version")]
+        public void OnExecuteIsNotInvokedWhenVersionOptionSpecified(string arg)
+        {
+            Assert.Equal(0, CommandLineApplication.Execute<SimpleVersionApp>(new TestConsole(_output), arg));
+        }
+
+        [Command(StopParsingAfterVersionOption = false)]
+        private class KeepParsingVersionApp
+        {
+            [VersionOption("1.0.0")]
+            public bool IsVersion { get; }
+
+            private int OnExecute()
+            {
+                return 14;
+            }
+        }
+
+        [Fact]
+        public void InvokesOnExecuteWhenStopParsingVersionDisabled()
+        {
+            Assert.Equal(14, CommandLineApplication.Execute<KeepParsingVersionApp>(new TestConsole(_output), "--version"));
+        }
     }
 }