implement verb aliases

Author: johnjaylward

src/CommandLine/Core/InstanceChooser.cs

@@ -50,18 +50,18 @@ public static ParserResult<object> Choose(
         {
             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 = () =>
+            ParserResult<object> choose()
             {
                 var firstArg = arguments.First();
 
-                Func<string, bool> preprocCompare = command =>
+                bool preprocCompare(string command) =>
                         nameComparer.Equals(command, firstArg) ||
                         nameComparer.Equals(string.Concat("--", command), firstArg);
 
@@ -72,7 +72,7 @@ public static ParserResult<object> Choose(
                     : (autoVersion && preprocCompare("version"))
                         ? MakeNotParsed(types, new VersionRequestedError())
                         : MatchVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, allowMultiInstance, nonFatalErrors);
-            };
+            }
 
             return arguments.Any()
                 ? choose()
@@ -120,21 +120,29 @@ private static ParserResult<object> MatchVerb(
             bool allowMultiInstance,
             IEnumerable<ErrorType> nonFatalErrors)
         {
-            return verbs.Any(a => nameComparer.Equals(a.Item1.Name, arguments.First()))
-                ? InstanceBuilder.Build(
-                    Maybe.Just<Func<object>>(
-                        () =>
-                            verbs.Single(v => nameComparer.Equals(v.Item1.Name, arguments.First())).Item2.AutoDefault()),
-                    tokenizer,
-                    arguments.Skip(1),
-                    nameComparer,
-                    ignoreValueCase,
-                    parsingCulture,
-                    autoHelp,
-                    autoVersion,
-                    allowMultiInstance,
-                    nonFatalErrors)
-                : MatchDefaultVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, nonFatalErrors);
+            string firstArg = arguments.First();
+
+            var verbUsed = verbs.FirstOrDefault(vt =>
+                    nameComparer.Equals(vt.Item1.Name, firstArg)
+                    || vt.Item1.Aliases.Any(alias => nameComparer.Equals(alias, firstArg))
+            );
+
+            if (verbUsed == default)
+            {
+                return MatchDefaultVerb(tokenizer, verbs, defaultVerb, arguments, nameComparer, ignoreValueCase, parsingCulture, autoHelp, autoVersion, nonFatalErrors);
+            }
+            return InstanceBuilder.Build(
+                Maybe.Just<Func<object>>(
+                    () => verbUsed.Item2.AutoDefault()),
+                tokenizer,
+                arguments.Skip(1),
+                nameComparer,
+                ignoreValueCase,
+                parsingCulture,
+                autoHelp,
+                autoVersion,
+                allowMultiInstance,
+                nonFatalErrors);
         }
 
         private static HelpVerbRequestedError MakeHelpVerbRequestedError(

src/CommandLine/Core/Verb.cs

@@ -9,49 +9,36 @@ namespace CommandLine.Core
 {
     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, bool isDefault = false)
+        public Verb(string name, string helpText, bool hidden, bool isDefault, IEnumerable<string> aliases)
         {
             if ( string.IsNullOrWhiteSpace(name))
                 throw new ArgumentNullException(nameof(name));
-            this.name = name;
+            Name = name;
 
-            this.helpText = helpText ?? throw new ArgumentNullException(nameof(helpText));
-            this.hidden = hidden;
-            this.isDefault = isDefault;
+            HelpText = helpText ?? throw new ArgumentNullException(nameof(helpText));
+            Hidden = hidden;
+            IsDefault = isDefault;
+            Aliases = aliases ?? new string[0];
         }
 
-        public string Name
-        {
-            get { return name; }
-        }
+        public string Name { get; private set; }
 
-        public string HelpText
-        {
-            get { return helpText; }
-        }
+        public string HelpText { get; private set; }
 
-        public bool Hidden
-        {
-            get { return hidden; }
-        }
+        public bool Hidden { get; private set; }
 
-        public bool IsDefault
-        {
-            get => isDefault;
-        }
+        public bool IsDefault { get; private set; }
+
+        public IEnumerable<string> Aliases { get; private set; }
 
         public static Verb FromAttribute(VerbAttribute attribute)
         {
             return new Verb(
                 attribute.Name,
                 attribute.HelpText,
                 attribute.Hidden,
-                attribute.IsDefault
+                attribute.IsDefault,
+                attribute.Aliases
                 );
         }
 

src/CommandLine/VerbAttribute.cs

@@ -1,6 +1,7 @@
 // Copyright 2005-2015 Giacomo Stelluti Scala & Contributors. All rights reserved. See License.md in the project root for license information.
 
 using System;
+using System.Collections.Generic;
 
 namespace CommandLine
 {
@@ -9,10 +10,8 @@ namespace CommandLine
     /// </summary>
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = true)]
     //public sealed class VerbAttribute : Attribute
