feat: Add Support for Nested Classes #8

README.md

@@ -40,7 +40,7 @@ Example:
 ```xml
 <Project Sdk="Microsoft.NET.Sdk">
     <ItemGroup>
-        <PackageReference Include="kli.Localize" Version="0.7.*" />
+        <PackageReference Include="kli.Localize" Version="1.0.*" />
 
         <AdditionalFiles Include="TestLocalizations\Locale.json" />
     </ItemGroup>
@@ -146,9 +146,52 @@ Access is based on [CultureInfo.CurrentUICulture](https://docs.microsoft.com/en-
 The namespace is generated using the following pattern:<br>
 `rootnamespace + relative directory structure`
 <br>
+Since v0.8 this behaviour can be overriden [see 'From version 0.8'](#From version 0.8)
 
 ## Version Changes
 
+### From version 1.0
+
+#### BREAKING - Ignore none JSON-String/Object values
+All properties that are not string or object will be ignored. 
+```json
+{
+    "Number": 4.2,
+    "Bool": true,
+    "Null": null,
+    "Array": [1,2,3]
+}
+```
+
+#### [Add Support for Nested Classes #8](https://github.com/kl1mm/localize/issues/8)
+It is now possible to use JSON objects in the localization files.
+During generation, the structure is mapped as a nested class for access
+
+```json
+{
+    "SomeText": "some text",
+    "Sub": 
+    {
+        "FileNotFound": "Not found",
+        "DivideByZero": "x / zero"
+    },
+    "UI":{
+        "LabelOne": "One",
+        "LabelTwo": "Two",
+        "Login": {
+            "LabelUserName": "User",
+            "LabelPassword": "Pass"
+        }
+    }
+}
+```
+#### Improved Diagnostics
+ - SGL0001: InvalidJsonFileFormat - `<JsonReaderException.Message>`
+ - SGL0002: InvalidJsonPropertyName - `Json property key must be a valid C# identifier`
+ - SGL0003: InvalidJsonTokenType - `Json property value must be an object or a string`
+
+All diagnostics came with LinePostion (linenumber & column)
+
 ### From version 0.8
 
 It is now possible to override the namespace and the class/file name that will be generated:
@@ -158,14 +201,14 @@ It is now possible to override the namespace and the class/file name that will b
         <PackageReference Include="kli.Localize" Version="0.8.*" />
 
         <AdditionalFiles Include="Localizations\Locale.json" 
-                         NamespaceName="Namesapce.of.your.choice"
+                         NamespaceName="Namespace.of.your.choice"
                          ClassName="MyClassName" />
     </ItemGroup>
 </Project>
 ```
 From which the following is generated:
 ```csharp
