Implement option grouping/clustering fixes #45

Author: Matthiee

CommandLineParser.Tests/CommandLineParserTests.cs

@@ -46,6 +46,22 @@ public void OrderAttributeWorks()
             Assert.Equal(to, result.Result.To);
         }
 
+        [Fact]
+        public void OrderAttributeWorks2()
+        {
+            var from = @"path/from/file";
+            var to = @"path/to/file";
+
+            var parser = new CommandLineParser<OrderModel>(Services);
+
+            var result = parser.Parse(new string[] { "app.exe", "-r", "5", from, to });
+
+            result.AssertNoErrors();
+
+            Assert.Equal(from, result.Result.From);
+            Assert.Equal(to, result.Result.To);
+        }
+
         [Fact]
         public void OrderAttributeInCommandWorks()
         {

CommandLineParser.Tests/Parsing/OptionClusteringTests.cs

@@ -0,0 +1,135 @@
+using MatthiWare.CommandLine.Core.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace MatthiWare.CommandLine.Tests.Parsing
+{
+    public class OptionClusteringTests : TestBase
+    {
+        public OptionClusteringTests(ITestOutputHelper testOutputHelper) : base(testOutputHelper)
+        {
+        }
+
+        [Fact]
+        public void ClusterdOptionsAreParsedCorrectly()
+        {
+            var parser = new CommandLineParser<ClusteredOptions<bool>>(Services);
+
+            var result = parser.Parse(new[] { "app.exe", "-abc" });
+
+            result.AssertNoErrors();
+
+            var model = result.Result;
+
+            Assert.True(model.A);
+            Assert.True(model.B);
+            Assert.True(model.C);
+        }
+
+        [Fact]
+        public void ClusterdOptionsAllSetTheSameValue()
+        {
+            var parser = new CommandLineParser<ClusteredOptions<bool>>(Services);
+
+            var result = parser.Parse(new[] { "app.exe", "-abc", "false" });
+
+            result.AssertNoErrors();
+
+            var model = result.Result;
+
+            Assert.False(model.A);
+            Assert.False(model.B);
+            Assert.False(model.C);
+        }
+
+        [Fact]
+        public void ClusterdOptionsAreIgnoredWhenRepeated()
+        {
+            var parser = new CommandLineParser<ClusteredOptions<bool>>(Services);
+
+            var result = parser.Parse(new[] { "app.exe", "-abc", "false", "-abc", "true" });
+
+            result.AssertNoErrors();
+
+            var model = result.Result;
+
+            Assert.False(model.A);
+            Assert.False(model.B);
+            Assert.False(model.C);
+        }
+
+        [Fact]
+        public void ClusterdOptionsInCommandWork()
+        {
+            var parser = new CommandLineParser(Services);
+
+            parser.AddCommand<ClusteredOptions<bool>>().Name("cmd").Required().OnExecuting((o, model) =>
+            {
+                Assert.False(model.A);
+                Assert.False(model.B);
+                Assert.False(model.C);
+            });
+
+            var result = parser.Parse(new[] { "app.exe", "cmd", "-abc", "false" });
+
+            result.AssertNoErrors();
+        }
+
+        [Fact]
+        public void ClusterdOptionsInCommandAndReusedInParentWork()
+        {
+            var parser = new CommandLineParser<ClusteredOptions<bool>>(Services);
+
+            parser.AddCommand<ClusteredOptions<bool>>().Name("cmd").Required().OnExecuting((o, model) =>
+            {
+                Assert.False(model.A);
+                Assert.False(model.B);
+                Assert.False(model.C);
+            });
+
+            var result = parser.Parse(new[] { "app.exe", "-abc", "cmd", "-abc", "false" });
+
+            result.AssertNoErrors();
+
+            Assert.True(result.Result.A);
+            Assert.True(result.Result.B);
+            Assert.True(result.Result.C);
+        }
+
+        [Fact]
+        public void ClusterdOptionsInCommandAndReusedInParentWork_String_Version()
+        {
+            var parser = new CommandLineParser<ClusteredOptions<string>>(Services);
+
+            parser.AddCommand<ClusteredOptions<string>>().Name("cmd").Required().OnExecuting((o, model) =>
+            {
+                Assert.Equal("false", model.A);
+                Assert.Equal("false", model.B);
+                Assert.Equal("false", model.C);
+            });
+
+            var result = parser.Parse(new[] { "app.exe", "-abc", "works", "cmd", "-abc", "false" });
+
+            result.AssertNoErrors();
+
+            Assert.Equal("works", result.Result.A);
+            Assert.Equal("works", result.Result.B);
+            Assert.Equal("works", result.Result.C);
+        }
+
+        private class ClusteredOptions<T>
+        {
+            [Name("a"), Required]
+            public T A { get; set; }
+
+            [Name("b"), Required]
+            public T B { get; set; }
+
+            [Name("c"), Required]
+            public T C { get; set; }
+        }
+    }
+}

CommandLineParser.Tests/Utils/ExtensionMethodsTest.cs

@@ -97,20 +97,16 @@ private bool ProcessOption(OptionRecord rec)
         {
             var foundOption = FindOption(rec);
 
-            if (foundOption == null)
+            if (!foundOption)
             {
                 // In case we have an option named "-1" and int value -1. This causes confusion. 
                 return ProcessCommandOrOptionValue(rec);
             }
 
-            var argumentModel = new ArgumentModel(rec.Name, rec.Value);
-
-            results.Add(foundOption, argumentModel);
-
             return true;
         }
 
-        private ICommandLineOption FindOption(OptionRecord rec)
+        private bool FindOption(OptionRecord rec)
         {
             var context = CurrentContext;
 
@@ -132,13 +128,77 @@ private ICommandLineOption FindOption(OptionRecord rec)
 
                     context.CurrentOption = option;
 
-                    return option;
+                    var argumentModel = new ArgumentModel(rec.Name, rec.Value);
+
+                    results.Add(option, argumentModel);
+
+                    return true;
+                }
+
+                if (ProcessClusteredOptions(context, rec))
+                {
+                    return true;
                 }
 
                 context = context.Parent;
             }
 
