Split key on postfix value if needed (#43)

* Split key on postfix value if needed

* Allow arguments to be split on postfix

* Fix codefactor

Author: Matthiee

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();
 

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;
+        }
+    }
+}

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>

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()

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);
 

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);
 

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; }
     }
 }

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; }
     }
 }

CommandLineParser/CommandLineParser.xml

@@ -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.