-    public  class VerbAttribute : Attribute
+    public class VerbAttribute : Attribute
     {
-        private readonly string name;
-        private readonly bool isDefault;
         private Infrastructure.LocalizableAttributeProperty helpText;
         private Type resourceType;
 
@@ -21,24 +20,23 @@ public  class VerbAttribute : Attribute
         /// </summary>
         /// <param name="name">The long name of the verb command.</param>
         /// <param name="isDefault">Whether the verb is the default verb.</param>
+        /// <param name="aliases">aliases for this verb. i.e. "move" and "mv"</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)
+        public VerbAttribute(string name, bool isDefault = false, string[] aliases = null)
         {
             if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("name");
 
-            this.name = name ;
-            this.isDefault = isDefault;
+            Name = name;
+            IsDefault = isDefault;
             helpText = new Infrastructure.LocalizableAttributeProperty(nameof(HelpText));
             resourceType = null;
+            Aliases = aliases ?? new string[0];
         }
 
         /// <summary>
         /// Gets the verb name.
         /// </summary>
-        public string Name
-        {
-            get { return name; }
-        }
+        public string Name { get; private set; }
 
         /// <summary>
         /// Gets or sets a value indicating whether a command line verb is visible in the help text.
@@ -54,7 +52,7 @@ public bool Hidden
         /// </summary>
         public string HelpText
         {
-            get => helpText.Value??string.Empty;
+            get => helpText.Value ?? string.Empty;
             set => helpText.Value = value ?? throw new ArgumentNullException("value");
         }
         /// <summary>
@@ -63,15 +61,17 @@ public string HelpText
         public Type ResourceType
         {
             get => resourceType;
-            set => resourceType =helpText.ResourceType = value;
+            set => resourceType = helpText.ResourceType = value;
         }
 
         /// <summary>
         /// Gets whether this verb is the default verb.
         /// </summary>
-        public bool IsDefault
-        {
-            get => isDefault;
-        }
+        public bool IsDefault { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the aliases
+        /// </summary>
+        public IEnumerable<string> Aliases { get; private set; }
     }
 }

tests/CommandLine.Tests/Unit/Issue6Tests.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Linq;
+using CommandLine.Tests.Fakes;
+using CommandLine.Text;
+using FluentAssertions;
+using Xunit;
+using Xunit.Abstractions;
+
+//Issue #6
+//Support Aliases on verbs (i.e. "move" and "mv" are the same verb).
+
+namespace CommandLine.Tests.Unit
+{
+    public class Issue6Tests
+    {
+        [Theory]
+        [InlineData("move -a bob", typeof(AliasedVerbOption1))]
+        [InlineData("mv -a bob", typeof(AliasedVerbOption1))]
+        [InlineData("copy -a bob", typeof(AliasedVerbOption2))]
+        [InlineData("cp -a bob", typeof(AliasedVerbOption2))]
+        public void Parse_option_with_aliased_verbs(string args, Type expectedArgType)
+        {
+            var arguments = args.Split(' ');
+            object options = null;
+            var result = Parser.Default.ParseArguments<AliasedVerbOption1, AliasedVerbOption2>(arguments)
+                .WithParsed((o) => options = o)
+               ;
+
+            Assert.NotNull(options);
+            Assert.Equal(expectedArgType, options.GetType());
+        }
+
+        [Verb("move", aliases:new string[] { "mv" })]
+        public class AliasedVerbOption1
+        {
+            [Option('a', "alpha", Required = true)]
+            public string Option { get; set; }
+        }
+
+        [Verb("copy", aliases: new string[] { "cp" })]
+        public class AliasedVerbOption2
+        {
+            [Option('a', "alpha", Required = true)]
+            public string Option { get; set; }
+        }
+    }
+}