Merge pull request #14 from jpdillingham/dev

Improved operand parsing, changed regular expression to allow for a wider variety of characters in argument names

Author: jpdillingham

Examples/Program.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Utility.CommandLine;
 
 namespace Examples
@@ -20,6 +21,9 @@ internal class Program
         [Argument('i', "integer")]
         private static int Int { get; set; }
 
+        [Argument('l', "list")]
+        private static List<int> List { get; set; }
+
         [Operands]
         private static string[] Operands { get; set; }
 
@@ -74,7 +78,7 @@ private static void Print(string commandLine)
             Console.WriteLine("\r\nArgument\tValue");
             Console.WriteLine("-------\t\t-------");
 
-            Dictionary<string, string> argumentDictionary = Arguments.Parse(commandLine).ArgumentDictionary;
+            Dictionary<string, object> argumentDictionary = Arguments.Parse(commandLine).ArgumentDictionary;
 
             foreach (string key in argumentDictionary.Keys)
             {
@@ -88,6 +92,7 @@ private static void Print(string commandLine)
             Console.WriteLine("Bool\t\t" + Bool);
             Console.WriteLine("Int\t\t" + Int);
             Console.WriteLine("Double\t\t" + Double);
+            Console.WriteLine("List\t\t" + String.Join(",", List.Select(o => o.ToString()).ToArray()));
 
             Console.WriteLine("\r\nOperands\n-------");
 

README.md

@@ -182,7 +182,7 @@ Operands
 ## Parsing
 
 Argument key-value pairs can be parsed from any string using the ```Parse(string)``` method.  This method returns a 
-```Dictionary<string, string>``` containing all argument-value pairs.
+```Dictionary<string, object>``` containing all argument-value pairs.
 
 If the string parameter is omitted, the value of ```Environment.CommandLine``` is used.
 
@@ -192,7 +192,7 @@ from property handling quoted strings.  There are generally very few instance in
 #### Example
 
 ```c#
-Dictionary<string, string> args = Arguments.Parse("-ab --foo bar");
+Dictionary<string, object> args = Arguments.Parse("-ab --foo bar");
 ```
 
 The example above would result in a dictionary ```args``` containing:

Utility.CommandLine.Arguments.Tests/Arguments.cs

@@ -162,7 +162,7 @@ public void Indexer()
         [Fact]
         public void Parse()
         {
-            Dictionary<string, string> test = CommandLine.Arguments.Parse().ArgumentDictionary;
+            Dictionary<string, object> test = CommandLine.Arguments.Parse().ArgumentDictionary;
 
             Assert.NotEmpty(test);
         }
@@ -174,7 +174,7 @@ public void Parse()
         [Fact]
         public void ParseCaseSensitive()
         {
-            Dictionary<string, string> test = CommandLine.Arguments.Parse("--TEST -aBc").ArgumentDictionary;
+            Dictionary<string, object> test = CommandLine.Arguments.Parse("--TEST -aBc").ArgumentDictionary;
 
             Assert.True(test.ContainsKey("TEST"));
             Assert.False(test.ContainsKey("test"));
@@ -219,7 +219,7 @@ public void ParseEmpty()
         [Fact]
         public void ParseInnerQuotedStrings()
         {
-            Dictionary<string, string> test = CommandLine.Arguments.Parse("--test1 \"test \'1\'\" --test2 \'test \"2\"\'").ArgumentDictionary;
+            Dictionary<string, object> test = CommandLine.Arguments.Parse("--test1 \"test \'1\'\" --test2 \'test \"2\"\'").ArgumentDictionary;
 
             Assert.Equal("test \'1\'", test["test1"]);
             Assert.Equal("test \"2\"", test["test2"]);
@@ -232,7 +232,7 @@ public void ParseInnerQuotedStrings()
         [Fact]
         public void ParseLongAndShortMix()
         {
-            Dictionary<string, string> test = CommandLine.Arguments.Parse("--one=1 -ab 2 /three:3 -4 4").ArgumentDictionary;
+            Dictionary<string, object> test = CommandLine.Arguments.Parse("--one=1 -ab 2 /three:3 -4 4").ArgumentDictionary;
 
             Assert.Equal("1", test["one"]);
             Assert.True(test.ContainsKey("a"));
@@ -262,7 +262,7 @@ public void ParseMixedArgumentsAndOperands()
         [Fact]
         public void ParseMultipleQuotes()
         {
-            Dictionary<string, string> test = CommandLine.Arguments.Parse("--test1 \"1\" --test2 \"2\" --test3 \'3\' --test4 \'4\'").ArgumentDictionary;
+            Dictionary<string, object> test = CommandLine.Arguments.Parse("--test1 \"1\" --test2 \"2\" --test3 \'3\' --test4 \'4\'").ArgumentDictionary;
 
             Assert.Equal("1", test["test1"]);
             Assert.Equal("2", test["test2"]);
@@ -328,7 +328,7 @@ public void ParseOperands()
         [Fact]
         public void ParseShorts()
         {
-            Dictionary<string, string> test = CommandLine.Arguments.Parse("-abc 'hello world'").ArgumentDictionary;
+            Dictionary<string, object> test = CommandLine.Arguments.Parse("-abc 'hello world'").ArgumentDictionary;
 
             Assert.True(test.ContainsKey("a"));
             Assert.Equal(string.Empty, test["a"]);
@@ -340,6 +340,34 @@ public void ParseShorts()
             Assert.Equal("hello world", test["c"]);
         }
 
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with a a string containing only the
+        ///     strict operand delimiter.
+        /// </summary>
+        [Fact]
+        public void ParseStrictOperandDelimiterOnly()
+        {
+            CommandLine.Arguments test = CommandLine.Arguments.Parse("--");
+
+            Assert.Equal(0, test.OperandList.Count);
+        }
+
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with a a string containing multiple
+        ///     strict operand delimiters.
+        /// </summary>
+        [Fact]
+        public void ParseStrictOperandMultipleDelimiter()
+        {
+            CommandLine.Arguments test = CommandLine.Arguments.Parse("one -- two -- three");
+
+            Assert.Equal(4, test.OperandList.Count);
+            Assert.Equal("one", test.OperandList[0]);
+            Assert.Equal("two", test.OperandList[1]);
+            Assert.Equal("--", test.OperandList[2]);
+            Assert.Equal("three", test.OperandList[3]);
+        }
+
         /// <summary>
         ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with an explicit operand delimiter.
         /// </summary>
@@ -365,20 +393,34 @@ public void ParseStrictOperands()
         [Fact]
         public void ParseStrictOperandsEmpty()
         {
-            CommandLine.Arguments test = CommandLine.Arguments.Parse("--test one two -- ");
+            CommandLine.Arguments test = CommandLine.Arguments.Parse("--test one two --");
 
             Assert.Equal(1, test.OperandList.Count);
             Assert.Equal("two", test.OperandList[0]);
         }
 
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with a a string beginning with the
+        ///     explicit operand delimiter.
+        /// </summary>
+        [Fact]
+        public void ParseStrictOperandsStart()
+        {
+            CommandLine.Arguments test = CommandLine.Arguments.Parse("-- one two");
+
+            Assert.Equal(2, test.OperandList.Count);
+            Assert.Equal("one", test.OperandList[0]);
+            Assert.Equal("two", test.OperandList[1]);
+        }
+
         /// <summary>
         ///     Tests the <see cref="Utility.CommandLine.Arguments.Parse(string)"/> method with an explicit command line string
         ///     containing only long parameters.
         /// </summary>
         [Fact]
         public void ParseStringOfLongs()
         {
-            Dictionary<string, string> test = CommandLine.Arguments.Parse("--one 1 --two=2 /three:3 --four \"4 4\" --five='5 5'").ArgumentDictionary;
+            Dictionary<string, object> test = CommandLine.Arguments.Parse("--one 1 --two=2 /three:3 --four \"4 4\" --five='5 5'").ArgumentDictionary;
 
             Assert.NotEmpty(test);
             Assert.Equal(5, test.Count);
@@ -396,7 +438,7 @@ public void ParseStringOfLongs()
         [Fact]
         public void ParseValueWithQuotedPeriod()
         {
-            Dictionary<string, string> test = CommandLine.Arguments.Parse("--test \"test.test\" --test2 'test2.test2'").ArgumentDictionary;
+            Dictionary<string, object> test = CommandLine.Arguments.Parse("--test \"test.test\" --test2 'test2.test2'").ArgumentDictionary;
 
             Assert.Equal("test.test", test["test"]);
             Assert.Equal("test2.test2", test["test2"]);
@@ -435,7 +477,7 @@ public void PopulateCaseSensitive()
         [Fact]
         public void PopulateDictionary()
         {
-            Dictionary<string, string> dict = new Dictionary<string, string>();
+            Dictionary<string, object> dict = new Dictionary<string, object>();
             dict.Add("i", "1");
 
             CommandLine.Arguments.Populate(dict);
@@ -642,6 +684,55 @@ public void PopulateOperands()
         #endregion Public Methods
     }
 
+    /// <summary>
+    ///     Unit tests for the <see cref="CommandLine.Arguments"/> class.
+    /// </summary>
+    /// <remarks>Used to facilitate testing of a class with an array property.</remarks>
+    [Collection("Arguments")]
+    public class TestClassWithArrayProperty
+    {
+        #region Private Properties
+
+        [CommandLine.Argument('a', "array")]
+        private static string[] Array { get; set; }
+
+        #endregion Private Properties
+
+        #region Public Methods
+
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Populate(Type, string)"/> method with an explicit string
+        ///     containing multiple instances of the same argument.
+        /// </summary>
+        [Fact]
+        public void Populate()
+        {
+            Exception ex = Record.Exception(() => CommandLine.Arguments.Populate(GetType(), "-a one -a two -a three"));
+
+            Assert.Null(ex);
+            Assert.Equal(3, Array.Length);
+            Assert.Equal("one", Array[0]);
+            Assert.Equal("two", Array[1]);
+            Assert.Equal("three", Array[2]);
+        }
+
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Populate(Type, string)"/> method with an explicit string
+        ///     containing a single a single instance of an array-backed argument.
+        /// </summary>
+        [Fact]
+        public void PopulateSingle()
+        {
+            Exception ex = Record.Exception(() => CommandLine.Arguments.Populate(GetType(), "-a one"));
+
+            Assert.Null(ex);
+            Assert.Equal(1, Array.Length);
+            Assert.Equal("one", Array[0]);
+        }
+
+        #endregion Public Methods
+    }
+
     /// <summary>
     ///     Unit tests for the <see cref="CommandLine.Arguments"/> class.
     /// </summary>
@@ -680,6 +771,55 @@ public void PopulateOperands()
         #endregion Public Methods
     }
 
+    /// <summary>
+    ///     Unit tests for the <see cref="CommandLine.Arguments"/> class.
+    /// </summary>
+    /// <remarks>Used to facilitate testing of a class with a List{T} property.</remarks>
+    [Collection("Arguments")]
+    public class TestClassWithListProperty
+    {
+        #region Private Properties
+
+        [CommandLine.Argument('l', "list")]
+        private static List<string> List { get; set; }
+
+        #endregion Private Properties
+
+        #region Public Methods
+
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Populate(Type, string)"/> method with an explicit string
+        ///     containing multiple instances of a list-backed argument.
+        /// </summary>
+        [Fact]
+        public void Populate()
+        {
+            Exception ex = Record.Exception(() => CommandLine.Arguments.Populate(GetType(), "-l one -l two -l three"));
+
+            Assert.Null(ex);
+            Assert.Equal(3, List.Count);
+            Assert.Equal("one", List[0]);
+            Assert.Equal("two", List[1]);
+            Assert.Equal("three", List[2]);
+        }
+
+        /// <summary>
+        ///     Tests the <see cref="Utility.CommandLine.Arguments.Populate(Type, string)"/> method with an explicit string
+        ///     containing a single a single instance of a list-backed argument.
+        /// </summary>
+        [Fact]
+        public void PopulateSingle()
+        {
+            Exception ex = Record.Exception(() => CommandLine.Arguments.Populate(GetType(), "-l one"));
+
+            Assert.Null(ex);
+            Assert.Equal(1, List.Count);
+            Assert.Equal("one", List[0]);
+        }
+
+        #endregion Public Methods
+    }
+
     /// <summary>
     ///     Unit tests for the <see cref="CommandLine.Arguments"/> class.
     /// </summary>