Fix toolchain version output (#1461)

src/NJsonSchema.CodeGeneration.CSharp.Tests/GeneralGeneratorTests.cs

@@ -43,6 +43,29 @@ public async Task When_type_is_array_and_items_and_item_is_not_defined_then_any_
             AssertCompile(output);
         }
 
+        [Fact]
+        public async Task When_code_is_generated_then_toolchain_version_is_printed()
+        {
+            //// Arrange
+            var json = @"{
+                'required': [ 'emptySchema' ],
+                'properties': {
+                    'emptySchema': { 'type': 'array' }
+                }
+            }";
+            var schema = await JsonSchema.FromJsonAsync(json);
+
+            //// Act
+            var settings = new CSharpGeneratorSettings { ClassStyle = CSharpClassStyle.Poco, Namespace = "ns", };
+            var generator = new CSharpGenerator(schema, settings);
+            var output = generator.GenerateFile("MyClass");
+
+            //// Assert
+            Assert.Contains(" (Newtonsoft.Json ", output);
+
+            AssertCompile(output);
+        }
+
         class CustomPropertyNameGenerator : IPropertyNameGenerator
         {
             public string Generate(JsonSchemaProperty property)

src/NJsonSchema.CodeGeneration.CSharp/CSharpGenerator.cs

@@ -57,13 +57,13 @@ public override IEnumerable<CodeArtifact> GenerateTypes()
             {
                 if (Settings.ExcludedTypeNames?.Contains("JsonInheritanceAttribute") != true)
                 {
-                    var template = Settings.TemplateFactory.CreateTemplate("CSharp", "JsonInheritanceAttribute", new TemplateModelBase());
+                    var template = Settings.TemplateFactory.CreateTemplate("CSharp", "JsonInheritanceAttribute", new object());
                     artifacts.Add(new CodeArtifact("JsonInheritanceAttribute", CodeArtifactType.Class, CodeArtifactLanguage.CSharp, CodeArtifactCategory.Utility, template));
                 }
 
                 if (Settings.ExcludedTypeNames?.Contains("JsonInheritanceConverter") != true)
                 {
-                    var template = Settings.TemplateFactory.CreateTemplate("CSharp", "JsonInheritanceConverter", new TemplateModelBase());
+                    var template = Settings.TemplateFactory.CreateTemplate("CSharp", "JsonInheritanceConverter", new object());
                     artifacts.Add(new CodeArtifact("JsonInheritanceConverter", CodeArtifactType.Class, CodeArtifactLanguage.CSharp, CodeArtifactCategory.Utility, template));
                 }
             }

src/NJsonSchema.CodeGeneration.CSharp/Models/EnumTemplateModel.cs

@@ -15,7 +15,7 @@ namespace NJsonSchema.CodeGeneration.CSharp.Models
     // TODO: Add base class for CSharp.EnumTemplateModel and TypeScript.EnumTemplateModel
 
     /// <summary>The CSharp enum template model.</summary>
-    public class EnumTemplateModel : TemplateModelBase
+    public class EnumTemplateModel
     {
         private readonly JsonSchema _schema;
         private readonly CSharpGeneratorSettings _settings;

src/NJsonSchema.CodeGeneration.CSharp/Templates/Class.liquid

@@ -24,7 +24,7 @@
 {%- if IsDeprecated -%}
 [System.Obsolete{% if HasDeprecatedMessage %}({{ DeprecatedMessage | literal }}){% endif %}]
 {% endif -%}
-{%- template Class.Annotations %}
+{%- template Class.Annotations -%}
 {{ TypeAccessModifier }} {% if IsAbstract %}abstract {% endif %}partial {% if GenerateNativeRecords %}record{% else %}class{% endif %} {{ClassName}} {%- template Class.Inheritance %}
 {
 {%- if IsTuple -%}

src/NJsonSchema.CodeGeneration.TypeScript/TypeScriptGenerator.cs

@@ -93,13 +93,13 @@ public IEnumerable<CodeArtifact> GenerateTypes(TypeScriptExtensionCode extension
 
             if (artifacts.Any(r => r.Code.Contains("formatDate(")))
             {
-                var template = Settings.TemplateFactory.CreateTemplate("TypeScript", "File.FormatDate", new TemplateModelBase());
+                var template = Settings.TemplateFactory.CreateTemplate("TypeScript", "File.FormatDate", new object());
                 yield return new CodeArtifact("formatDate", CodeArtifactType.Function, CodeArtifactLanguage.CSharp, CodeArtifactCategory.Utility, template);
             }
 
             if (Settings.HandleReferences)
             {
-                var template = Settings.TemplateFactory.CreateTemplate("TypeScript", "File.ReferenceHandling", new TemplateModelBase());
+                var template = Settings.TemplateFactory.CreateTemplate("TypeScript", "File.ReferenceHandling", new object());
                 yield return new CodeArtifact("jsonParse", CodeArtifactType.Function, CodeArtifactLanguage.CSharp, CodeArtifactCategory.Utility, template);
             }
         }

src/NJsonSchema.CodeGeneration/DefaultTemplateFactory.cs

@@ -222,7 +222,7 @@ public string Render()
                     {
                         templateContext = new TemplateContext(_model, _templateOptions);
                         templateContext.AmbientValues.Add(LiquidParser.SettingsKey, _settings);
-                        templateContext.AmbientValues.Add("ToolchainVersion", _toolchainVersion);
+                        templateContext.SetValue("ToolchainVersion", _toolchainVersion);
                     }
 
                     templateContext.AmbientValues[LiquidParser.LanguageKey] = _language;

src/NJsonSchema.CodeGeneration/Models/ClassTemplateModelBase.cs

@@ -12,7 +12,7 @@
 namespace NJsonSchema.CodeGeneration.Models
 {
     /// <summary>The class template base class.</summary>
-    public abstract class ClassTemplateModelBase : TemplateModelBase
+    public abstract class ClassTemplateModelBase
     {
         private readonly JsonSchema _schema;
         private readonly object _rootObject;