Added ability to manually specify properties and exclude them from code generation

Author: IqualityRobin

Directory.Build.props

@@ -3,6 +3,6 @@
     <LangVersion>9.0</LangVersion>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <Nullable>enable</Nullable>
-    <Version>0.4.0</Version>
+    <Version>0.5.0</Version>
   </PropertyGroup>
 </Project>

JsonByExampleGenerator.Generator/JsonGenerator.cs

@@ -15,6 +15,7 @@
 using System.Globalization;
 using Scriban;
 using JsonByExampleGenerator.Generator.Utils;
+using System.Text.Json.Serialization;
 
 namespace JsonByExampleGenerator.Generator
 {
@@ -87,6 +88,11 @@ public void Execute(GeneratorExecutionContext context)
                         template = Template.Parse(EmbeddedResource.GetContent(defaultTemplatePath), defaultTemplatePath);
                     }
 
+                    if (context.Compilation != null)
+                    {
+                        FilterAndChangeBasedOnExistingCode(classModels, namespaceName, context.Compilation);
+                    }
+
                     // Use Scriban to render the code using the model that was built
                     string generatedCode = template.Render(new
                     {
@@ -117,6 +123,40 @@ public void Execute(GeneratorExecutionContext context)
             }
         }
 
+        /// <summary>
+        /// If json properties are specified manually, filter them here, so they can be omitted when generating code.
+        /// </summary>
+        /// <param name="classModels">The list of class models to apply filtering to</param>
+        /// <param name="namespaceName">The namespace, so we know what existing types to resolve</param>
+        /// <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)
+            {
+                // Find a class in the current compilation that already exists
+                var existingClass = compilation.GetTypeByMetadataName($"{namespaceName}.Json.{classModel.ClassName}");
+                if(existingClass != null)
+                {
+                    // Find all JsonPropertyName decorations
+                    var jsonProperties = existingClass
+                        .GetMembers()
+                        .OfType<IPropertySymbol>()
+                        .SelectMany(m => m
+                            .GetAttributes()
+                            .Where(a =>
+                                string.Equals(nameof(JsonPropertyNameAttribute), a.AttributeClass?.Name, StringComparison.InvariantCulture)
+                                || string.Equals("JsonPropertyName", a.AttributeClass?.Name, StringComparison.InvariantCulture))
+                            .Select(a => a.ConstructorArguments.FirstOrDefault().Value?.ToString())
+                            .Where(a => a != null));
+                    if(jsonProperties != null)
+                    {
+                        // Remove properties that are already in the compilation; no need to generate them
+                        classModel.Properties.RemoveAll(p => jsonProperties.Contains(p.PropertyNameOriginal));
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Find out if Microsoft.Extensions.Configuration.Json is used.
         /// </summary>

JsonByExampleGenerator.Tests/ChangesToGeneratedCodeTests.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace JsonByExampleGenerator.Tests
+{
+    public class ChangesToGeneratedCodeTests : TestsBase
+    {
+        public ChangesToGeneratedCodeTests(ITestOutputHelper output) : base(output)
+        {
+        }
+
+        [Fact]
+        public void ShouldGenerateWithChangedPropertyTypeOrName()
+        {
+            string source = @"using System;
+using System.Text.Json.Serialization;
+
+namespace TestImplementation.Json
+{
+    public partial class Example
+    {
+        // Change the type to int, instead of string
+        [JsonPropertyName(""prop"")]
+        public int Prop { get; set; }
+
+        // Change the name of the property, but reference json property properly
+        [JsonPropertyName(""another"")]
+        public int YetAnother { get; set; }
+    }
+}
+
+namespace Example
+{
+    class Test
+    {
+        public static string RunTest()
+        {
+            var json = new TestImplementation.Json.Example()
+                {
+                    Prop = 111,
+                    YetAnother = 33
+                };
+            return $""{json.Prop} {json.YetAnother}"";
+        }
+    }
+}";
+            var compilation = GetGeneratedOutput(source, new Dictionary<string, string>()
+                {
+                    { "example.json", "{ \"prop\" : \"val\", \"another\" : 22 }" }
+                });
+
+            Assert.Equal("111 33", RunTest(compilation));
+        }
+    }
+}

README.md

@@ -109,4 +109,34 @@ If you have specific needs for the generated code, you can easily create a [Scri
 - Create a file with the same name as your example json file, but with the extension `.sbntxt` instead of `.json`.
 - Ensure that the file is included in the `AdditionalFiles` for your project (the same way that you include your json files).
 - Copy the contents of the [default template](JsonByExampleGenerator.Generator/JsonByExampleTemplate.sbntxt), paste them in the file and save.
-- Change the template in any way you want, and you should observe the changes when you build your project.
+- Change the template in any way you want, and you should observe the changes when you build your project.
+
+## Manually change the type or name of properties
+
+Sometimes you may not like the name of the property or the type that is used. For example, if you want a `DateTime` instead of a `string` or a `int` instead of a `double`. The generator cannot detect this based on examples.
+
+You can fix this by specifying the property exactly how you want it in a partial class. Example:
+
+Given the following `products.json` file:
+```json
+[
+  {
+    "id": 12,
+    "name": "Example product"
+  }
+]
+```
+
+You can specify this partial class:
+
+```csharp
+namespace MyNs.Json
+{
+  public partial class Product
+  {
+    // Based on the attribute, the generator knows not to generate this property
+    [JsonPropertyName("id")]
+    public int Id { get; set; }
+  }
+}
+```