Merge pull request #21 from beheshty/feature/comprehensive-list-type

Feature/comprehensive list type

Author: beheshty

CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.0] - 2025-08-10
+### Changed
+- Enhanced the type inference logic for JSON arrays. The source generator now analyzes **all** objects within an array to create a single, comprehensive class for the list items. This replaces the previous behavior of only inspecting the first item, ensuring that properties from all objects are correctly captured.
+
+## [2.0.1] - 2025-08-04
+### Added
+- Added `Shipped.md` and `Unshipped.md` files to track analyzer diagnostics and releases. These files follow the official Roslyn analyzer release tracking format.
+
+### Notes
+- This is a documentation-only update with no functional code changes.
+
 ## [2.0.1] - 2025-08-04
 ### Added
 - Added `Shipped.md` and `Unshipped.md` files to track analyzer diagnostics and releases.

src/SetSharp/ModelBuilder/ConfigurationModelBuilder.cs

@@ -57,29 +57,49 @@ string HandleNestedObject(Dictionary<string, object> obj)
 
         private string InferListType(string parentSectionPath, string key, List<object> list)
         {
-            if (list.Count == 0) return "ImmutableList<object>";
+            if (list.Count == 0)
+            {
+                return "ImmutableList<object>";
+            }
 
-            string HandleListItemObject(Dictionary<string, object> obj)
+            var objectItems = list.OfType<Dictionary<string, object>>().ToList();
+
+            // If the list contains no objects (e.g., a list of strings or ints),
+            // infer the type from the first element as a fallback.
+            if (objectItems.Count == 0)
             {
-                var sectionPath = string.IsNullOrEmpty(parentSectionPath) ? key : $"{parentSectionPath}:{key}";
-                var classNameKey = $"{key}Item";
-                return CreateNestedClass(sectionPath, classNameKey, obj, isFromCollection: true);
+                return InferSimpleListType(list[0]);
             }
 
-            // Infer list type from the first item
-            var firstItem = list[0];
-            string listTypeName = firstItem switch
+            var mergedObject = new Dictionary<string, object>();
+            foreach (var item in objectItems)
+            {
+                foreach (var prop in item)
+                {
+                    mergedObject[prop.Key] = prop.Value;
+                }
+            }
+
+            var sectionPath = string.IsNullOrEmpty(parentSectionPath) ? key : $"{parentSectionPath}:{key}";
+            var classNameKey = $"{key}Item";
+            var listTypeName = CreateNestedClass(sectionPath, classNameKey, mergedObject, isFromCollection: true);
+
+            return $"ImmutableList<{listTypeName}>";
+        }
+
+        // Helper for simple list types (string, int, etc.)
+        private string InferSimpleListType(object item)
+        {
+            string typeName = item switch
             {
                 string => "string",
                 int => "int",
                 long => "long",
                 double => "double",
                 bool => "bool",
-                Dictionary<string, object> obj => HandleListItemObject(obj),
                 _ => "object"
             };
-
-            return $"ImmutableList<{listTypeName}>";
+            return $"ImmutableList<{typeName}>";
         }
 
         private string CreateNestedClass(string sectionPath, string classNameKey, Dictionary<string, object> obj, bool isFromCollection = false)

src/SetSharp/SetSharp.csproj

@@ -10,7 +10,7 @@
 		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
 
 		<PackageId>SetSharp</PackageId>
-		<Version>2.0.1</Version>
+		<Version>2.1.0</Version>
 		<PackageIcon>icon.png</PackageIcon>
 		<Authors>Amirhossein Beheshti</Authors>
 		<Description>Generates strongly typed settings classes from appsettings.json using Source Generators.</Description>

tests/SetSharp.Tests/ModelBuilder/ConfigurationModelBuilderTests.cs

@@ -14,7 +14,7 @@ public void BuildFrom_WithFlatPrimitives_ShouldCreateModelCorrectly()
             {
                 { "ConnectionString", "Server=.;Database=Test;"},
                 { "Timeout", 30 },
-                { "MaxRetries", 9223372036854775807L }, 
+                { "MaxRetries", 9223372036854775807L },
                 { "EnableLogging", true },
                 { "DefaultThreshold", 0.95 }
             };
@@ -240,5 +240,55 @@ public void BuildFrom_WithEmptyDictionary_ShouldReturnRootWithNoProperties()
             Assert.Equal("RootOptions", rootModel.ClassName);
             Assert.Empty(rootModel.Properties);
         }
+
+        [Fact]
+        public void BuildFrom_WithListOfObjectsHavingDifferentProperties_ShouldCreateComprehensiveClass()
+        {
+            // Arrange
+            var builder = new ConfigurationModelBuilder();
+            var root = new Dictionary<string, object>
+            {
+                { "Products", new List<object> {
+                    // First item only has Name and Id
+                    new Dictionary<string, object> {
+                        { "Id", 1 },
+                        { "Name", "Gadget" }
+                    },
+                    // Second item adds a 'Price' property
+                    new Dictionary<string, object> {
+                        { "Id", 2 },
+                        { "Name", "Widget" },
+                        { "Price", 99.99 }
+                    },
+                    // Third item adds an 'InStock' property
+                     new Dictionary<string, object> {
+                        { "Id", 3 },
+                        { "Name", "Doodad" },
+                        { "InStock", true }
+                    }
+                }}
+            };
+
+            // Act
+            var result = builder.BuildFrom(root);
+
+            // Assert
+            Assert.Equal(2, result.Count);
+
+            var rootModel = result.First(c => c.ClassName == "RootOptions");
+            var listProperty = Assert.Single(rootModel.Properties);
+            Assert.Equal("Products", listProperty.PropertyName);
+            Assert.Equal("ImmutableList<ProductsItemOptions>", listProperty.PropertyType);
+
+            var productItemModel = result.First(c => c.ClassName == "ProductsItemOptions");
+            Assert.Equal("Products", productItemModel.SectionPath);
+
+            Assert.Equal(4, productItemModel.Properties.Count);
+            Assert.Contains(productItemModel.Properties, p => p.PropertyName == "Id" && p.PropertyType == "int");
+            Assert.Contains(productItemModel.Properties, p => p.PropertyName == "Name" && p.PropertyType == "string");
+            Assert.Contains(productItemModel.Properties, p => p.PropertyName == "Price" && p.PropertyType == "double");
+            Assert.Contains(productItemModel.Properties, p => p.PropertyName == "InStock" && p.PropertyType == "bool");
+        }
     }
+
 }