-            return null;
+            return false;
+        }
+
+        private bool ProcessClusteredOptions(ProcessingContext context, OptionRecord rec)
+        {
+            var tokens = rec.Name.WithoutPreAndPostfixes(options);
+
+            var list = new List<ICommandLineOption>();
+
+            foreach (var token in tokens)
+            {
+                bool found = false;
+
+                string key = $"{options.PrefixShortOption}{token}";
+
+                foreach (var option in context.CurrentCommand.Options.Where(ValidClusteredOption))
+                {
+                    if (!option.ShortName.EqualsIgnoreCase(key))
+                    {
+                        continue;
+                    }
+
+                    var model = new ArgumentModel(key, string.Empty);
+
+                    list.Add(option);
+                    results.Add(option, model);
+
+                    found = true;
+                    break;
+                }
+
+                if (!found)
+                {
+                    return false;
+                }
+            }
+
+            context.NextArgumentIsForClusteredOptions = true;
+            context.ProcessedClusteredOptions = list;
+
+            return true;
+        }
+
+        private bool ValidClusteredOption(ICommandLineOption option)
+        {
+            if (!option.HasShortName)
+            {
+                return false;
+            }
+
+            if (results.ContainsKey(option))
+            {
+                return false;
+            }
+
+            return true;
         }
 
         private bool ProcessCommandOrOptionValue(ArgumentRecord rec)
@@ -161,6 +221,17 @@ private bool ProcessCommandOrOptionValue(ArgumentRecord rec)
 
             while (context != null)
             {
+                if (context.NextArgumentIsForClusteredOptions)
+                {
+                    foreach (var option in context.ProcessedClusteredOptions)
+                    {
+                        results[option].Value = rec.RawData;
+                    }
+
+                    context.ProcessedClusteredOptions = null;
+                    context.NextArgumentIsForClusteredOptions = false;
+                }
+
                 if (context.CurrentOption == null)
                 {
                     context = context.Parent;
@@ -228,6 +299,8 @@ private class ProcessingContext
             public bool HasOrderedOptions { get; }
             public bool AllOrderedOptionsProcessed => orderedOptions.Count == 0;
             public bool ProcessingOrderedOptions { get; private set; }
+            public bool NextArgumentIsForClusteredOptions { get; set; }
+            public List<ICommandLineOption> ProcessedClusteredOptions { get; set; }
 
             public ProcessingContext(ProcessingContext parent, ICommandLineCommandContainer commandContainer, ILogger logger)
             {
@@ -257,6 +330,8 @@ public void AssertSafeToSwitchProcessingContext()
             {
                 if (!ProcessingOrderedOptions || AllOrderedOptionsProcessed)
                 {
+                    ProcessedClusteredOptions = null;
+                    NextArgumentIsForClusteredOptions = false;
                     return;
                 }