Make UnrecognizedArgumentHandling per command scope

src/CommandLineUtils/Attributes/CommandAttribute.cs

@@ -93,7 +93,13 @@ public string? Name
         /// <summary>
         /// Set the behavior for how to handle unrecognized arguments.
         /// </summary>
-        public UnrecognizedArgumentHandling UnrecognizedArgumentHandling { get; set; } = UnrecognizedArgumentHandling.Throw;
+        public UnrecognizedArgumentHandling UnrecognizedArgumentHandling
+        {
+            get => _unrecognizedArgumentHandling ?? UnrecognizedArgumentHandling.Throw;
+            set => _unrecognizedArgumentHandling = value;
+        }
+
+        private UnrecognizedArgumentHandling? _unrecognizedArgumentHandling;
 
         /// <summary>
         /// Allow '--' to be used to stop parsing arguments.
@@ -172,7 +178,6 @@ internal void Configure(CommandLineApplication app)
             app.FullName = FullName;
             app.ResponseFileHandling = ResponseFileHandling;
             app.ShowInHelpText = ShowInHelpText;
-            app.UnrecognizedArgumentHandling = UnrecognizedArgumentHandling;
             app.OptionsComparison = OptionsComparison;
             app.ValueParsers.ParseCulture = ParseCulture;
             app.UsePagerForHelpText = UsePagerForHelpText;
@@ -181,6 +186,11 @@ internal void Configure(CommandLineApplication app)
             {
                 app.ClusterOptions = _clusterOptions.Value;
             }
+
+            if (_unrecognizedArgumentHandling.HasValue)
+            {
+                app.UnrecognizedArgumentHandling = _unrecognizedArgumentHandling.Value;
+            }
         }
     }
 }

src/CommandLineUtils/CommandLineApplication.cs

