Updated packages, allow renaming types, parse property types in an improved way (for numeric values and DateTime)

Author: IqualityRobin

JsonByExampleGenerator.Generator/JsonByExampleGenerator.Generator.csproj

@@ -27,10 +27,13 @@
     <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
     <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.8.0" />
-    <PackageReference Include="NuGetizer" Version="0.4.11" />
+    <PackageReference Include="NuGetizer" Version="0.6.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Pluralize.NET" Version="1.0.2" GeneratePathProperty="true" PrivateAssets="all" />
-    <PackageReference Include="Scriban" Version="3.4.0" GeneratePathProperty="true" IncludeAssets="Build" PrivateAssets="all" />
-    <PackageReference Include="System.Text.Json" Version="5.0.0" GeneratePathProperty="true" PrivateAssets="all" />
+    <PackageReference Include="Scriban" Version="3.4.1" GeneratePathProperty="true" IncludeAssets="build" PrivateAssets="all" />
+    <PackageReference Include="System.Text.Json" Version="5.0.1" GeneratePathProperty="true" PrivateAssets="all" />
   </ItemGroup>
 
   <PropertyGroup>

JsonByExampleGenerator.Generator/JsonByExampleTemplate.sbntxt

@@ -1,4 +1,5 @@
 #nullable disable
+using System;
 using System.Collections.Generic;
 using System.Text.Json.Serialization;{{ for OptionalDependency in OptionalDependencies}}
 using {{ OptionalDependency }};

JsonByExampleGenerator.Generator/JsonGenerator.cs

@@ -8,8 +8,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Text;
-using Microsoft.CodeAnalysis.Emit;
-using System.Reflection;
 using Pluralize.NET;
 using JsonByExampleGenerator.Generator.Models;
 using System.Globalization;
