Split key on postfix value if needed (#43)

Matthiee · web-flow · commit 52e2c3853293 · 2019-05-31T14:47:55.000+02:00
* Split key on postfix value if needed

* Allow arguments to be split on postfix

* Fix codefactor
diff --git a/CommandLineParser.Tests/CommandLineParserTests.cs b/CommandLineParser.Tests/CommandLineParserTests.cs
@@ -29,6 +29,24 @@ public override void OnConfigure(ICommandConfigurationBuilder<object> builder)
             }
         }
 
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        public void CommandLineParserParsesCorrectOptionsWithPostfix(bool useShort)
+        {
+            var query = $"{(useShort ? "-" : "--")}p=some text";
+
+            var parser = new CommandLineParser<AddOption>();
+
+            parser.Configure(p => p.Message).Name("p", "p").Required();
+
+            var result = parser.Parse(new string[] { query });
+
+            result.AssertNoErrors();
+
+            Assert.Equal("some text", result.Result.Message);
+        }
+
         [Fact]
         public void CommandLineParserUsesCorrectOptions()
         {
@@ -174,7 +192,7 @@ public void ParseTests()
 
         [Theory]
         [InlineData(new[] { "app.exe", "-e", "Opt1" }, false, EnumOption.Opt1)]
-        [InlineData(new[] { "app.exe", "-e", "opt1" }, false, EnumOption.Opt1)]
+        [InlineData(new[] { "app.exe", "-e=opt1" }, false, EnumOption.Opt1)]
         [InlineData(new[] { "app.exe", "-e", "Opt2" }, false, EnumOption.Opt2)]
         [InlineData(new[] { "app.exe", "-e", "bla" }, true, default(EnumOption))]
         [InlineData(new[] { "app.exe", "-e" }, true, default(EnumOption))]
@@ -195,11 +213,11 @@ public void ParseEnumInArguments(string[] args, bool hasErrors, EnumOption enumO
 
         [Theory]
         // string
-        [InlineData(typeof(string), new[] { "-1", "message1", "-2", "-3" }, "default", "message1", "default", "default")]
+        [InlineData(typeof(string), new[] { "-1=message1", "-2", "-3" }, "default", "message1", "default", "default")]
         [InlineData(typeof(string), new[] { "-1", "-2", "message2", "-3" }, "default", "default", "message2", "default")]
         [InlineData(typeof(string), new[] { "-1", "-2", "-3" }, "default", "default", "default", "default")]
         // bool
-        [InlineData(typeof(bool), new[] { "-1", "false", "-2", "-3" }, false, false, true, true)]
+        [InlineData(typeof(bool), new[] { "-1=false", "-2", "-3" }, false, false, true, true)]
         [InlineData(typeof(bool), new[] { "-1", "-2", "false", "-3" }, false, true, false, true)]
         [InlineData(typeof(bool), new[] { "-1", "-2", "-3" }, false, true, true, true)]
         //// int
@@ -316,7 +334,7 @@ public void ParseWithCommandTests()
                 .Name("m", "message")
                 .Required();
 
-            var parsed = parser.Parse(new string[] { "app.exe", "-o", "test", "add", "-m", "my message" });
+            var parsed = parser.Parse(new string[] { "app.exe", "-o", "test", "add", "-m=my message" });
 
             parsed.AssertNoErrors();
 
diff --git a/CommandLineParser.Tests/Utils/ExtensionMethodsTest.cs b/CommandLineParser.Tests/Utils/ExtensionMethodsTest.cs
@@ -0,0 +1,78 @@
+﻿using Xunit;
+using MatthiWare.CommandLine.Core.Utils;
+using System.Linq;
+using Moq;
+using MatthiWare.CommandLine.Abstractions;
+
+namespace MatthiWare.CommandLine.Tests.Utils
+{
+    public class ExtensionMethodsTest
+    {
+        [Fact]
+        public void TestSplitOnPostFixWorksCorrectly()
+        {
+            var settings = new CommandLineParserOptions();
+
+            var mockTestOption1 = CreateMock(settings, "test").Object;
+            var mockTestOption2 = CreateMock(settings, "test2", "test2").Object;
+            var mockTestOption3 = CreateMock(settings, "test3").Object;
+            var mockTestOption4 = CreateMock(settings, "blabla", "blabla").Object;
+
+            var options = new[] 
+            {
+                mockTestOption1,
+                mockTestOption2,
+                mockTestOption3,
+                mockTestOption4
+            };
+
+            var input = new[] { "--test=1", "-test2=\"some value\"", "--test3=some value", "-blabla", "third" };
+            var output = input.SplitOnPostfix(settings, options).ToArray();
+
+            Assert.Equal("--test", output[0]);
+            Assert.Equal("1", output[1]);
+            Assert.Equal("-test2", output[2]);
+            Assert.Equal("\"some value\"", output[3]);
+            Assert.Equal("--test3", output[4]);
+            Assert.Equal("some value", output[5]);
+            Assert.Equal("-blabla", output[6]);
+            Assert.Equal("third", output[7]);
+        }
+
+        [Fact]
+        public void TestSplitOnPostFixWorksCorrectly_2()
+        {
+            var settings = new CommandLineParserOptions();
+
+            var testOption = CreateMock(settings, "test").Object;
+
+            var options = new[]
+            {
+                testOption,
+            };
+
+            var input = new[] { "--test", "some=value" };
+
+            var output = input.SplitOnPostfix(settings, options).ToArray();
+
+            Assert.Equal("--test", output[0]);
+            Assert.Equal("some=value", output[1]);
+        }
+
+        private Mock<ICommandLineOption> CreateMock(CommandLineParserOptions settings, string longName, string shortName = "")
+        {
+            var mock = new Mock<ICommandLineOption>();
+
+            mock.SetupGet(option => option.LongName).Returns($"{settings.PrefixLongOption}{longName}");
+            mock.SetupGet(option => option.HasLongName).Returns(true);
+
+            if (!string.IsNullOrWhiteSpace(shortName))
+            {
+                mock.SetupGet(option => option.ShortName).Returns($"{settings.PrefixShortOption}{shortName}");
+                mock.SetupGet(option => option.HasShortName).Returns(true);
+            }
+
+            return mock;
+        }
+    }
+}
diff --git a/CommandLineParser/Abstractions/Command/Command.cs b/CommandLineParser/Abstractions/Command/Command.cs
@@ -3,7 +3,6 @@
     /// <summary>
     /// Defines a command
     /// </summary>
-    /// <typeparam name="TOptions">Base options of the command</typeparam>
     public abstract class Command
     {
         /// <summary>
diff --git a/CommandLineParser/Abstractions/Command/ICommandBuilder'.cs b/CommandLineParser/Abstractions/Command/ICommandBuilder'.cs
@@ -7,6 +7,7 @@ namespace MatthiWare.CommandLine.Abstractions.Command
     /// Configures commands using a fluent interface
     /// </summary>
     /// <typeparam name="TSource">Command options class</typeparam>
+    /// <typeparam name="TOption">Base option</typeparam>
     public interface ICommandBuilder<TOption, TSource> : ICommandConfigurationBuilder, ICommandExecutor<TOption, TSource>
         where TOption : class
         where TSource : class, new()
diff --git a/CommandLineParser/Abstractions/Command/ICommandBuilder.cs b/CommandLineParser/Abstractions/Command/ICommandBuilder.cs
@@ -26,7 +26,7 @@ public interface ICommandBuilder<TOption>
         /// <summary>
         /// Describes the command, used in the usage output. 
         /// </summary>
-        /// <param name="desc">description of the command</param>
+        /// <param name="description">description of the command</param>
         /// <returns><see cref="ICommandBuilder{TOption}"/></returns>
         ICommandBuilder<TOption> Description(string description);
 
diff --git a/CommandLineParser/Abstractions/Command/ICommandConfigurationBuilder.cs b/CommandLineParser/Abstractions/Command/ICommandConfigurationBuilder.cs
@@ -15,7 +15,7 @@ public interface ICommandConfigurationBuilder
         /// <summary>
         /// Configures the description text for the command
         /// </summary>
-        /// <param name="required">True or false</param>
+        /// <param name="description">Description</param>
         /// <returns><see cref="ICommandConfigurationBuilder"/></returns>
         ICommandConfigurationBuilder Description(string description);
 
diff --git a/CommandLineParser/Abstractions/Command/ICommandLineCommand.cs b/CommandLineParser/Abstractions/Command/ICommandLineCommand.cs
@@ -5,9 +5,24 @@
     /// </summary>
     public interface ICommandLineCommand : IArgument
     {
+        /// <summary>
+        /// Name of the command
+        /// </summary>
         string Name { get; }
+
+        /// <summary>
+        /// Indicates if the command is required or not
+        /// </summary>
         bool IsRequired { get; }
+
+        /// <summary>
+        /// Description of the command
+        /// </summary>
         string Description { get; }
+
+        /// <summary>
+        /// Auto executes the command if set to true
+        /// </summary>
         bool AutoExecute { get; }
     }
 }
diff --git a/CommandLineParser/Abstractions/ICommandLineOption.cs b/CommandLineParser/Abstractions/ICommandLineOption.cs
@@ -5,12 +5,39 @@
     /// </summary>
     public interface ICommandLineOption : IArgument
     {
+        /// <summary>
+        /// Short name of the option
+        /// </summary>
         string ShortName { get; }
+
+        /// <summary>
+        /// Long name of the option
+        /// </summary>
         string LongName { get; }
+
+        /// <summary>
+        /// Description of the option
+        /// </summary>
         string Description { get; }
+
+        /// <summary>
+        /// Indicates if the option is required
+        /// </summary>
         bool IsRequired { get; }
+
+        /// <summary>
+        /// Indicates if a short option name has been specified
+        /// </summary>
         bool HasShortName { get; }
+
+        /// <summary>
+        /// Indicates if a long option name has been specified
+        /// </summary>
         bool HasLongName { get; }
+
+        /// <summary>
+        /// Inidicates if a default value has been specified for this option
+        /// </summary>
         bool HasDefault { get; }
     }
 }
diff --git a/CommandLineParser/CommandLineParser.xml b/CommandLineParser/CommandLineParser.xml
diff --git a/CommandLineParser/CommandLineParserOptions.cs b/CommandLineParser/CommandLineParserOptions.cs
@@ -14,6 +14,11 @@ public class CommandLineParserOptions
         /// </summary>
         public string PrefixLongOption { get; set; } = "--";
 
+        /// <summary>
+        /// Postfix for the long option
+        /// </summary>
+        public string PostfixOption { get; set; } = "=";
+
         /// <summary>
         /// Help option name. 
         /// Accepts both formatted and unformatted help name. 
diff --git a/CommandLineParser/CommandLineParser`TOption.cs b/CommandLineParser/CommandLineParser`TOption.cs
@@ -196,7 +196,7 @@ public IParserResult<TOption> Parse(string[] args)
 
             var result = new ParseResult<TOption>();
 
-            var argumentManager = new ArgumentManager(args, ParserOptions.EnableHelpOption, m_helpOptionName, m_helpOptionNameLong, m_commands, m_options.Values);
+            var argumentManager = new ArgumentManager(args, ParserOptions, m_helpOptionName, m_helpOptionNameLong, m_commands, m_options.Values.Cast<ICommandLineOption>().ToArray());
 
             ParseCommands(errors, result, argumentManager);
 
diff --git a/CommandLineParser/Core/Parsing/ArgumentManager.cs b/CommandLineParser/Core/Parsing/ArgumentManager.cs
@@ -8,6 +8,7 @@
 using MatthiWare.CommandLine.Abstractions.Models;
 using MatthiWare.CommandLine.Abstractions.Parsing;
 using MatthiWare.CommandLine.Core.Command;
+using MatthiWare.CommandLine.Core.Utils;
 
 namespace MatthiWare.CommandLine.Core.Parsing
 {
@@ -18,22 +19,27 @@ internal class ArgumentManager : IArgumentManager, IDisposable
         private readonly bool helpOptionsEnabled;
         private readonly string shortHelpOption;
         private readonly string longHelpOption;
+        private readonly CommandLineParserOptions parserOptions;
+        private readonly bool hasPostfixDefined;
 
         public IQueryable<ArgumentValueHolder> UnusedArguments => args.AsQueryable().Where(a => !a.Used);
 
-        public ArgumentManager(string[] args, bool helpOptionsEnabled, string shortHelpOption, string longHelpOption, ICollection<CommandLineCommandBase> commands, ICollection<CommandLineOptionBase> options)
+        public ArgumentManager(string[] args, CommandLineParserOptions parserOptions, string shortHelpOption, string longHelpOption, ICollection<CommandLineCommandBase> commands, ICollection<ICommandLineOption> options)
         {
             resultCache = new Dictionary<IArgument, ArgumentModel>(commands.Count + options.Count);
 
-            this.helpOptionsEnabled = helpOptionsEnabled;
+            this.parserOptions = parserOptions;
+            this.helpOptionsEnabled = parserOptions.EnableHelpOption;
             this.shortHelpOption = shortHelpOption;
             this.longHelpOption = longHelpOption;
+            this.hasPostfixDefined = !string.IsNullOrWhiteSpace(parserOptions.PostfixOption);
 
-            this.args = new List<ArgumentValueHolder>(args.Select(arg => new ArgumentValueHolder
-            {
-                Argument = arg,
-                Used = false
-            }));
+            this.args = new List<ArgumentValueHolder>(
+                args.SplitOnPostfix(parserOptions, GetCommandLineOptions(options, commands))
+                .Select(arg => new ArgumentValueHolder
+                {
+                    Argument = arg
+                }));
 
             ParseCommands(commands);
 
@@ -63,6 +69,25 @@ public ArgumentManager(string[] args, bool helpOptionsEnabled, string shortHelpO
             }
         }
 
+        private ICollection<ICommandLineOption> GetCommandLineOptions(ICollection<ICommandLineOption> options, IEnumerable<CommandLineCommandBase> commands)
+        {
+            List<ICommandLineOption> result = new List<ICommandLineOption>(options);
+
+            Traverse(commands);
+
+            return result;
+
+            void Traverse(IEnumerable<CommandLineCommandBase> cmds)
+            {
+                foreach (var cmd in cmds)
+                {
+                    result.AddRange(cmd.Options);
+
+                    Traverse(cmd.Commands.Cast<CommandLineCommandBase>());
+                }
+            }
+        }
+
         private void CheckHelpCommands()
         {
             if (!helpOptionsEnabled) return;
@@ -140,7 +165,7 @@ private int FindIndex(object model, int startOffset = 0)
                             return string.Equals(key, arg.Argument, StringComparison.InvariantCultureIgnoreCase);
                         case ICommandLineOption opt:
                             return (opt.HasShortName && string.Equals(opt.ShortName, arg.Argument, StringComparison.InvariantCultureIgnoreCase)) ||
-                                    (opt.HasLongName && string.Equals(opt.LongName, arg.Argument, StringComparison.InvariantCultureIgnoreCase));
+                                (opt.HasLongName && string.Equals(opt.LongName, arg.Argument, StringComparison.InvariantCultureIgnoreCase));
                         case ICommandLineCommand cmd:
                             return string.Equals(cmd.Name, arg.Argument, StringComparison.InvariantCultureIgnoreCase);
                         default:
@@ -157,7 +182,7 @@ private int FindIndex(object model, int startOffset = 0)
         public class ArgumentValueHolder
         {
             public string Argument { get; set; }
-            public bool Used { get; set; }
+            public bool Used { get; set; } = false;
             public IArgument ArgModel { get; set; }
             public int Index { get; set; }
         }
diff --git a/CommandLineParser/Core/Utils/ExtensionMethods.cs b/CommandLineParser/Core/Utils/ExtensionMethods.cs

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`	`/// <summary>`
`4`	`4`	`/// Defines a command`
`5`	`5`	`/// </summary>`
`6`		`- /// <typeparam name="TOptions">Base options of the command</typeparam>`
`7`	`6`	`public abstract class Command`
`8`	`7`	`{`
`9`	`8`	`/// <summary>`