Support typed options

kcartlidge · Nov 2, 2020 · 7b03f38 · 7b03f38
1 parent c290d72
commit 7b03f38
Show file tree

Hide file tree

Showing 3 changed files with 62 additions and 1 deletion.
diff --git a/ArgsParser.Tests/ArgsParserTests.cs b/ArgsParser.Tests/ArgsParserTests.cs
@@ -1,4 +1,5 @@
 using NUnit.Framework;
+using System;
 using System.Linq;
 
 namespace ArgsParser.Tests
@@ -138,6 +139,48 @@ public void ComplexOptionsAndFlags_ConditionsMet_HasNoErrors()
             Assert.IsEmpty(result.Errors);
         }
 
+        [Test]
+        public void OptionsWithTypes_ValuesCannotBeConverted_HasErrors()
+        {
+            var parser = new ArgsParser(new string[] { "-dtm", "a", "-f", "b" })
+                .RequiresOption<DateTime>("dtm", "A datetime value")
+                .RequiresOption<float>("f", "A float value");
+
+            var result = parser.Parse();
+
+            Assert.AreEqual(2, result.Errors.Count);
+            Assert.Contains("dtm", result.Errors.Keys.ToList());
+            StringAssert.Contains("value of type", result.Errors["dtm"].First());
+            Assert.Contains("f", result.Errors.Keys.ToList());
+            StringAssert.Contains("value of type", result.Errors["f"].First());
+        }
+
+        [Test]
+        public void OptionsWithTypes_TypeConversionOccurs()
+        {
+            var parser = new ArgsParser(new string[] {
+                    "-s", "a", "-i", "1", "-n", "1.2", "-d", "2020-10-03", "-b", "true" })
+                .RequiresOption<string>("s", "A string value")
+                .RequiresOption<int>("i", "An integer value")
+                .RequiresOption<decimal>("n", "A numeric value")
+                .RequiresOption<DateTime>("d", "A datetime value")
+                .RequiresOption<bool>("b", "A boolean value");
+
+            var result = parser.Parse();
+
+            Assert.IsEmpty(result.Errors);
+            Assert.IsInstanceOf<string>(result.ParsedOptions["s"]);
+            Assert.IsInstanceOf<int>(result.ParsedOptions["i"]);
+            Assert.IsInstanceOf<decimal>(result.ParsedOptions["n"]);
+            Assert.IsInstanceOf<DateTime>(result.ParsedOptions["d"]);
+            Assert.IsInstanceOf<bool>(result.ParsedOptions["b"]);
+            Assert.AreEqual("a", result.ParsedOptions["s"]);
+            Assert.AreEqual(1, result.ParsedOptions["i"]);
+            Assert.AreEqual(1.2D, result.ParsedOptions["n"]);
+            Assert.AreEqual(new DateTime(2020, 10, 3), result.ParsedOptions["d"]);
+            Assert.AreEqual(true, result.ParsedOptions["b"]);
+        }
+
         [Test]
         public void UnexpectedValueProvided_HasErrors()
         {

diff --git a/ArgsParser/ArgsParser.cs b/ArgsParser/ArgsParser.cs
@@ -7,7 +7,7 @@ namespace ArgsParser
     public class ArgsParser
     {
         public List<string> ParsedFlags = new List<string>();
-        public SortedList<string, string> ParsedOptions = new SortedList<string, string>();
+        public SortedList<string, object> ParsedOptions = new SortedList<string, object>();
         public bool HasErrors { get => Errors.Any(); }
         public SortedList<string, List<string>> Errors = new SortedList<string, List<string>>();
 
@@ -68,6 +68,7 @@ public ArgsParser Help()
         public ArgsParser Parse()
         {
             // Extract all the flags and options.
+            // In this initial splitting process, all option values are treated as strings.
             var currentName = (string)null;
             foreach (var arg in RawArgs)
             {
@@ -121,6 +122,20 @@ public ArgsParser Parse()
             if (currentName != null)
                 ParsedFlags.Add(currentName.ToLower());
 
+            // Convert any non-string options.
+            foreach (var option in Options.Where(x => x.Value.ArgType != typeof(string)))
+                if (ParsedOptions.ContainsKey(option.Key))
+                {
+                    try
+                    {
+                        ParsedOptions[option.Key] = Convert.ChangeType(ParsedOptions[option.Key], option.Value.ArgType);
+                    }
+                    catch
+                    {
+                        AddError(option.Key, $"Expected a value of type {option.Value.ArgType}: {option.Key}");
+                    }
+                }
+
             // Enforce any options requirements.
             // No required flags, as that would force the value to always be true.
             foreach (var option in Options.Where(x => x.Value.IsRequired))

diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -7,3 +7,6 @@
 	- And tests
 - Add `ArgsParser` class
 	- And tests
+- Support typed options
+	- Converts where possible
+	- Else returns as strings