Add default verb support

demo/ReadText.Demo/Options.cs

@@ -27,7 +27,7 @@ interface IOptions
         string FileName { get; set; }
     }
 
-    [Verb("head", HelpText = "Displays first lines of a file.")]
+    [Verb("head", true, HelpText = "Displays first lines of a file.")]
     class HeadOptions : IOptions
     {
         public uint? Lines { get; set; }
@@ -62,4 +62,4 @@ class TailOptions : IOptions
 
         public string FileName { get; set; }
     }
-}
+}

src/CommandLine/Core/InstanceChooser.cs

@@ -23,6 +23,15 @@ public static ParserResult<object> Choose(
             bool autoVersion,
             IEnumerable<ErrorType> nonFatalErrors)
         {
+            var verbs = Verb.SelectFromTypes(types);
+            var defaultVerbs = verbs.Where(t => t.Item1.IsDefault);
+
+            int defaultVerbCount = defaultVerbs.Count();
+            if (defaultVerbCount > 1)
+                return MakeNotParsed(types, new MultipleDefaultVerbsError());
+
+            var defaultVerb = defaultVerbCount == 1 ? defaultVerbs.First() : null;
+
             Func<ParserResult<object>> choose = () =>
             {
                 var firstArg = arguments.First();
@@ -31,25 +40,52 @@ public static ParserResult<object> Choose(
                         nameComparer.Equals(command, firstArg) ||
                         nameComparer.Equals(string.Concat("--", command), firstArg);
 
-                var verbs = Verb.SelectFromTypes(types);
-
                 return (autoHelp && preprocCompare("help"))
                     ? MakeNotParsed(types,
                         MakeHelpVerbRequestedError(verbs,
                             arguments.Skip(1).FirstOrDefault() ?? string.Empty, nameComparer))
                     : (autoVersion && preprocCompare("version"))
                         ? MakeNotParsed(types, new VersionRequestedError())
-                        : MatchVerb(tokenizer, verbs, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, nonFatalErrors);
+                        : MatchVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, nonFatalErrors);
             };
 
             return arguments.Any()
                 ? choose()
-                : MakeNotParsed(types, new NoVerbSelectedError());
+                : (defaultVerbCount == 1
+                    ? MatchDefaultVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, nonFatalErrors)
+                    : MakeNotParsed(types, new NoVerbSelectedError()));
+        }
+
+        private static ParserResult<object> MatchDefaultVerb(
+            Func<IEnumerable<string>, IEnumerable<OptionSpecification>, Result<IEnumerable<Token>, Error>> tokenizer,
+            IEnumerable<Tuple<Verb, Type>> verbs,
+            Tuple<Verb, Type> defaultVerb,
+            IEnumerable<string> arguments,
+            StringComparer nameComparer,
+            bool ignoreValueCase,
+            CultureInfo parsingCulture,
+            bool autoHelp,
+            bool autoVersion,
+            IEnumerable<ErrorType> nonFatalErrors)
+        {
+            return !(defaultVerb is null)
+                ? InstanceBuilder.Build(
+                    Maybe.Just<Func<object>>(() => defaultVerb.Item2.AutoDefault()),
+                    tokenizer,
+                    arguments,
+                    nameComparer,
+                    ignoreValueCase,
+                    parsingCulture,
+                    autoHelp,
+                    autoVersion,
+                    nonFatalErrors)
+                : MakeNotParsed(verbs.Select(v => v.Item2), new BadVerbSelectedError(arguments.First()));
         }
 
         private static ParserResult<object> MatchVerb(
             Func<IEnumerable<string>, IEnumerable<OptionSpecification>, Result<IEnumerable<Token>, Error>> tokenizer,
             IEnumerable<Tuple<Verb, Type>> verbs,
+            Tuple<Verb, Type> defaultVerb,
             IEnumerable<string> arguments,
             StringComparer nameComparer,
             bool ignoreValueCase,
@@ -71,7 +107,7 @@ private static ParserResult<object> MatchVerb(
                     autoHelp,
                     autoVersion,
                     nonFatalErrors)
-                : MakeNotParsed(verbs.Select(v => v.Item2), new BadVerbSelectedError(arguments.First()));
+                : MatchDefaultVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, nonFatalErrors);
         }
 
         private static HelpVerbRequestedError MakeHelpVerbRequestedError(

src/CommandLine/Core/Verb.cs

@@ -12,12 +12,17 @@ sealed class Verb
         private readonly string name;
         private readonly string helpText;
         private readonly bool hidden;
+        private readonly bool isDefault;
 
-        public Verb(string name, string helpText, bool hidden = false)
+        public Verb(string name, string helpText, bool hidden = false, bool isDefault = false)
         {
-            this.name = name ?? throw new ArgumentNullException(nameof(name));
+            if (!isDefault && string.IsNullOrWhiteSpace(name))
+                throw new ArgumentNullException(nameof(name));
+            this.name = name ?? string.Empty;
+
             this.helpText = helpText ?? throw new ArgumentNullException(nameof(helpText));
             this.hidden = hidden;
+            this.isDefault = isDefault;
         }
 
         public string Name
@@ -35,12 +40,18 @@ public bool Hidden
             get { return hidden; }
         }
 
+        public bool IsDefault
+        {
+            get => isDefault;
+        }
+
         public static Verb FromAttribute(VerbAttribute attribute)
         {
             return new Verb(
                 attribute.Name,
                 attribute.HelpText,
-                attribute.Hidden
+                attribute.Hidden,
+                attribute.IsDefault
                 );
         }
 
@@ -54,4 +65,4 @@ select Tuple.Create(
                        type);
         }
     }
-}
+}

src/CommandLine/Error.cs