-namespace Namesapce.of.your.choice
+namespace Namespace.of.your.choice
 {
     ...
     public sealed class MyClassName {

example/kli.Localize.Example/kli.Localize.Example.csproj

@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <OutputType>Exe</OutputType>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
     </PropertyGroup>
 
     <ItemGroup>

src/kli.Localize.Generator/Internal/Helper/CultureData.cs

@@ -0,0 +1,41 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace kli.Localize.Generator.Internal.Helper
+{
+    internal class CultureData
+    {
+        public const string InvariantKeyName = "invariant";
+
+        public string Key { get; private set; }
+        public string NormalizedKey { get; private set; }
+        public TranslationData Translations { get; private set; }
+
+        private CultureData() { }
+
+        public static IReadOnlyList<CultureData> Initialize(string filePath, ITranslationReader translationReader)
+        {
+            var searchDir = Path.GetDirectoryName(filePath)!;
+            var fileName = Path.GetFileNameWithoutExtension(filePath);
+            return Directory.GetFiles(searchDir, $"{fileName}*{Path.GetExtension(filePath)}")
+                .Select(cfp => ResolveCulture(cfp, translationReader)).ToList();
+        }
+
+        private static CultureData ResolveCulture(string cultureFilePath, ITranslationReader translationReader)
+        {
+            var cultureId = Path.GetFileNameWithoutExtension(cultureFilePath).Split('_').Skip(1).LastOrDefault()
+                ?? InvariantKeyName;
+
+            return new()
+            {
+                Key = cultureId, 
+                NormalizedKey = NormalizeCultureIdentifier(cultureId), 
+                Translations = translationReader.Read(cultureFilePath)
+            };
+        }
+
+        private static string NormalizeCultureIdentifier(string cultureId)
+            => cultureId.ToLower().Replace('-', '_');
+    }
+}

src/kli.Localize.Generator/Internal/Helper/GeneratorData.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace kli.Localize.Generator.Internal.Helper
+{
+    internal class GeneratorData  
+    {
+        public IReadOnlyList<CultureData> CultureData { get; set; }
+        public TranslationData InvariantTranslationData 
+            => this.CultureData.Single(cd => cd.Key == Helper.CultureData.InvariantKeyName).Translations;
+
+        public string Namespace { get; set; }
+        public string GeneratedFileName { get; set; }
+        public string GeneratedClassName { get; set; }
+    }
+}

src/kli.Localize.Generator/Internal/Helper/GeneratorDataBuilder.cs

@@ -0,0 +1,18 @@
+using Microsoft.CodeAnalysis;
+
+namespace kli.Localize.Generator.Internal.Helper;
+
+internal class GeneratorDataBuilder(AdditionalText originFile, 
+    NamesResolver namesResolver, ITranslationReader translationReader)
+{
+    public GeneratorData Build()
+    {
+        return new GeneratorData
+        {
+            GeneratedClassName = namesResolver.ResolveGeneratedClassName(),
+            GeneratedFileName = namesResolver.ResolveGeneratedFileName(),
+            Namespace = namesResolver.ResolveNamespace(),
+            CultureData = CultureData.Initialize(originFile.Path, translationReader),
+        };
+    }
+}

src/kli.Localize.Generator/Internal/NamesResolver.cs → src/kli.Localize.Generator/Internal/Helper/NamesResolver.cs

@@ -3,7 +3,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace kli.Localize.Generator.Internal
+namespace kli.Localize.Generator.Internal.Helper
 {
     internal class NamesResolver
     {
@@ -22,7 +22,7 @@ public string ResolveGeneratedClassName()
         {
             if (this.optionsProvider.GetOptions(this.originFile).TryGetValue("build_metadata.AdditionalFiles.ClassName", out var className) && !string.IsNullOrWhiteSpace(className))
                 return className;
-            return Path.GetFileNameWithoutExtension(originFile.Path);
+            return Path.GetFileNameWithoutExtension(this.originFile.Path);
         }
 
         public string ResolveGeneratedFileName() 
@@ -34,7 +34,7 @@ public string ResolveNamespace()
                 return namespaceName;
 
             if (!this.optionsProvider.GlobalOptions.TryGetValue("build_property.rootnamespace", out var rootNamespace))
-                rootNamespace = fallBackRootNamespace;
+                rootNamespace = this.fallBackRootNamespace;
 
             if (this.optionsProvider.GlobalOptions.TryGetValue("build_property.projectdir", out var projectDir))
             {

src/kli.Localize.Generator/Internal/Helper/TranslationData.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+
+namespace kli.Localize.Generator.Internal.Helper
+{
+    internal class TranslationData : Dictionary<string, object>
+    {
+        public IDictionary<string, string> Flatten() 
+            => this.FlattenCore(this, string.Empty);
+
+        private IDictionary<string, string> FlattenCore(TranslationData translationData, string parentKey)
+        {
+            var result = new Dictionary<string, string>();
+            foreach (var kvp in translationData)
+            {
+                var key = string.IsNullOrEmpty(parentKey) ? kvp.Key : $"{parentKey}::{kvp.Key}";
+                if (kvp.Value is TranslationData nested)
+                {
+                    foreach (var nestedKvp in this.FlattenCore(nested, key)) 
+                        result[nestedKvp.Key] = nestedKvp.Value;
+                }
+                else
+                    result[key] = kvp.Value.ToString();
+            }
+
+            return result;
+        }        
+    }
+}

src/kli.Localize.Generator/Internal/ITranslationReader.cs

@@ -0,0 +1,9 @@
+using kli.Localize.Generator.Internal.Helper;
+
+namespace kli.Localize.Generator.Internal
+{
+    internal interface ITranslationReader
+    {
+        TranslationData Read(string filePath);
+    }
+}

src/kli.Localize.Generator/Internal/Json/JsonDiagnostics.cs

@@ -0,0 +1,39 @@
+using System;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Text;
+using Newtonsoft.Json;
+
+namespace kli.Localize.Generator.Internal.Json
+{
+    internal static class JsonDiagnostics
+    {
+        public static void ReportInvalidFileFormat(this Action<Diagnostic> reporter, string filePath, JsonReaderException ex)
+        {
+            reporter.Report(1, ex.Message, filePath, 
+                new LinePosition(ex.LineNumber-1, ex.LinePosition), DiagnosticSeverity.Error);
+        }
+
+        public static void ReportInvalidKey(this Action<Diagnostic> reporter, string filePath, JsonTextReader reader)
+        {
+            var message = $"Json property key must be a valid C# identifier: '{reader.Value}'";
+            reporter.Report(2, message, filePath, 
+                new LinePosition(reader.LineNumber-1, reader.LinePosition), DiagnosticSeverity.Warning);
+        } 
+
+        public static void ReportInvalidTokenType(this Action<Diagnostic> reporter, string filePath, JsonTextReader reader)
+        {
+            var message = $"Json property value must be an object or a string: '{reader.TokenType} - {reader.Value} ({reader.ValueType})'";
+            reporter.Report(3, message, filePath, 
+                new LinePosition(reader.LineNumber-1, reader.LinePosition), DiagnosticSeverity.Warning);
+        }
+
+        private static void Report(this Action<Diagnostic> reporter, int id, string message,
+            string filePath, LinePosition linePosition, DiagnosticSeverity severity)
+        {
+            var diagnostic = Diagnostic.Create(
+                new DiagnosticDescriptor($"SGL000{id}", "kli.Localize.Generator", message, "Source Generators", severity, true),
+                Location.Create(filePath, new TextSpan(), new LinePositionSpan(linePosition, linePosition)));
+            reporter(diagnostic);
+        }
+    }
+}