Merge pull request #46 from jpdillingham/develop

Fix implicit Type identification with async calling methods

Author: jpdillingham

src/Utility.CommandLine.Arguments/Arguments.cs

@@ -77,6 +77,26 @@ internal static void ExclusiveAdd(this Dictionary<string, object> dictionary, st
                 }
             }
         }
+
+        /// <summary>
+        ///     Gets the DeclaringType of the first method on the stack whose name matches the specified <paramref name="caller"/>.
+        /// </summary>
+        /// <param name="caller">The name of the calling method for which the DeclaringType is to be fetched.</param>
+        /// <returns>The DeclaringType of the first method on the stack whose name matches the specified <paramref name="caller"/>.</returns>
+        internal static Type GetCallingType(string caller)
+        {
+            var callingMethod = new StackTrace().GetFrames()
+                .Select(f => f.GetMethod())
+                .Where(m => m.Name == caller)
+                .FirstOrDefault();
+
+            if (callingMethod == default(MethodBase))
+            {
+                throw new InvalidOperationException($"Unable to determine the containing type of the calling method '{caller}'.  Explicitly specify the originating Type.");
+            }
+
+            return callingMethod.DeclaringType;
+        }
     }
 
     /// <summary>
@@ -198,11 +218,12 @@ public object this[string index]
         ///     marked with the <see cref="ArgumentAttribute"/><see cref="Attribute"/> along with the short and long names and help text.
         /// </summary>
         /// <param name="type">The <see cref="Type"/> for which the matching properties are to be retrieived.</param>
+        /// <param name="caller">Internal parameter used to identify the calling method.</param>
         /// <returns>The retrieved collection of <see cref="ArgumentHelp"/>.</returns>
