API review: remove ParserSettings

Will revisit the need for a separate parser settings class in 3.0

Author: natemcmaster

src/CommandLineUtils/Attributes/CommandAttribute.cs

@@ -100,6 +100,40 @@ public string Name
         /// </summary>
         public CultureInfo ParseCulture { get; set; } = CultureInfo.CurrentCulture;
 
+        /// <summary>
+        /// <para>
+        /// One or more options of <see cref="CommandOptionType.NoValue"/>, followed by at most one option that takes values, should be accepted when grouped behind one '-' delimiter.
+        /// </para>
+        /// <para>
+        /// When true, the following are equivalent.
+        ///
+        /// <code>
+        /// -abcXyellow
+        /// -abcX=yellow
+        /// -abcX:yellow
+        /// -abc -X=yellow
+        /// -ab -cX=yellow
+        /// -a -b -c -Xyellow
+        /// -a -b -c -X yellow
+        /// -a -b -c -X=yellow
+        /// -a -b -c -X:yellow
+        /// </code>
+        /// </para>
+        /// <para>
+        /// This defaults to true unless an option with a short name of two or more characters is added.
+        /// </para>
+        /// </summary>
+        /// <remarks>
+        /// <seealso href="https://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html"/>
+        /// </remarks>
+        public bool ClusterOptions
+        {
+            get => _clusterOptions ?? true;
+            set => _clusterOptions = value;
+        }
+
+        private bool? _clusterOptions;
+
         internal void Configure(CommandLineApplication app)
         {
             // this might have been set from SubcommandAttribute
@@ -119,6 +153,11 @@ internal void Configure(CommandLineApplication app)
             app.ThrowOnUnexpectedArgument = ThrowOnUnexpectedArgument;
             app.OptionsComparison = OptionsComparison;
             app.ValueParsers.ParseCulture = ParseCulture;
+
+            if (_clusterOptions.HasValue)
+            {
+                app.ClusterOptions = _clusterOptions.Value;
+            }
         }
     }
 }

src/CommandLineUtils/CommandLineApplication.cs