@@ -74,8 +74,11 @@ public enum ErrorType
         /// <summary>
         /// Value of <see cref="CommandLine.MissingGroupOptionError"/> type.
         /// </summary>
-        MissingGroupOptionError
-
+        MissingGroupOptionError,
+        /// <summary>
+        /// Value of <see cref="CommandLine.MultipleDefaultVerbsError"/> type.
+        /// </summary>
+        MultipleDefaultVerbsError
     }
 
     /// <summary>
@@ -556,4 +559,16 @@ public IEnumerable<NameInfo> Names
             get { return names; }
         }
     }
+
+    /// <summary>
+    /// Models an error generated when multiple default verbs are defined.
+    /// </summary>
+    public sealed class MultipleDefaultVerbsError : Error
+    {
+        public const string ErrorMessage = "More than one default verb is not allowed.";
+
+        internal MultipleDefaultVerbsError()
+            : base(ErrorType.MultipleDefaultVerbsError)
+        { }
+    }
 }

src/CommandLine/Text/SentenceBuilder.cs

@@ -158,6 +158,8 @@ public override Func<Error, string> FormatError
                                         "' (",
                                         string.Join(", ", missingGroupOptionError.Names.Select(n => n.NameText)),
                                         ") is required.");
+                                case ErrorType.MultipleDefaultVerbsError:
+                                    return MultipleDefaultVerbsError.ErrorMessage;
                             }
                             throw new InvalidOperationException();
                         };

src/CommandLine/VerbAttribute.cs

@@ -12,19 +12,22 @@ namespace CommandLine
     public  class VerbAttribute : Attribute
     {
         private readonly string name;
+        private readonly bool isDefault;
         private Infrastructure.LocalizableAttributeProperty helpText;
         private Type resourceType;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="CommandLine.VerbAttribute"/> class.
         /// </summary>
         /// <param name="name">The long name of the verb command.</param>
-        /// <exception cref="System.ArgumentException">Thrown if <paramref name="name"/> is null, empty or whitespace.</exception>
-        public VerbAttribute(string name)
+        /// <param name="isDefault">Whether the verb is the default verb.</param>
+        /// <exception cref="System.ArgumentException">Thrown if <paramref name="name"/> is null, empty or whitespace and <paramref name="isDefault"/> is false.</exception>
+        public VerbAttribute(string name, bool isDefault = false)
         {
-            if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("name");
+            if (!isDefault && string.IsNullOrWhiteSpace(name)) throw new ArgumentException("name");
 
-            this.name = name;
+            this.name = name ?? string.Empty;
+            this.isDefault = isDefault;
             helpText = new Infrastructure.LocalizableAttributeProperty(nameof(HelpText));
             resourceType = null;
         }
@@ -62,5 +65,13 @@ public Type ResourceType
             get => resourceType;
             set => resourceType =helpText.ResourceType = value;
         }
+
+        /// <summary>
+        /// Gets whether this verb is the default verb.
+        /// </summary>
+        public bool IsDefault
+        {
+            get => isDefault;
+        }
     }
 }

tests/CommandLine.Tests/Fakes/Verb_Fakes.cs

@@ -85,4 +85,25 @@ class Verb_With_Option_And_Value_Of_String_Type
         [Value(0)]
         public string PosValue { get; set; }
     }
-}
+
+    [Verb("default1", true)]
+    class Default_Verb_One
+    {
+        [Option('t', "test-one")]
+        public bool TestValueOne { get; set; }
+    }
+
+    [Verb("default2", true)]
+    class Default_Verb_Two
+    {
+        [Option('t', "test-two")]
+        public bool TestValueTwo { get; set; }
+    }
+
+    [Verb(null, true)]
+    class Default_Verb_With_Empty_Name
+    {
+        [Option('t', "test")]
+        public bool TestValue { get; set; }
+    }
+}

tests/CommandLine.Tests/Unit/ParserTests.cs

@@ -825,5 +825,50 @@ public void Blank_lines_are_inserted_between_verbs()
             // Teardown
         }
 
+
+        [Fact]
+        public void Parse_default_verb_implicit()
+        {
+            var parser = Parser.Default;
+            parser.ParseArguments<Default_Verb_One>(new[] { "-t" })
+                .WithNotParsed(errors => throw new InvalidOperationException("Must be parsed."))
+                .WithParsed(args =>
+                {
+                    Assert.True(args.TestValueOne);
+                });
+        }
+
+        [Fact]
+        public void Parse_default_verb_explicit()
+        {
+            var parser = Parser.Default;
+            parser.ParseArguments<Default_Verb_One>(new[] { "default1", "-t" })
+                .WithNotParsed(errors => throw new InvalidOperationException("Must be parsed."))
+                .WithParsed(args =>
+                {
+                    Assert.True(args.TestValueOne);
+                });
+        }
+
+        [Fact]
+        public void Parse_multiple_default_verbs()
+        {
+            var parser = Parser.Default;
+            parser.ParseArguments<Default_Verb_One, Default_Verb_Two>(new string[] { })
+                .WithNotParsed(errors => Assert.IsType<MultipleDefaultVerbsError>(errors.First()))
+                .WithParsed(args => throw new InvalidOperationException("Should not be parsed."));
+        }
+
+        [Fact]
+        public void Parse_default_verb_with_empty_name()
+        {
+            var parser = Parser.Default;
+            parser.ParseArguments<Default_Verb_With_Empty_Name>(new[] { "-t" })
+                .WithNotParsed(errors => throw new InvalidOperationException("Must be parsed."))
+                .WithParsed(args =>
+                {
+                    Assert.True(args.TestValue);
+                });
+        }
     }
 }