Add support for merged commands (#78)

reubeno · web-flow · commit 48e52f64baf2 · 2018-09-20T13:05:06.000-07:00
diff --git a/src/NClap/Metadata/CommandGroup`1.cs b/src/NClap/Metadata/CommandGroup`1.cs
@@ -19,7 +19,7 @@ public class CommandGroup<TCommandType> : Command, IArgumentProvider, ICommandGr
     {
         private readonly CommandGroupOptions _options;
         private readonly object _parentObject;
-        private TCommandType? _selectedCommandType;
+        private object _selectedCommand;
 
         /// <summary>
         /// Parameterless constructor. Deprecated.
@@ -68,17 +68,17 @@ public CommandGroup(TCommandType selection, object parentObject)
         /// <param name="selection">The selected command type.</param>
         /// <param name="parentObject">Optionally provides a reference to the
         /// object containing this command group.</param>
-        public CommandGroup(CommandGroupOptions options, TCommandType selection, object parentObject) : this(options)
+        public CommandGroup(CommandGroupOptions options, object selection, object parentObject) : this(options)
         {
             _parentObject = parentObject;
-            Selection = selection;
+            SelectedCommand = selection;
         }
 
         /// <summary>
         /// True if the group has a selection, false if no selection was yet
         /// made.
         /// </summary>
-        public bool HasSelection => Selection.HasValue;
+        public bool HasSelection => SelectedCommand != null;
 
         /// <summary>
         /// The enum value corresponding with the selected command, or null if no
@@ -87,19 +87,15 @@ public CommandGroup(CommandGroupOptions options, TCommandType selection, object
         [PositionalArgument(ArgumentFlags.Required, Position = 0, LongName = nameof(Command))]
         public TCommandType? Selection
         {
-            get => _selectedCommandType;
-            set
-            {
-                _selectedCommandType = value;
-                InstantiatedCommand = value.HasValue ? InstantiateCommand(value.Value) : null;
-            }
+            get => (TCommandType)SelectedCommand;
+            set => SelectedCommand = value.HasValue ? (object)value.Value : null;
         }
 
         /// <summary>
         /// The enum value corresponding with the selected command, or null if no
         /// selection has yet been made.
         /// </summary>
-        object ICommandGroup.Selection => Selection;
+        object ICommandGroup.Selection => SelectedCommand;
 
         /// <summary>
         /// The command presently selected from this group, or null if no
@@ -149,7 +145,17 @@ public override Task<CommandResult> ExecuteAsync(CancellationToken cancel)
             return InstantiatedCommand.ExecuteAsync(cancel);
         }
 
-        private ICommand InstantiateCommand(TCommandType selection)
+        private object SelectedCommand
+        {
+            get => _selectedCommand;
+            set
+            {
+                _selectedCommand = value;
+                InstantiatedCommand = value != null ? InstantiateCommand(value) : null;
+            }
+        }
+
+        private ICommand InstantiateCommand(object selection)
         {
             var commandTypeType = EnumArgumentType.Create(typeof(TCommandType));
 
diff --git a/src/NClap/Metadata/ExtensibleEnumAttribute.cs b/src/NClap/Metadata/ExtensibleEnumAttribute.cs
@@ -0,0 +1,26 @@
+﻿using System;
+using NClap.Types;
+
+namespace NClap.Metadata
+{
+    /// <summary>
+    /// Attribute that indicates the associated enum type is extensible.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Enum, AllowMultiple = true)]
+    public sealed class ExtensibleEnumAttribute : Attribute
+    {
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="provider">Provider.</param>
+        public ExtensibleEnumAttribute(Type provider)
+        {
+            Provider = provider;
+        }
+
+        /// <summary>
+        /// Implementation of <see cref="IEnumArgumentTypeProvider"/>.
+        /// </summary>
+        public Type Provider { get; set; }
+    }
+}
diff --git a/src/NClap/PublicAPI.Unshipped.txt b/src/NClap/PublicAPI.Unshipped.txt
@@ -6,9 +6,13 @@ NClap.Help.ArgumentHelpOptions.IncludeNamedArgumentValueSyntax.set -> void
 NClap.Metadata.ArgumentSetAttribute.ExpandLogo.get -> bool
 NClap.Metadata.ArgumentSetAttribute.ExpandLogo.set -> void
 NClap.Metadata.CommandGroup<TCommandType>.CommandGroup(NClap.Metadata.CommandGroupOptions options) -> void
-NClap.Metadata.CommandGroup<TCommandType>.CommandGroup(NClap.Metadata.CommandGroupOptions options, TCommandType selection, object parentObject) -> void
+NClap.Metadata.CommandGroup<TCommandType>.CommandGroup(NClap.Metadata.CommandGroupOptions options, object selection, object parentObject) -> void
 NClap.Metadata.CommandGroupOptions
 NClap.Metadata.CommandGroupOptions.DeepClone() -> NClap.Metadata.CommandGroupOptions
+NClap.Metadata.ExtensibleEnumAttribute
+NClap.Metadata.ExtensibleEnumAttribute.ExtensibleEnumAttribute(System.Type provider) -> void
+NClap.Metadata.ExtensibleEnumAttribute.Provider.get -> System.Type
+NClap.Metadata.ExtensibleEnumAttribute.Provider.set -> void
 NClap.Parser.ArgumentDefinition.ArgumentDefinition(System.Reflection.MemberInfo member, NClap.Metadata.ArgumentBaseAttribute attribute, NClap.Parser.ArgumentSetDefinition argSet, object defaultValue = null, NClap.Parser.ArgumentDefinition containingArgument = null, NClap.ServiceConfigurer serviceConfigurer = null) -> void
 NClap.Parser.AttributeBasedArgumentDefinitionFactory
 NClap.Repl.ILoopClient.PromptWithColor.get -> NClap.Utilities.ColoredString?
@@ -26,14 +30,16 @@ NClap.ServiceConfigurer
 NClap.Types.ArgumentParseContext.ServiceConfigurer.get -> NClap.ServiceConfigurer
 NClap.Types.ArgumentParseContext.ServiceConfigurer.set -> void
 NClap.Types.IArgumentValue.GetAttributes<T>() -> System.Collections.Generic.IEnumerable<T>
+NClap.Types.IEnumArgumentTypeProvider
+NClap.Types.IEnumArgumentTypeProvider.GetTypes() -> System.Collections.Generic.IEnumerable<NClap.Types.IEnumArgumentType>
 static NClap.CommandLineParser.Format<T>(T value, NClap.CommandLineParserOptions options) -> System.Collections.Generic.IEnumerable<string>
+static NClap.CommandLineParser.GetCompletions(System.Type type, string commandLineToComplete, int charIndexOfCursor) -> System.Collections.Generic.IEnumerable<string>
+static NClap.CommandLineParser.GetCompletions(System.Type type, string commandLineToComplete, int charIndexOfCursor, int tokensToSkip, NClap.CommandLineParserOptions options) -> System.Collections.Generic.IEnumerable<string>
 static NClap.CommandLineParser.GetUsageInfo(System.Type type, NClap.Help.ArgumentSetHelpOptions options = null, object defaultValues = null, NClap.ServiceConfigurer serviceConfigurer = null) -> NClap.Utilities.ColoredMultistring
 static NClap.CommandLineParserOptionsExtensions.ConfigureServices(this NClap.Utilities.FluentBuilder<NClap.CommandLineParserOptions> builder, NClap.ServiceConfigurer configurer) -> NClap.Utilities.FluentBuilder<NClap.CommandLineParserOptions>
 static NClap.CommandLineParserOptionsExtensions.Quiet(this NClap.Utilities.FluentBuilder<NClap.CommandLineParserOptions> builder) -> NClap.Utilities.FluentBuilder<NClap.CommandLineParserOptions>
 static NClap.CommandLineParserOptionsExtensions.TryParse<T>(this NClap.CommandLineParserOptions options, System.Collections.Generic.IEnumerable<string> arguments, out T result) -> bool
 static NClap.CommandLineParserOptionsExtensions.With(this NClap.CommandLineParserOptions options) -> NClap.Utilities.FluentBuilder<NClap.CommandLineParserOptions>
-static NClap.CommandLineParser.GetCompletions(System.Type type, string commandLineToComplete, int charIndexOfCursor) -> System.Collections.Generic.IEnumerable<string>
-static NClap.CommandLineParser.GetCompletions(System.Type type, string commandLineToComplete, int charIndexOfCursor, int tokensToSkip, NClap.CommandLineParserOptions options) -> System.Collections.Generic.IEnumerable<string>
 static NClap.Help.ArgumentSetHelpOptionsExtensions.NoDescription(this NClap.Utilities.FluentBuilder<NClap.Help.ArgumentSetHelpOptions> builder) -> NClap.Utilities.FluentBuilder<NClap.Help.ArgumentSetHelpOptions>
 static NClap.Help.ArgumentSetHelpOptionsExtensions.NoEnumValues(this NClap.Utilities.FluentBuilder<NClap.Help.ArgumentSetHelpOptions> builder) -> NClap.Utilities.FluentBuilder<NClap.Help.ArgumentSetHelpOptions>
 static NClap.Help.ArgumentSetHelpOptionsExtensions.NoExamples(this NClap.Utilities.FluentBuilder<NClap.Help.ArgumentSetHelpOptions> builder) -> NClap.Utilities.FluentBuilder<NClap.Help.ArgumentSetHelpOptions>
diff --git a/src/NClap/Types/CommandGroupArgumentType.cs b/src/NClap/Types/CommandGroupArgumentType.cs
@@ -95,7 +95,7 @@ protected override object Parse(ArgumentParseContext context, string stringToPar
                 ServiceConfigurer = context.ServiceConfigurer
             };
 
-            var constructorArgTypes = new[] { typeof(CommandGroupOptions), _commandTypeType, typeof(object) };
+            var constructorArgTypes = new[] { typeof(CommandGroupOptions), typeof(object), typeof(object) };
             var commandGroupConstructor = Type.GetTypeInfo().GetConstructor(constructorArgTypes);
 
             if (commandGroupConstructor == null)
diff --git a/src/NClap/Types/EnumArgumentType.cs b/src/NClap/Types/EnumArgumentType.cs
@@ -3,6 +3,7 @@
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
+using NClap.Metadata;
 using NClap.Utilities;
 
 namespace NClap.Types
@@ -12,15 +13,15 @@ namespace NClap.Types
     /// </summary>
     internal class EnumArgumentType : ArgumentTypeBase, IEnumArgumentType
     {
-        private readonly Dictionary<string, EnumArgumentValue> _valuesByCaseSensitiveName =
-            new Dictionary<string, EnumArgumentValue>(StringComparer.Ordinal);
+        private readonly Dictionary<string, IArgumentValue> _valuesByCaseSensitiveName =
+            new Dictionary<string, IArgumentValue>(StringComparer.Ordinal);
 
-        private readonly Dictionary<string, EnumArgumentValue> _valuesByCaseInsensitiveName =
-            new Dictionary<string, EnumArgumentValue>(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<string, IArgumentValue> _valuesByCaseInsensitiveName =
+            new Dictionary<string, IArgumentValue>(StringComparer.OrdinalIgnoreCase);
 
-        private readonly Dictionary<object, EnumArgumentValue> _valuesByValue = new Dictionary<object, EnumArgumentValue>();
+        private readonly Dictionary<object, IArgumentValue> _valuesByValue = new Dictionary<object, IArgumentValue>();
 
-        private readonly List<EnumArgumentValue> _values = new List<EnumArgumentValue>();
+        private readonly List<IArgumentValue> _values = new List<IArgumentValue>();
 
         /// <summary>
         /// Constructs an object to describe an empty enumeration type.  Values must be
@@ -49,7 +50,20 @@ protected EnumArgumentType(Type type) : base(type)
         public static EnumArgumentType Create(Type type)
         {
             var flagsAttrib = type.GetTypeInfo().GetSingleAttribute<FlagsAttribute>();
-            return (flagsAttrib != null) ? new FlagsEnumArgumentType(type) : new EnumArgumentType(type);
+            var argType = (flagsAttrib != null) ? new FlagsEnumArgumentType(type) : new EnumArgumentType(type);
+
+            var extensibleAttribs = type.GetTypeInfo().GetAttributes<ExtensibleEnumAttribute>().ToList();
+            if (extensibleAttribs.Count > 0)
+            {
+                var types = extensibleAttribs.Select(a => a.Provider)
+                    .Where(p => p != null)
+                    .Select(ConstructEnumArgumentTypeProviderFromType)
+                    .SelectMany(p => p.GetTypes());
+
+                argType = new MergedEnumArgumentType(new[] { argType }.Concat(types));
+            }
+
+            return argType;
         }
 
         /// <summary>
@@ -64,7 +78,7 @@ public override string Format(object value)
         {
             if (value == null) throw new ArgumentNullException(nameof(value));
 
-            if (_valuesByValue.TryGetValue(value, out EnumArgumentValue enumValue))
+            if (_valuesByValue.TryGetValue(value, out IArgumentValue enumValue))
             {
                 return enumValue.DisplayName;
             }
@@ -102,7 +116,7 @@ protected override object Parse(ArgumentParseContext context, string stringToPar
             var map = context.CaseSensitive ? _valuesByCaseSensitiveName : _valuesByCaseInsensitiveName;
 
             // First try looking up the string in our name map.
-            if (!map.TryGetValue(stringToParse, out EnumArgumentValue value))
+            if (!map.TryGetValue(stringToParse, out IArgumentValue value))
             {
                 // We might have more options if it's an enum type, but if it's not--there's
                 // nothing else we can do.
@@ -145,7 +159,7 @@ protected override object Parse(ArgumentParseContext context, string stringToPar
         /// <returns>true on success; false otherwise.</returns>
         public bool TryGetValue(object value, out IArgumentValue argValue)
         {
-            if (!_valuesByValue.TryGetValue(value, out EnumArgumentValue enumArgValue))
+            if (!_valuesByValue.TryGetValue(value, out IArgumentValue enumArgValue))
             {
                 argValue = null;
                 return false;
@@ -159,7 +173,7 @@ public bool TryGetValue(object value, out IArgumentValue argValue)
         /// Defines a new value in this type.
         /// </summary>
         /// <param name="value">Value to define.</param>
-        protected void AddValue(EnumArgumentValue value)
+        protected void AddValue(IArgumentValue value)
         {
             _values.Add(value);
             AddToValueNameMap(_valuesByCaseSensitiveName, value);
@@ -184,10 +198,22 @@ protected void AddValuesFromType(Type type)
             }
         }
 
-        private static IEnumerable<EnumArgumentValue> GetAllValues(Type type) =>
+        /// <summary>
+        /// Defines all values in the given type.
+        /// </summary>
+        /// <param name="type">Type to inspect.</param>
+        protected void AddValuesFromType(IEnumArgumentType type)
+        {
+            foreach (var value in type.GetValues())
+            {
+                AddValue(value);
+            }
+        }
+
+        private static IEnumerable<IArgumentValue> GetAllValues(Type type) =>
             type.GetTypeInfo().GetFields(BindingFlags.Public | BindingFlags.Static).Select(f => new EnumArgumentValue(f));
 
-        private static void AddToValueMap(Dictionary<object, EnumArgumentValue> map, EnumArgumentValue value)
+        private static void AddToValueMap(Dictionary<object, IArgumentValue> map, IArgumentValue value)
         {
             // We do our best to add each value to the map; but if there
             // are multiple members that share a value, then the first
@@ -204,7 +230,7 @@ private static void AddToValueMap(Dictionary<object, EnumArgumentValue> map, Enu
         /// </summary>
         /// <param name="map">Map to add to.</param>
         /// <param name="value">The value to add.</param>
-        private static void AddToValueNameMap(Dictionary<string, EnumArgumentValue> map, EnumArgumentValue value)
+        private static void AddToValueNameMap(Dictionary<string, IArgumentValue> map, IArgumentValue value)
         {
             // We skip disallowed values.
             if (value.Disallowed) return;
@@ -229,5 +255,10 @@ private static void AddToValueNameMap(Dictionary<string, EnumArgumentValue> map,
                 map[value.ShortName] = value;
             }
         }
+
+        private static IEnumArgumentTypeProvider ConstructEnumArgumentTypeProviderFromType(Type type)
+        {
+            return (IEnumArgumentTypeProvider)type.GetParameterlessConstructor().Invoke(Array.Empty<object>());
+        }
     }
 }
diff --git a/src/NClap/Types/IEnumArgumentTypeProvider.cs b/src/NClap/Types/IEnumArgumentTypeProvider.cs
@@ -0,0 +1,16 @@
+﻿using System.Collections.Generic;
+
+namespace NClap.Types
+{
+    /// <summary>
+    /// Enum argument type provider.
+    /// </summary>
+    public interface IEnumArgumentTypeProvider
+    {
+        /// <summary>
+        /// Retrieves types being provided.
+        /// </summary>
+        /// <returns>Enumeration of types.</returns>
+        IEnumerable<IEnumArgumentType> GetTypes();
+    }
+}
diff --git a/src/NClap/Types/MergedEnumArgumentType.cs b/src/NClap/Types/MergedEnumArgumentType.cs
@@ -29,5 +29,27 @@ public MergedEnumArgumentType(IEnumerable<Type> types)
                 throw new ArgumentOutOfRangeException(nameof(types));
             }
         }
+
+        /// <summary>
+        /// Constructs a type that merges the given enum types.
+        /// </summary>
+        /// <param name="types">Types to merge.</param>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when zero types are
+        /// provided.</exception>
+        public MergedEnumArgumentType(IEnumerable<IEnumArgumentType> types)
+        {
+            var typeCount = 0;
+            foreach (var type in types)
+            {
+                AddValuesFromType(type);
+                ++typeCount;
+            }
+
+            // We throw if 0 types are merged.
+            if (typeCount == 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(types));
+            }
+        }
     }
 }
diff --git a/src/Samples/MergedCommandApp/CommandType.cs b/src/Samples/MergedCommandApp/CommandType.cs
@@ -0,0 +1,11 @@
+﻿using NClap.Metadata;
+
+namespace MergedCommandApp
+{
+    [ExtensibleEnum(typeof(EnumProvider))]
+    internal enum CommandType
+    {
+        [Command(typeof(SimpleCommand), Description = "Keep it simple")]
+        Foo
+    }
+}
diff --git a/src/Samples/MergedCommandApp/EnumProvider.cs b/src/Samples/MergedCommandApp/EnumProvider.cs
@@ -0,0 +1,13 @@
+﻿using System.Collections.Generic;
+using NClap.Types;
+
+namespace MergedCommandApp
+{
+    internal class EnumProvider : IEnumArgumentTypeProvider
+    {
+        public IEnumerable<IEnumArgumentType> GetTypes()
+        {
+            return new[] { (IEnumArgumentType)ArgumentType.GetType(typeof(ExtraCommandsType)) };
+        }
+    }
+}
diff --git a/src/Samples/MergedCommandApp/ExtraCommand.cs b/src/Samples/MergedCommandApp/ExtraCommand.cs
@@ -0,0 +1,14 @@
+﻿using System;
+using NClap.Metadata;
+
+namespace MergedCommandApp
+{
+    internal class ExtraCommand : SynchronousCommand
+    {
+        public override CommandResult Execute()
+        {
+            Console.WriteLine("Extra!");
+            return CommandResult.Success;
+        }
+    }
+}
diff --git a/src/Samples/MergedCommandApp/ExtraCommandsType.cs b/src/Samples/MergedCommandApp/ExtraCommandsType.cs
@@ -0,0 +1,10 @@
+﻿using NClap.Metadata;
+
+namespace MergedCommandApp
+{
+    internal enum ExtraCommandsType
+    {
+        [Command(typeof(ExtraCommand), Description = "Do something a bit extra")]
+        Extra
+    }
+}
diff --git a/src/Samples/MergedCommandApp/Program.cs b/src/Samples/MergedCommandApp/Program.cs
@@ -1,12 +1,19 @@
 ﻿using System;
+using NClap;
 
 namespace MergedCommandApp
 {
     class Program
     {
-        static void Main(string[] args)
+        static int Main(string[] args)
         {
-            Console.WriteLine("Hello World!");
+            if (!CommandLineParser.TryParse(args, out ProgramArguments progArgs))
+            {
+                return 1;
+            }
+
+            var result = progArgs.Command.Execute();
+            return result == NClap.Metadata.CommandResult.Success ? 0 : 1;
         }
     }
 }
diff --git a/src/Samples/MergedCommandApp/ProgramArguments.cs b/src/Samples/MergedCommandApp/ProgramArguments.cs
diff --git a/src/Samples/MergedCommandApp/SimpleCommand.cs b/src/Samples/MergedCommandApp/SimpleCommand.cs
diff --git a/src/Samples/MultilevelCommandApp/SetConfigurationCommand.cs b/src/Samples/MultilevelCommandApp/SetConfigurationCommand.cs
diff --git a/src/Samples/MultilevelCommandApp/StatusCommand.cs b/src/Samples/MultilevelCommandApp/StatusCommand.cs
