Fix #830 - Recognize Option, Value and Usage attributes on private members

src/CommandLine/Core/ReflectionExtensions.cs

@@ -15,7 +15,10 @@ static class ReflectionExtensions
     {
         public static IEnumerable<T> GetSpecifications<T>(this Type type, Func<PropertyInfo, T> selector)
         {
-            return from pi in type.FlattenHierarchy().SelectMany(x => x.GetTypeInfo().GetProperties())
+            return from pi in type.FlattenHierarchy()
+                    .SelectMany(x => x.GetTypeInfo()
+                        .GetProperties(BindingFlags.Instance | BindingFlags.Static |
+                                       BindingFlags.NonPublic | BindingFlags.Public))
                    let attrs = pi.GetCustomAttributes(true)
                    where
                        attrs.OfType<OptionAttribute>().Any() ||
@@ -38,7 +41,9 @@ public static Maybe<VerbAttribute> GetVerbSpecification(this Type type)
         public static Maybe<Tuple<PropertyInfo, UsageAttribute>> GetUsageData(this Type type)
         {
             return
-                (from pi in type.FlattenHierarchy().SelectMany(x => x.GetTypeInfo().GetProperties())
+                (from pi in type.FlattenHierarchy().SelectMany(x => x.GetTypeInfo().GetProperties(
+                        BindingFlags.Instance | BindingFlags.Static |
+                        BindingFlags.NonPublic | BindingFlags.Public))
                     let attrs = pi.GetCustomAttributes(typeof(UsageAttribute), true)
                     where attrs.Any()
                     select Tuple.Create(pi, (UsageAttribute)attrs.First()))

src/CommandLine/Text/HelpText.cs

@@ -839,8 +839,10 @@ private static Maybe<Tuple<UsageAttribute, IEnumerable<Example>>> GetUsageFromTy
                     var prop = tuple.Item1;
                     var attr = tuple.Item2;
 
-                    var examples = (IEnumerable<Example>)prop
-                        .GetValue(null, BindingFlags.Public | BindingFlags.Static | BindingFlags.GetProperty, null, null, null);
+                    var examples = (IEnumerable<Example>) prop
+                        .GetValue(null,
+                            BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static |
+                            BindingFlags.GetProperty, null, null, null);
 
                     return Tuple.Create(attr, examples);
                 });

tests/CommandLine.Tests/Unit/Issue830Tests.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using System.IO;
+using CommandLine.Text;
+using FluentAssertions;
+using Xunit;
+
+// Issue #830
+// Allow private properties as options and usage
+namespace CommandLine.Tests.Unit
+{
+    public class Issue830Tests
+    {
+        [Fact]
+        public void Parse_options_with_private_value_and_option()
+        {
+            var expectedOptions = new Options
+            {
+                Option = "a",
+                Value = "b"
+            };
+
+            var result = Parser.Default.ParseArguments<Options>(
+                new[] { "b", "--opt", "a" });
+
+            ((Parsed<Options>)result).Value.Should().BeEquivalentTo(expectedOptions);
+        }
+
+        [Fact]
+        public void Print_private_usage()
+        {
+            var help = new StringWriter();
+            var sut = new Parser(config => config.HelpWriter = help);
+
+            sut.ParseArguments<Options>(new string[] { "--help" });
+            var result = help.ToString();
+
+            var lines = result.ToLines().TrimStringArray();
+            lines[3].Should().BeEquivalentTo("Do something very cool:");
+            lines[4].Should().BeEquivalentTo("myApp.txt --opt test1 test2");
+        }
+
+        private class Options
+        {
+            public string Option { get => PrivateOption; set => PrivateOption = value; }
+
+            public string Value { get => PrivateValue; set => PrivateValue = value; }
+
+            [Option("opt", Required = true)]
+            private string PrivateOption { get; set; }
+
+            [Value(0, Required = true)]
+            private string PrivateValue { get; set; }
+
+            [Usage(ApplicationAlias = "myApp.txt")]
+            private static IEnumerable<Example> PrivateUsage { get; } = new List<Example>
+            {
+                new Example("Do something very cool", new Options
+                {
+                    PrivateOption = "test1",
+                    PrivateValue = "test2"
+                })
+            };
+        }
+    }
+}