@@ -104,7 +104,7 @@ internal CommandLineApplication(CommandLineApplication parent,
             SetContext(context);
             _services = new Lazy<IServiceProvider>(() => new ServiceProvider(this));
             ValueParsers = parent?.ValueParsers ?? new ValueParserProvider();
-            ParserSettings = parent?.ParserSettings ?? new ParserSettings();
+            _clusterOptions = parent?._clusterOptions;
 
             _conventionContext = CreateConventionContext();
 
@@ -280,6 +280,42 @@ public CommandOption OptionHelp
         /// </summary>
         public StringComparison OptionsComparison { get; set; }
 
+        /// <summary>
+        /// <para>
+        /// One or more options of <see cref="CommandOptionType.NoValue"/>, followed by at most one option that takes values, should be accepted when grouped behind one '-' delimiter.
+        /// </para>
+        /// <para>
+        /// When true, the following are equivalent.
+        ///
+        /// <code>
+        /// -abcXyellow
+        /// -abcX=yellow
+        /// -abcX:yellow
+        /// -abc -X=yellow
+        /// -ab -cX=yellow
+        /// -a -b -c -Xyellow
+        /// -a -b -c -X yellow
+        /// -a -b -c -X=yellow
+        /// -a -b -c -X:yellow
+        /// </code>
+        /// </para>
+        /// <para>
+        /// This defaults to true unless an option with a short name of two or more characters is added.
+        /// </para>
+        /// </summary>
+        /// <remarks>
+        /// <seealso href="https://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html"/>
+        /// </remarks>
+        public bool ClusterOptions
+        {
+            get => _clusterOptions ?? true;
+            set => _clusterOptions = value;
+        }
+
+        private bool? _clusterOptions;
+
+        internal bool ClusterOptionsWasSetExplicitly => _clusterOptions.HasValue;
+
         /// <summary>
         /// Gets the default value parser provider.
         /// <para>
@@ -623,16 +659,25 @@ public ParseResult Parse(params string[] args)
         {
             args = args ?? new string[0];
 
-            var processor = new CommandLineProcessor(this, ParserSettings, args);
+            var processor = new CommandLineProcessor(this, args);
             var result = processor.Process();
             result.SelectedCommand.HandleParseResult(result);
             return result;
         }
 
         /// <summary>
-        /// Settings to control the behavior of the parser.
+        /// When an invalid argument is given, make suggestions in the error message
+        /// about similar, valid commands or options.
+        /// <para>
+        /// $ git pshu
+        /// Specify --help for a list of available options and commands
+        /// Unrecognized command or argument 'pshu'
+        ///
+        /// Did you mean this?
+        ///     push
+        /// </para>
         /// </summary>
-        public ParserSettings ParserSettings { get; }
+        public bool MakeSuggestionsInErrorMessage { get; set; } = true;
 
         /// <summary>
         /// Handle the result of parsing command line arguments.

…singParameterlessConstructorException.cs …singParameterlessConstructorException.cssrc/CommandLineUtils/MissingParameterlessConstructorException.cs renamed to src/CommandLineUtils/Errors/MissingParameterlessConstructorException.cs src/CommandLineUtils/MissingParameterlessConstructorException.cs renamed to src/CommandLineUtils/Errors/MissingParameterlessConstructorException.cs

@@ -1,11 +1,15 @@
-using System;
+// 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.Reflection;
 
 namespace McMaster.Extensions.CommandLineUtils
 {
     /// <summary>
     /// The exception that is thrown when trying to instantiate a model with no parameterless constructor.
     /// </summary>
-    public class MissingParameterlessConstructorException : Exception
+    public class MissingParameterlessConstructorException : TargetException
     {
         /// <summary>
         /// Gets the type that caused the exception.
@@ -17,7 +21,8 @@ public class MissingParameterlessConstructorException : Exception
         /// </summary>
         /// <param name="type">The type missing a parameterless constructor.</param>
         /// <param name="innerException">The original exception.</param>
-        public MissingParameterlessConstructorException(Type type, Exception innerException) : base($"Class {type.FullName} does not have a parameterless constructor", innerException)
+        public MissingParameterlessConstructorException(Type type, Exception innerException)
+            : base($"Class {type.FullName} does not have a parameterless constructor", innerException)
         {
             Type = type;
         }

…s/UnrecognizedCommandParsingException.cs …s/UnrecognizedCommandParsingException.cssrc/CommandLineUtils/UnrecognizedCommandParsingException.cs renamed to src/CommandLineUtils/Errors/UnrecognizedCommandParsingException.cs src/CommandLineUtils/UnrecognizedCommandParsingException.cs renamed to src/CommandLineUtils/Errors/UnrecognizedCommandParsingException.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.Collections.Generic;
 
 namespace McMaster.Extensions.CommandLineUtils
@@ -11,23 +12,28 @@ namespace McMaster.Extensions.CommandLineUtils
     /// </summary>
     public class UnrecognizedCommandParsingException : CommandParsingException
     {
-
         /// <summary>
         /// Initializes an instance of <see cref="UnrecognizedCommandParsingException"/>.
         /// </summary>
         /// <param name="command"></param>
+        /// <param name="nearestMatches">The options or commands that </param>
         /// <param name="message"></param>
-        public UnrecognizedCommandParsingException(CommandLineApplication command, string message) : base(command, message)
-        { }
+        public UnrecognizedCommandParsingException(CommandLineApplication command,
+            IEnumerable<string> nearestMatches,
+            string message)
+            : base(command, message)
+        {
+            NearestMatches = nearestMatches ?? throw new ArgumentNullException(nameof(nearestMatches));
+        }
 
         /// <summary>
-        /// A list of strings representing suggestions about similar and valid commands or options for the invalid
+        /// A collection of strings representing suggestions about similar and valid commands or options for the invalid
         /// argument that caused this <see cref="UnrecognizedCommandParsingException"/>.
         /// </summary>
         /// <remarks>
-        /// This property is set if <see cref="ParserSettings.MakeSuggestionsInErrorMessage"/> is true
+        /// This property always be empty <see cref="CommandLineApplication.MakeSuggestionsInErrorMessage"/> is false.
         /// </remarks>
         /// <value>This property get/set the suggestions for an invalid argument.</value>
-        public List<string> NearestMatches { get; set; }
+        public IEnumerable<string> NearestMatches { get; }
     }
 }

src/CommandLineUtils/Internal/CommandLineProcessor.cs

@@ -15,7 +15,6 @@ namespace McMaster.Extensions.CommandLineUtils
     internal sealed class CommandLineProcessor
     {
         private readonly CommandLineApplication _app;
-        private readonly ParserSettings _settings;
         private readonly CommandLineApplication _initialCommand;
         private readonly ParameterEnumerator _enumerator;
 
@@ -32,30 +31,28 @@ private CommandLineApplication _currentCommand
         private CommandArgumentEnumerator _currentCommandArguments;
 
         public CommandLineProcessor(CommandLineApplication command,
-            ParserSettings settings,
             IReadOnlyList<string> arguments)
         {
             _app = command;
-            _settings = settings;
             _initialCommand = command;
             _enumerator = new ParameterEnumerator(arguments ?? new string[0]);
 
             // TODO in 3.0, remove this check, and make ClusterOptions true always
             // and make it an error to use short options with multiple characters
             var allOptions = command.Commands.SelectMany(c => c.Options).Concat(command.GetOptions());
-            if (!settings.ClusterOptionsWasSetExplicitly)
+            if (!command.ClusterOptionsWasSetExplicitly)
             {
-                settings.ClusterOptions = !allOptions.Any(o => o.ShortName != null && o.ShortName.Length > 1);
+                command.ClusterOptions = !allOptions.Any(o => o.ShortName != null && o.ShortName.Length > 1);
             }
 
-            if (settings.ClusterOptions)
+            if (command.ClusterOptions)
             {
                 foreach (var option in allOptions)
                 {
                     if (option.ShortName != null && option.ShortName.Length != 1)
                     {
                         throw new CommandParsingException(command,
-                            $"The ShortName on CommandOption is too long: '{option.ShortName}'. Short names cannot be more than one character long when {nameof(ParserSettings.ClusterOptions)} is enabled.");
+                            $"The ShortName on CommandOption is too long: '{option.ShortName}'. Short names cannot be more than one character long when {nameof(CommandLineApplication.ClusterOptions)} is enabled.");
                     }
                 }
             }
@@ -156,7 +153,7 @@ private bool ProcessOption()
             var name = arg.Name;
             if (arg.Type == ParameterType.ShortOption)
             {
-                if (_settings.ClusterOptions)
+                if (_currentCommand.ClusterOptions)
                 {
                     for (var i = 0; i < arg.Name.Length; i++)
                     {
@@ -344,16 +341,15 @@ private void HandleUnexpectedArg(string argTypeName, string argValue = null)
                 _currentCommand.ShowHint();
                 var value = argValue ?? _enumerator.Current?.Raw;
 
-                List<string> suggestions = null;
-                if (_settings.MakeSuggestionsInErrorMessage && !string.IsNullOrEmpty(value))
+                var suggestions = Enumerable.Empty<string>();
+
+                if (_currentCommand.MakeSuggestionsInErrorMessage && !string.IsNullOrEmpty(value))
                 {
                     suggestions = SuggestionCreator.GetTopSuggestions(_currentCommand, value);
                 }
 
-                throw new UnrecognizedCommandParsingException(_currentCommand, $"Unrecognized {argTypeName} '{value}'")
-                {
-                    NearestMatches = suggestions
-                };
+                throw new UnrecognizedCommandParsingException(_currentCommand, suggestions,
+                    $"Unrecognized {argTypeName} '{value}'");
             }
 
             // All remaining arguments are stored for further use

src/CommandLineUtils/Internal/StringDistance.cs

@@ -158,7 +158,6 @@ internal static IEnumerable<string> GetBestMatchesSorted(Func<string, string, in
                 .Where(candidate => candidate.normalizedDistance >= threshold)
                 .OrderByDescending(candidate => candidate.normalizedDistance)
                 .Select(candidate => candidate.stringValue);
-
         }
     }
 }

src/CommandLineUtils/Internal/SuggestionCreator.cs

@@ -4,73 +4,59 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace McMaster.Extensions.CommandLineUtils.Internal
+namespace McMaster.Extensions.CommandLineUtils
 {
     /// <summary>
     /// Creates suggestions based on an input string and a command object.
     /// </summary>
     internal static class SuggestionCreator
     {
-
         /// <summary>
         /// Gets a list of suggestions from sub commands and options of <paramref name="command"/> that are likely to
         /// fix the invalid argument <paramref name="input"/>
         /// </summary>
         /// <param name="command"></param>
         /// <param name="input"></param>
         /// <returns>A list of string with suggestions or null if no suggestions were found</returns>
-        public static List<string> GetTopSuggestions(CommandLineApplication command, string input)
+        public static IEnumerable<string> GetTopSuggestions(CommandLineApplication command, string input)
         {
             var candidates = GetCandidates(command).ToList();
 
             if (candidates.Count == 0)
             {
-                return null;
+                return Enumerable.Empty<string>();
             }
 
             return StringDistance.GetBestMatchesSorted(StringDistance.DamareuLevenshteinDistance,
                 input,
-                candidates.Select(c => c.CompareValue),
-                0.33d)
-                .ToList();
+                candidates,
+                0.33d);
         }
 
-        private static IEnumerable<Candidate> GetCandidates(CommandLineApplication command)
+        private static IEnumerable<string> GetCandidates(CommandLineApplication command)
         {
             foreach (var cmd in command.Commands)
             {
-                yield return new Candidate(cmd.Name, cmd.Name);
+                yield return cmd.Name;
             }
 
             foreach (var option in command.GetOptions().Where(o => o.ShowInHelpText))
             {
                 if (!string.IsNullOrEmpty(option.LongName))
                 {
-                    yield return new Candidate("--" + option.LongName, option.LongName);
+                    yield return option.LongName;
                 }
 
                 if (!string.IsNullOrEmpty(option.ShortName))
                 {
-                    yield return new Candidate("-" + option.ShortName, option.ShortName);
+                    yield return option.ShortName;
                 }
 
                 if (!string.IsNullOrEmpty(option.SymbolName))
                 {
-                    yield return new Candidate("-" + option.SymbolName, option.SymbolName);
+                    yield return option.SymbolName;
                 }
             }
         }
-
-        private struct Candidate
-        {
-            public Candidate(string displayValue, string compareValue)
-            {
-                DisplayValue = displayValue;
-                CompareValue = compareValue;
-            }
-
-            public string DisplayValue { get; }
-            public string CompareValue { get; }
-        }
     }
 }