-        [Obsolete]
-        public static IEnumerable<ArgumentHelp> GetArgumentHelp(Type type = null)
+        [Obsolete("Use GetArgumentInfo()")]
+        public static IEnumerable<ArgumentHelp> GetArgumentHelp(Type type = null, [CallerMemberName] string caller = default(string))
         {
-            type = type ?? new StackFrame(1).GetMethod().DeclaringType;
+            type = type ?? ArgumentsExtensions.GetCallingType(caller);
 
             return GetArgumentInfo(type).Select(i => new ArgumentHelp()
             {
@@ -217,10 +238,11 @@ public static IEnumerable<ArgumentHelp> GetArgumentHelp(Type type = null)
         ///     marked with the <see cref="ArgumentAttribute"/><see cref="Attribute"/> along with the short and long names and help text.
         /// </summary>
         /// <param name="type">The <see cref="Type"/> for which the matching properties are to be retrieived.</param>
+        /// <param name="caller">Internal parameter used to identify the calling method.</param>
         /// <returns>The retrieved collection of <see cref="ArgumentInfo"/>.</returns>
-        public static IEnumerable<ArgumentInfo> GetArgumentInfo(Type type = null)
+        public static IEnumerable<ArgumentInfo> GetArgumentInfo(Type type = null, [CallerMemberName] string caller = default(string))
         {
-            type = type ?? new StackFrame(1).GetMethod().DeclaringType;
+            type = type ?? ArgumentsExtensions.GetCallingType(caller);
             var retVal = new List<ArgumentInfo>();
 
             foreach (PropertyInfo property in GetArgumentProperties(type).Values.Distinct())
@@ -247,13 +269,14 @@ public static IEnumerable<ArgumentInfo> GetArgumentInfo(Type type = null)
         /// </summary>
         /// <param name="commandLineString">The command line arguments with which the application was started.</param>
         /// <param name="type">The <see cref="Type"/> for which the command line string is to be parsed.</param>
+        /// <param name="caller">Internal parameter used to identify the calling method.</param>
         /// <returns>
         ///     The dictionary containing the arguments and values specified in the command line arguments with which the
         ///     application was started.
         /// </returns>
-        public static Arguments Parse(string commandLineString = default(string), Type type = null)
+        public static Arguments Parse(string commandLineString = default(string), Type type = null, [CallerMemberName] string caller = default(string))
         {
-            type = type ?? new StackFrame(1).GetMethod().DeclaringType;
+            type = type ?? ArgumentsExtensions.GetCallingType(caller);
 
             commandLineString = commandLineString == default(string) || commandLineString == string.Empty ? Environment.CommandLine : commandLineString;
 
@@ -300,16 +323,7 @@ public static IEnumerable<ArgumentInfo> GetArgumentInfo(Type type = null)
         /// <param name="caller">Internal parameter used to identify the calling method.</param>
         public static void Populate(string commandLineString = default(string), bool clearExistingValues = true, [CallerMemberName] string caller = default(string))
         {
-            var callingMethod = new StackTrace().GetFrames()
-                .Select(f => f.GetMethod())
-                .Where(m => m.Name == caller).FirstOrDefault();
-
-            if (callingMethod == default(MethodBase))
-            {
-                throw new InvalidOperationException("Error populating arguments; Unable to determine the containing type of Main().  Use Populate(typeof(<class containing main>))");
-            }
-
-            Populate(callingMethod.DeclaringType, Parse(commandLineString), clearExistingValues);
+            Populate(ArgumentsExtensions.GetCallingType(caller), Parse(commandLineString), clearExistingValues);
         }
 
         /// <summary>
@@ -488,7 +502,6 @@ private static object ChangeType(object value, string argument, Type toType)
             }
             catch (Exception ex)
             {
-                // if the cast fails, throw an exception
                 string message = $"Specified value '{value}' for argument '{argument}' (expected type: {toType}).  ";
                 message += "See inner exception for details.";
 

tests/Utility.CommandLine.Arguments.Tests/ArgumentsTests.cs

@@ -115,6 +115,23 @@ public void GetArgumentInfo()
 
             Assert.Equal(7, help.Count);
             Assert.Single(help.Where(h => h.ShortName == 'b'));
+            Assert.Single(help.Where(h => h.LongName == "test-prop"));
+            Assert.Equal("help", help.Where(h => h.ShortName == 'b').FirstOrDefault().HelpText);
+        }
+
+        /// <summary>
+        ///     Tests <see cref="CommandLine.Arguments.GetArgumentHelp"/>.
+        /// </summary>
+        [Fact]
+        public void GetArgumentHelp()
+        {
+#pragma warning disable CS0618 // Type or member is obsolete
+            var help = CommandLine.Arguments.GetArgumentHelp(typeof(Arguments)).ToList();
+#pragma warning restore CS0618 // Type or member is obsolete
+
+            Assert.Equal(7, help.Count);
+            Assert.Single(help.Where(h => h.ShortName == 'b'));
+            Assert.Single(help.Where(h => h.LongName == "test-prop"));
             Assert.Equal("help", help.Where(h => h.ShortName == 'b').FirstOrDefault().HelpText);
         }
 
@@ -128,6 +145,18 @@ public void GetArgumentInfoNull()
             Assert.Equal("help", help.Where(h => h.ShortName == 'b').FirstOrDefault().HelpText);
         }
 
+        [Fact]
+        public void GetArgumentHelpNull()
+        {
+#pragma warning disable CS0618 // Type or member is obsolete
+            var help = CommandLine.Arguments.GetArgumentHelp().ToList();
+#pragma warning restore CS0618 // Type or member is obsolete
+
+            Assert.Equal(7, help.Count);
+            Assert.Single(help.Where(h => h.ShortName == 'b'));
+            Assert.Equal("help", help.Where(h => h.ShortName == 'b').FirstOrDefault().HelpText);
+        }
+
         [Fact]
         public void Indexer()
         {
@@ -621,7 +650,7 @@ public class TestClassWithListProperty
         private static List<string> List { get; set; }
 
         [Fact]
-        public void Populate()
+        public void PopulateShort()
         {
             Exception ex = Record.Exception(() => CommandLine.Arguments.Populate(GetType(), "-l one -l two -l three"));
 
@@ -632,6 +661,30 @@ public void Populate()
             Assert.Equal("three", List[2]);
         }
 
+        [Fact]
+        public void PopulateLong()
+        {
+            Exception ex = Record.Exception(() => CommandLine.Arguments.Populate(GetType(), "--list one --list two --list three"));
+
+            Assert.Null(ex);
+            Assert.Equal(3, List.Count);
+            Assert.Equal("one", List[0]);
+            Assert.Equal("two", List[1]);
+            Assert.Equal("three", List[2]);
+        }
+
+        //[Fact]
+        //public void PopulateLongAndShort()
+        //{
+        //    Exception ex = Record.Exception(() => CommandLine.Arguments.Populate(GetType(), "-l one --list 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]);
+        //}
+
         [Fact]
         public void PopulateSingle()
         {