Added test to check that options can be bound to properties without setters provided they're initialized.

Author: markolbert

Binder.Tests/EmbeddedPropertiesNoSetter.cs

@@ -0,0 +1,38 @@
+using System.Collections.Generic;
+using Xunit;
+
+namespace J4JSoftware.Binder.Tests
+{
+    public class EmbeddedPropertiesNoSetter : BaseTest
+    {
+        [ Theory ]
+        [ MemberData( nameof(TestDataSource.GetEmbeddedPropertyData), MemberType = typeof(TestDataSource) ) ]
+        public void Allocations( TestConfig config )
+        {
+            Initialize( config );
+
+            Bind<EmbeddedTargetNoSetter, bool>( x => x.Target1.ASwitch );
+            Bind<EmbeddedTargetNoSetter, string>( x => x.Target1.ASingleValue );
+            Bind<EmbeddedTargetNoSetter, TestEnum>( x => x.Target1.AnEnumValue );
+            Bind<EmbeddedTargetNoSetter, TestFlagEnum>( x => x.Target1.AFlagEnumValue );
+            Bind<EmbeddedTargetNoSetter, List<string>>( x => x.Target1.ACollection );
+
+            ValidateTokenizing();
+        }
+
+        [ Theory ]
+        [ MemberData( nameof(TestDataSource.GetEmbeddedPropertyData), MemberType = typeof(TestDataSource) ) ]
+        public void Parsing( TestConfig config )
+        {
+            Initialize( config );
+
+            Bind<EmbeddedTargetNoSetter, bool>( x => x.Target1.ASwitch );
+            Bind<EmbeddedTargetNoSetter, string>( x => x.Target1.ASingleValue );
+            Bind<EmbeddedTargetNoSetter, TestEnum>( x => x.Target1.AnEnumValue );
+            Bind<EmbeddedTargetNoSetter, TestFlagEnum>( x => x.Target1.AFlagEnumValue );
+            Bind<EmbeddedTargetNoSetter, List<string>>( x => x.Target1.ACollection );
+
+            ValidateConfiguration<EmbeddedTargetNoSetter>();
+        }
+    }
+}

Binder.Tests/results/BasicTargetParameteredCtor.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+
+namespace J4JSoftware.Binder.Tests
+{
+    public class BasicTargetParameteredCtor
+    {
+        private readonly int _value;
+
+        public BasicTargetParameteredCtor( int value )
+        {
+            _value = value;
+        }
+
+        public bool ASwitch { get; set; }
+        public string ASingleValue { get; set; }
+        public List<string> ACollection { get; set; }
+        public TestEnum AnEnumValue { get; set; }
+        public TestFlagEnum AFlagEnumValue { get; set; }
+    }
+}

Binder.Tests/results/EmbeddedTarget.cs

@@ -1,4 +1,5 @@
 #pragma warning disable 8618
+#pragma warning disable 8618
 
 namespace J4JSoftware.Binder.Tests
 {

Binder.Tests/results/EmbeddedTargetNoSetter.cs

@@ -0,0 +1,10 @@
+#pragma warning disable 8618
+
+namespace J4JSoftware.Binder.Tests
+{
+    public class EmbeddedTargetNoSetter
+    {
+        public BasicTargetParameteredCtor Target1 { get; } = new( 0 );
+        public BasicTargetParameteredCtor Target2 { get; } = new( 0 );
+    }
+}

Binder/options/OptionCollection.cs

@@ -165,9 +165,9 @@ private bool ValidatePropertyInfo( PropertyInfo propInfo, bool isOuterMostLeaf =
 
             var piEntry = ((ValidationEntry<PropertyInfo>)piContext.Current)
                 .HasSupportedGetter();
-            
-            var typeEntry = piEntry.CreateChild(piEntry.Value.PropertyType)
-                .IsSupportedType();
+
+            var typeEntry = piEntry.CreateChild( piEntry.Value.PropertyType )
+                .IsSupportedType( isOuterMostLeaf );
 
             if( isOuterMostLeaf )
             {

Binder/options/PropertyValidators.cs

@@ -42,11 +42,11 @@ public static ValidationEntry<PropertyInfo> HasSupportedSetter( this ValidationE
             return entry;
         }
 
-        public static ValidationEntry<Type> IsSupportedType( this ValidationEntry<Type> entry )
+        public static ValidationEntry<Type> IsSupportedType( this ValidationEntry<Type> entry, bool isOuterMostLeaf = false )
         {
             if( entry.Value.IsGenericType )
                 entry.IsSupportedGenericType();
-            else entry.IsSupportedNonGenericType();
+            else entry.IsSupportedNonGenericType( isOuterMostLeaf );
 
             return entry;
         }
@@ -63,7 +63,7 @@ public static ValidationEntry<Type> IsSupportedGenericType( this ValidationEntry
                 var typeParamEntry =
                     entry.CreateChild<Type>( entry.Value.GetGenericArguments()[ 0 ], "from generic type check" );
 
-                typeParamEntry.IsSupportedNonGenericType();
+                typeParamEntry.IsSupportedNonGenericType( true );
 
                 if (!typeof(List<>).MakeGenericType(entry.Value.GenericTypeArguments[0]).IsAssignableFrom(entry.Value))
                     entry.AddError("Generic type is not a List<> type");
@@ -72,7 +72,7 @@ public static ValidationEntry<Type> IsSupportedGenericType( this ValidationEntry
             return entry;
         }
 
-        public static ValidationEntry<Type> IsSupportedNonGenericType( this ValidationEntry<Type> entry )
+        public static ValidationEntry<Type> IsSupportedNonGenericType( this ValidationEntry<Type> entry, bool isOuterMostLeaf = false )
         {
             if( entry.Value.IsGenericType )
                 entry.AddError( "Type must be non-generic" );
@@ -87,8 +87,10 @@ public static ValidationEntry<Type> IsSupportedNonGenericType( this ValidationEn
                 }
                 else
                 {
-                    if( entry.Value.IsValueType
-                        || typeof(string).IsAssignableFrom( entry.Value )
+                    if( entry.Value.IsValueType || typeof(string).IsAssignableFrom( entry.Value ) )
+                        return entry;
+
+                    if( !isOuterMostLeaf
                         || entry.Value.GetConstructors().Any( c => !c.GetParameters().Any() ) )
                         return entry;