@@ -35,6 +33,31 @@ public void Execute(GeneratorExecutionContext context)
         {
             try
             {
+                // The namespace of the code is determined by the assembly name of the compilation
+                string namespaceName = context.Compilation?.AssemblyName ?? "JsonByExample";
+
+                // Determine if the functionality for easy access to configuration should be enabled
+                bool configEnabled = IsConfigurationEnabled(context);
+
+                // A list of dependencies to be added to the using statements in the code generation
+                var optionalDependencies = new List<string>();
+                if (configEnabled)
+                {
+                    optionalDependencies.Add("Microsoft.Extensions.Configuration");
+                }
+
+                // Generate code that should only be generated once
+                const string onlyOnceTemplatePath = "OnlyOnceTemplate.sbntxt";
+                var onlyOnceTemplate = Template.Parse(EmbeddedResource.GetContent(onlyOnceTemplatePath), onlyOnceTemplatePath);
+                string onlyOnceGeneratedCode = onlyOnceTemplate.Render(new
+                {
+                    NamespaceName = namespaceName
+                }, member => member.Name);
+
+                // Add the generated code to the compilation
+                context.AddSource($"{namespaceName}_onlyonce.gen.cs",
+                    SourceText.From(onlyOnceGeneratedCode, Encoding.UTF8));
+
                 // Resolve all json files that are added to the AdditionalFiles in the compilation
                 foreach (var jsonFile in context.AdditionalFiles.Where(f => f.Path.EndsWith(".json", StringComparison.InvariantCultureIgnoreCase)))
                 {
@@ -44,26 +67,14 @@ public void Execute(GeneratorExecutionContext context)
                         continue;
                     }
 
-                    // Determine if the functionality for easy access to configuration should be enabled
-                    bool configEnabled = IsConfigurationEnabled(context);
-
                     var json = JsonDocument.Parse(jsonFileText.ToString());
 
-                    // The namespace of the code is determined by the assembly name of the compilation
-                    string namespaceName = context.Compilation?.AssemblyName ?? "JsonByExample";
-
                     // Read the json and build a list of models that can be used to generate classes
                     var classModels = new List<ClassModel>();
                     var jsonElement = json.RootElement;
                     string rootTypeName = GetValidName(Path.GetFileNameWithoutExtension(jsonFile.Path).Replace(" ", string.Empty), true);
                     ResolveTypeRecursive(context, classModels, jsonElement, rootTypeName);
 
-                    // A list of dependencies to be added to the using statements in the code generation
-                    var optionalDependencies = new List<string>();
-                    if (configEnabled)
-                    {
-                        optionalDependencies.Add("Microsoft.Extensions.Configuration");
-                    }
 
                     // Attempt to find a Scriban template in the AdditionalFiles that has the same name as the json
                     string templateFileName = $"{Path.GetFileNameWithoutExtension(jsonFile.Path)}.sbntxt";
@@ -131,7 +142,56 @@ public void Execute(GeneratorExecutionContext context)
         /// <param name="compilation">The compilation, so we can find existing types</param>
         private void FilterAndChangeBasedOnExistingCode(List<ClassModel> classModels, string namespaceName, Compilation compilation)
         {
-            foreach(var classModel in classModels)
+            // Deal with classes that have been decorated with JsonRenamedFrom attribute
+            // They must be renamed in the model
+            var renamedAttributes = compilation
+                .SyntaxTrees
+                .SelectMany(s => s
+                    .GetRoot()
+                    .DescendantNodes()
+                    .Where(d => d.IsKind(SyntaxKind.Attribute))
+                    .OfType<AttributeSyntax>()
+                    .Where(d => d.Name.ToString() == "JsonRenamedFrom")
+                    .Select(d => new
+                        {
+                            Renamed = (d?.Parent?.Parent as ClassDeclarationSyntax)?.Identifier.ToString().Trim(),
+                            From = d?.ArgumentList?.Arguments.FirstOrDefault()?.ToString().Trim().Trim('\"')
+                        }))
+                .Where(x => x.From != null
+                            && x.Renamed != null
+                            && compilation.GetTypeByMetadataName($"{namespaceName}.Json.{x.Renamed}") != null)
+                .ToList();
+            foreach (var classModel in classModels)
+            {
+                var match = renamedAttributes.FirstOrDefault(r => r.From == classModel.ClassName);
+                if (match != null)
+                {
+                    // Rename class
+                    classModel.ClassName = match.Renamed ?? classModel.ClassName;
+
+                    // Find all properties and update the type and init
+                    foreach(var property in classModels.SelectMany(p => p.Properties).ToList())
+                    {
+                        // Update init statement, if applicable
+                        if(property.Init == $"new List<{match.From}>()")
+                        {
+                            property.Init = $"new List<{classModel.ClassName}>()";
+                        }
+
+                        // Rename property type, if applicable
+                        if(property.PropertyType == match.From)
+                        {
+                            property.PropertyType = classModel.ClassName;
+                        }
+                        else if (property.PropertyType == $"IList<{match.From}>")
+                        {
+                            property.PropertyType = $"IList<{classModel.ClassName}>";
+                        }
+                    }
+                }
+            }
+
+            foreach (var classModel in classModels)
             {
                 // Find a class in the current compilation that already exists
                 var existingClass = compilation.GetTypeByMetadataName($"{namespaceName}.Json.{classModel.ClassName}");
@@ -217,11 +277,11 @@ private static void ResolveTypeRecursive(GeneratorExecutionContext context, List
                                 {
                                     if (arrEnumerator.Current.ValueKind == JsonValueKind.Number)
                                     {
-                                        arrPropName = "double";
+                                        arrPropName = FindBestNumericType(arrEnumerator.Current);
                                     }
                                     else if (arrEnumerator.Current.ValueKind == JsonValueKind.String)
                                     {
-                                        arrPropName = "string";
+                                        arrPropName = FindBestStringType(arrEnumerator.Current);
                                     }
                                     else if (arrEnumerator.Current.ValueKind == JsonValueKind.True || arrEnumerator.Current.ValueKind == JsonValueKind.False)
                                     {
@@ -247,8 +307,8 @@ private static void ResolveTypeRecursive(GeneratorExecutionContext context, List
 
                                 break;
                             }
-                        case JsonValueKind.String: propertyModel = new PropertyModel(prop.Name, "string", propName); break;
-                        case JsonValueKind.Number: propertyModel = new PropertyModel(prop.Name, "double", propName); break;
+                        case JsonValueKind.String: propertyModel = new PropertyModel(prop.Name, FindBestStringType(prop.Value), propName); break;
+                        case JsonValueKind.Number: propertyModel = new PropertyModel(prop.Name, FindBestNumericType(prop.Value), propName); break;
                         case JsonValueKind.False:
                         case JsonValueKind.True: propertyModel = new PropertyModel(prop.Name, "bool", propName); break;
                         case JsonValueKind.Object:
@@ -283,6 +343,53 @@ private static void ResolveTypeRecursive(GeneratorExecutionContext context, List
             }
         }
 
+        /// <summary>
+        /// Based on the value specified, determine an appropriate numeric type.
+        /// </summary>
+        /// <param name="propertyValue">Example value of the property</param>
+        /// <returns>The name of the numeric type</returns>
+        private static string FindBestNumericType(JsonElement propertyValue)
+        {
+            if (propertyValue.TryGetInt32(out _))
+            {
+                return "int";
+            }
+
+            if (propertyValue.TryGetInt64(out _))
+            {
+                return "long";
+            }
+
+            if (propertyValue.TryGetDouble(out var doubleVal)
+                && propertyValue.TryGetDecimal(out var decimalVal)
+                && Convert.ToDecimal(doubleVal) == decimalVal)
+            {
+                return "double";
+            }
+
+            if (propertyValue.TryGetDecimal(out _))
+            {
+                return "decimal";
+            }
+
+            return "object";
+        }
+
+        /// <summary>
+        /// Based on the value specified, determine if anything better than "string" can be used.
+        /// </summary>
+        /// <param name="current">Example value of the property</param>
+        /// <returns>string or something better</returns>
+        private static string FindBestStringType(JsonElement propertyValue)
+        {
+            if (propertyValue.TryGetDateTime(out _))
+            {
+                return "DateTime";
+            }
+
+            return "string";
+        }
+
         /// <summary>
         /// Gets a name that is valid in C# and makes it Pascal-case.
         /// Optionally, it can singularize the name, so that a list property has a proper model class.

JsonByExampleGenerator.Generator/Models/ClassModel.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Linq;
 using System.Collections.Generic;
-using System.Text;
 
 namespace JsonByExampleGenerator.Generator.Models
 {
@@ -10,6 +9,14 @@ namespace JsonByExampleGenerator.Generator.Models
     /// </summary>
     public class ClassModel
     {
+        private static readonly string[] numericPropertyTypeOrder = new[]
+        {
+            "int",
+            "long",
+            "double",
+            "decimal"
+        };
+
         /// <summary>
         /// The name of the class, that should be valid in C#.
         /// </summary>
@@ -37,7 +44,28 @@ public void Merge(ClassModel classModel)
         {
             if (classModel != null)
             {
-                Properties.AddRange(classModel.Properties.Except(this.Properties, new PropertyModelEqualityComparer()));
+                foreach(var property in classModel.Properties)
+                {
+                    var existingProp = Properties.FirstOrDefault(p => p.PropertyName == property.PropertyName);
+                    if(existingProp == null)
+                    {
+                        Properties.Add(property);
+                    }
+                    else if(existingProp.PropertyType != property.PropertyType)
+                    {
+                        // If there is a less restrictive property type that is needed, it must be changed
+                        if (numericPropertyTypeOrder.Contains(existingProp.PropertyType)
+                            && numericPropertyTypeOrder.Contains(property.PropertyType)
+                            && Array.IndexOf(numericPropertyTypeOrder, existingProp.PropertyType) < Array.IndexOf(numericPropertyTypeOrder, property.PropertyType))
+                        {
+                            existingProp.PropertyType = property.PropertyType;
+                        }
+                        else if (existingProp.PropertyType == "DateTime" && property.PropertyType == "string")
+                        {
+                            existingProp.PropertyType = property.PropertyType;
+                        }
+                    }
+                }
             }
         }
     }

JsonByExampleGenerator.Generator/Models/PropertyModel.cs

@@ -8,7 +8,7 @@ public class PropertyModel
         /// <summary>
         /// The C# type of the property.
         /// </summary>
-        public string PropertyType { get; private set; }
+        public string PropertyType { get; internal set; }
 
         /// <summary>
         /// The C# safe to use name of the property.
@@ -19,12 +19,12 @@ public class PropertyModel
         /// The original property name, before making it safe to use in C#.
         /// Can be used for example, for mapping back to json or comments.
         /// </summary>
-        public object PropertyNameOriginal { get; private set; }
+        public string PropertyNameOriginal { get; private set; }
 
         /// <summary>
         /// If the property needs to have a default value, it can be specified here.
         /// </summary>
-        public string? Init { get; set; }
+        public string? Init { get; internal set; }
 
         /// <summary>
         /// Create a new instance of the class.

JsonByExampleGenerator.Generator/OnlyOnceTemplate.sbntxt

@@ -0,0 +1,15 @@
+using System;
+
+namespace {{ NamespaceName }}.Json
+{
+    [AttributeUsage(AttributeTargets.Class)]
+    internal sealed class JsonRenamedFromAttribute : Attribute
+    {
+        internal string SourceName { get; private set; }
+
+        internal JsonRenamedFromAttribute(string sourceName)
+        {
+            SourceName = sourceName;
+        }
+    }
+}