@@ -122,7 +122,7 @@ internal CommandLineApplication(
             SetContext(context);
             _services = new Lazy<IServiceProvider>(() => new ServiceProvider(this));
             ValueParsers = parent?.ValueParsers ?? new ValueParserProvider();
-            _parserConfig = parent?._parserConfig ?? new ParserConfig();
+            _parserConfig = new ParserConfig();
             _clusterOptions = parent?._clusterOptions;
             UsePagerForHelpText = parent?.UsePagerForHelpText ?? false;
 
@@ -255,7 +255,7 @@ public CommandOption? OptionHelp
         /// </summary>
         public UnrecognizedArgumentHandling UnrecognizedArgumentHandling
         {
-            get => _parserConfig.UnrecognizedArgumentHandling;
+            get => _parserConfig.UnrecognizedArgumentHandling ?? Parent?.UnrecognizedArgumentHandling ?? UnrecognizedArgumentHandling.Throw;
             set => _parserConfig.UnrecognizedArgumentHandling = value;
         }
 
@@ -356,10 +356,23 @@ public bool ClusterOptions
         /// </example>
         public char[] OptionNameValueSeparators
         {
-            get => _parserConfig.OptionNameValueSeparators;
-            set => _parserConfig.OptionNameValueSeparators = value;
+            get => _parserConfig.OptionNameValueSeparators ?? Parent?.OptionNameValueSeparators ?? new[] { ' ', ':', '=' };
+            set
+            {
+                if (value is null)
+                {
+                    throw new ArgumentNullException(nameof(value));
+                }
+                else if (value.Length == 0)
+                {
+                    throw new ArgumentException(Strings.IsEmptyArray, nameof(value));
+                }
+                _parserConfig.OptionNameValueSeparators = value;
+            }
         }
 
+        internal bool OptionNameAndValueCanBeSpaceSeparated => Array.IndexOf(this.OptionNameValueSeparators, ' ') >= 0;
+
         /// <summary>
         /// Gets the default value parser provider.
         /// <para>
@@ -728,7 +741,7 @@ public ParseResult Parse(params string[] args)
 
             args ??= Util.EmptyArray<string>();
 
-            var processor = new CommandLineProcessor(this, _parserConfig, args);
+            var processor = new CommandLineProcessor(this, args);
             var result = processor.Process();
             result.SelectedCommand.HandleParseResult(result);
             return result;

src/CommandLineUtils/Internal/CommandLineProcessor.cs

@@ -14,7 +14,6 @@ namespace McMaster.Extensions.CommandLineUtils
     internal sealed class CommandLineProcessor
     {
         private readonly CommandLineApplication _initialCommand;
-        private readonly ParserConfig _config;
         private readonly ArgumentEnumerator _enumerator;
 
         private CommandLineApplication _currentCommand
@@ -31,12 +30,10 @@ private CommandLineApplication _currentCommand
 
         public CommandLineProcessor(
             CommandLineApplication command,
-            ParserConfig config,
             IReadOnlyList<string> arguments)
         {
             _initialCommand = command;
-            _config = config ?? throw new ArgumentNullException(nameof(config));
-            _enumerator = new ArgumentEnumerator(command, _config, arguments ?? new string[0]);
+            _enumerator = new ArgumentEnumerator(command, arguments ?? new string[0]);
             CheckForShortOptionClustering(command);
         }
 
@@ -260,7 +257,7 @@ private bool ProcessOption(OptionArgument arg)
             }
             else
             {
-                if (_config.OptionNameAndValueCanBeSpaceSeparated)
+                if (_currentCommand.OptionNameAndValueCanBeSpaceSeparated)
                 {
                     if (_enumerator.MoveNext())
                     {
@@ -334,7 +331,7 @@ private bool ProcessArgumentSeparator()
 
         private bool ProcessUnexpectedArg(string argTypeName, string? argValue = null)
         {
-            switch (_config.UnrecognizedArgumentHandling)
+            switch (_currentCommand.UnrecognizedArgumentHandling)
             {
                 case UnrecognizedArgumentHandling.Throw:
                     _currentCommand.ShowHint();
@@ -429,11 +426,9 @@ private sealed class ArgumentEnumerator : IEnumerator<Argument?>
         {
             private readonly IEnumerator<string> _rawArgEnumerator;
             private IEnumerator<string>? _rspEnumerator;
-            private readonly ParserConfig _config;
 
-            public ArgumentEnumerator(CommandLineApplication command, ParserConfig config, IReadOnlyList<string> rawArguments)
+            public ArgumentEnumerator(CommandLineApplication command, IReadOnlyList<string> rawArguments)
             {
-                _config = config;
                 CurrentCommand = command;
                 _rawArgEnumerator = rawArguments.GetEnumerator();
             }
@@ -489,15 +484,15 @@ private Argument CreateArgument(string raw)
 
                 if (raw[1] != '-')
                 {
-                    return new OptionArgument(raw, _config.OptionNameValueSeparators, isShortOption: true);
+                    return new OptionArgument(raw, CurrentCommand.OptionNameValueSeparators, isShortOption: true);
                 }
 
                 if (raw.Length == 2)
                 {
                     return ArgumentSeparatorArgument.Instance;
                 }
 
-                return new OptionArgument(raw, _config.OptionNameValueSeparators, isShortOption: false);
+                return new OptionArgument(raw, CurrentCommand.OptionNameValueSeparators, isShortOption: false);
             }
 
             private IEnumerator<string> CreateRspParser(string path)

src/CommandLineUtils/Internal/ParserConfig.cs

@@ -1,17 +1,13 @@
 // Copyright (c) Nate McMaster.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System;
-
 namespace McMaster.Extensions.CommandLineUtils
 {
     /// <summary>
     /// Configures the argument parser.
     /// </summary>
     internal class ParserConfig
     {
-        private char[] _optionNameValueSeparators = { ' ', ':', '=' };
-
         /// <summary>
         /// Characters used to separate the option name from the value.
         /// <para>
@@ -25,26 +21,11 @@ internal class ParserConfig
         /// <example>
         /// Given --name=value, = is the separator.
         /// </example>
-        public char[] OptionNameValueSeparators
-        {
-            get => _optionNameValueSeparators;
-            set
-            {
-                _optionNameValueSeparators = value ?? throw new ArgumentNullException(nameof(value));
-                if (value.Length == 0)
-                {
-                    throw new ArgumentException(Strings.IsNullOrEmpty, nameof(value));
-                }
-                OptionNameAndValueCanBeSpaceSeparated = Array.IndexOf(OptionNameValueSeparators, ' ') >= 0;
-            }
-        }
-
-        internal bool OptionNameAndValueCanBeSpaceSeparated { get; private set; } = true;
+        public char[]? OptionNameValueSeparators { get; set; }
 
         /// <summary>
         /// Set the behavior for how to handle unrecognized arguments.
         /// </summary>
-        public UnrecognizedArgumentHandling UnrecognizedArgumentHandling { get; set; } =
-            UnrecognizedArgumentHandling.Throw;
+        public UnrecognizedArgumentHandling? UnrecognizedArgumentHandling { get; set; }
     }
 }

src/CommandLineUtils/Properties/Strings.cs

@@ -16,7 +16,7 @@ internal static class Strings
         public const string DefaultVersionTemplate = "--version";
         public const string DefaultVersionOptionDescription = "Show version information.";
 
-        public const string IsNullOrEmpty = "Value is null or empty.";
+        public const string IsEmptyArray = "value is an empty array.";
 
         public const string PathMustNotBeRelative = "File path must not be relative.";
 

test/CommandLineUtils.Tests/CommandLineApplicationOfTTests.cs

@@ -101,6 +101,28 @@ public ThrowsInCtorClass()
             public void OnExecute() { }
         }
 
+        [Command(UnrecognizedArgumentHandling = UnrecognizedArgumentHandling.StopParsingAndCollect)]
+        [Subcommand(typeof(FooCommand))]
+        class NotThrowOnUnrecognizedArgumentClass
+        {
+            public void OnExecute() { }
+        }
+
+        [Command]
+        class FooCommand
+        {
+        }
+
+        [Fact]
+        public void AllowNoThrowBehaviorOnUnexpectedOptionWhenHasSubcommand()
+        {
+            using var app = new CommandLineApplication<NotThrowOnUnrecognizedArgumentClass>();
+            app.Conventions.UseDefaultConventions();
+
+            // should not throw
+            app.Execute("--unexpected");
+        }
+
         [Fact]
         public void ItDoesNotInitalizeClassUnlessNecessary()
         {

test/CommandLineUtils.Tests/CommandLineApplicationTests.cs

@@ -494,6 +494,22 @@ public void AllowNoThrowBehaviorOnUnexpectedOptionAfterSubcommand()
             Assert.Equal(unexpectedOption, arg);
         }
 
+        [Fact]
+        public void AllowNoThrowBehaviorOnUnexpectedOptionWhenHasSubcommand()
+        {
+            var app = new CommandLineApplication
+            {
+                UnrecognizedArgumentHandling = UnrecognizedArgumentHandling.StopParsingAndCollect
+            };
+            app.Command("k", c =>
+            {
+                c.UnrecognizedArgumentHandling = UnrecognizedArgumentHandling.Throw;
+            });
+
+            // should not throw
+            app.Execute("--unexpected");
+        }
+
         [Fact]
         public void CollectUnrecognizedArguments()
         {
@@ -754,6 +770,20 @@ public void OptionSeparatorMustNotUseSpace()
             Assert.Equal("abc", option.Value());
         }
 
+        [Fact]
+        public void AllowSettingOptionNameValueSeparatorsPerCommand()
+        {
+            var app = new CommandLineApplication();
+
+            app.Command("k", c =>
+            {
+                c.Option("-o", "option desc.", CommandOptionType.SingleValue);
+                c.OptionNameValueSeparators = new[] { '=' };
+            });
+
+            Assert.ThrowsAny<CommandParsingException>(() => app.Parse("k", "-o", "foo"));
+        }
+
         [Fact]
         public void HelpTextIgnoresHiddenItems()
         {