fix resource class name generation -> 0.0.3

Readme.md

@@ -3,8 +3,10 @@
 ## What is ResourceString.Net?
 
 ResourceString.Net is a powerful .NET library that allows you to work with string resources in a type-safe manner.
-It leverages the `resx` file in your project and utilizes a  [c# source code generator](https://learn.microsoft.com/en-us/dotnet/csharp/roslyn-sdk/source-generators-overview) to create a comprehensive API.
+It leverages the `resx` file in your project and utilizes a [c# source code generator](https://learn.microsoft.com/en-us/dotnet/csharp/roslyn-sdk/source-generators-overview) to create a comprehensive API. No [`Designer.cs`](https://learn.microsoft.com/en-us/dotnet/framework/tools/resgen-exe-resource-file-generator?source=recommendations) or  [`T4 Text Templates`](https://learn.microsoft.com/en-us/visualstudio/modeling/code-generation-and-t4-text-templates?) filer for resources are required any more.
+
 With ResourceString.Net, you can handle resource strings as "multi-language strings" (see [The ResourceString-Classes](#the-resourcestring-classes)) instead of built-in strings.
+
 This provides the ability to switch languages during runtime without the need to rerun string factory methods.
 Additionally, ResourceString.Net ensures that formatted strings have methods with the correct number of expected parameters.
 
@@ -81,53 +83,85 @@ namespace MyTestConsoleApp
 {
   internal static class Resources
   {
+    #region ResourceManager 
 
-      #region ResourceManager 
+    private static readonly Type _Type = typeof(Resources);
+  
+    private static readonly Lazy<ResourceManager> _ResourceManager = new Lazy<ResourceManager>(
+        () => new ResourceManager("MyTestConsoleApp.Resources" ?? string.Empty, _Type.Assembly),                   
+        LazyThreadSafetyMode.PublicationOnly
+    );
 
-      private static readonly Type _Type = typeof(Resources);
+    public static ResourceManager ResourceManager => _ResourceManager.Value;
+
+    #endregion // ResourceManager  
     
-      private static readonly Lazy<ResourceManager> _ResourceManager = new Lazy<ResourceManager>(
+    #region Greetings 
-          () => new ResourceManager(_Type.FullName ?? string.Empty, _Type.Assembly),                   
-          LazyThreadSafetyMode.PublicationOnly
-      );
 
-      public static ResourceManager ResourceManager => _ResourceManager.Value;
+    internal static class Greetings 
+    {
+        private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
+            () => new ResourceManagerString("Greetings", ResourceManager, CultureInfo.CurrentCulture),
+            LazyThreadSafetyMode.PublicationOnly
+        );
 
-      #endregion // ResourceManager
+        public static IResourceString Format => LazyFormat.Value;
-  
+        
+        public static IResourceString From(IResourceString name) => new FormattedResourceString(
+            Format, 
+            name
+        );
 
-      internal static class Greetings 
+    } 
-      {
-          private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
-              () => new ResourceManagerString("Greetings", ResourceManager, CultureInfo.CurrentCulture),
-              LazyThreadSafetyMode.PublicationOnly
-          );
 
-          public static IResourceString Format => LazyFormat.Value;
+    #endregion // Greetings  
-          
-          public static IResourceString From(IResourceString name) => new FormattedResourceString(
-              Format, 
-              name
-          );
-  
-      } 
-  
-      #region World 
 
-      private static readonly Lazy<IResourceString> LazyWorld = new Lazy<IResourceString>(
+    #region World 
-          () => new ResourceManagerString("World", ResourceManager, CultureInfo.CurrentCulture),
-          LazyThreadSafetyMode.PublicationOnly
-      );
 
-      public static IResourceString World => LazyWorld.Value;
+    private static readonly Lazy<IResourceString> LazyWorld = new Lazy<IResourceString>(
+        () => new ResourceManagerString("World", ResourceManager, CultureInfo.CurrentCulture),
+        LazyThreadSafetyMode.PublicationOnly
+    );
 
-      #endregion // World 
+    public static IResourceString World => LazyWorld.Value;
-  
+
+    #endregion // World   
   }
 }
 
 ```
 
+### Add Multi-Languages
+
+
+Run the following script to add a language specific resource file and add a culture change during runtime:
+```sh
+
+echo "<?xml version='1.0' encoding='utf-8'?>
+<root>
+  <data name='Greetings'>
+    <value>Hallo {0}</value>
+    <comment>0 = name</comment>
+  </data>
+  <data name='World' type='System.String'>
+    <value>Welt</value>
+  </data>
+</root>
+" > Resources.de.resx
+
+echo "
+Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.GetCultureInfo(\"de-DE\");
+
+Console.WriteLine(message.Value);
+" >> Program.cs
+
+dotnet run
+# Expected output: Hello World \n Hallo Welt
+```
+
+In the code from `Program.cs` you can see there is explicit rebuild of the format string required after the culture switch.
+The `IResourceString` object themselves are rebuilding the culture specific string.
+
 ## The ResourceString-Classes
 
 ### IResourceString
@@ -212,13 +246,13 @@ You can redirect the output to a file if desired.
 
 ## Third party packages
 
-| Package                               | Version |
+| Package                                                                                             | Version |
-| ------------------------------------- | ------- |
+| --------------------------------------------------------------------------------------------------- | ------- |
-| Microsoft.CodeAnalysis.Analyzers      | 3.3.4   |
+| [Microsoft.CodeAnalysis.Analyzers](https://www.nuget.org/packages/Microsoft.CodeAnalysis.Analyzers) | 3.3.4   |
-| Microsoft.CodeAnalysis.CSharp         | 4.3.0   |
+| [Microsoft.CodeAnalysis.CSharp](https://www.nuget.org/packages/Microsoft.CodeAnalysis.CSharp)       | 4.3.0   |
-| NETStandard.Library (Auto-referenced) | 2.0.3   |
+| [NETStandard.Library](https://www.nuget.org/packages/NETStandard.Library)                           | 2.0.3   |
-| LanguageExt.Core                      | 4.4.3   |
+| [LanguageExt.Core](https://www.nuget.org/packages/LanguageExt.Core)                                 | 4.4.3   |
-| System.Resources.Extensions           | 7.0.0   |
+| [System.Resources.Extensions](https://www.nuget.org/packages/System.Resources.Extensions)           | 7.0.0   |
 
 ## Development Notes
 

ResourceString.Net.App.Console/Program.cs

@@ -3,14 +3,21 @@ using ResourceString.Net.Logic.Parsers.Resx;
 
 var sourceFile = args.First();
 var namespaceString = args.Skip(1).FirstOrDefault() ?? "Properties";
-var className = args.Skip(2).FirstOrDefault() ?? "Resources";
+
+var resourceFileName = args.Skip(2).FirstOrDefault() ?? "Resources";
+var className = CodeSnippetFactory.TransformToClassName(
+    resourceFileName
+);
 
 var result = Parser.TryParse(System.IO.File.ReadAllText(sourceFile)).Match(
    Some: v => CodeSnippetFactory.CreateResourceClassCodeSnippet(
-       namespaceString,
+       CodeSnippetFactory.TransformToNamespace(namespaceString),
        className,
-       CodeSnippetFactory.CreateResourceMangerMemberCodeSnippet(className),
+       CodeSnippetFactory.CreateResourceMangerMemberCodeSnippet(
-       v.Resources
+        $"{namespaceString}.{className}",
+        className
+        ),
+        v.Resources
    ),
    None: () => throw new InvalidOperationException()
 );

ResourceString.Net.Logic.Tests/LogicResourcesTests.cs

@@ -68,10 +68,12 @@ public class LogicResourcesTests
         var rm = Properties.Resources.ResourceManager;
         Assert.AreEqual(
             CodeSnippetFactory.CreateResourceMangerMemberCodeSnippet(
+                "Resources",
                 "Resources"
             ).Value,
             string.Format(
                 rm.GetString("ResourceManagerMemberTemplate") ?? string.Empty,
+                "Resources",
                 "Resources"
             )
         );
@@ -83,6 +85,7 @@ public class LogicResourcesTests
         var rm = Properties.Resources.ResourceManager;
 
         var rmSnippet = CodeSnippetFactory.CreateResourceMangerMemberCodeSnippet(
+            "Resources",
             "Resources"
         );
 

ResourceString.Net.Logic.Tests/ResxFileTests.cs

@@ -36,10 +36,10 @@ namespace TestNameSpace
 
         #region ResourceManager 
 
-        private static readonly Type _Type = typeof(ResourceManager);
+        private static readonly Type _Type = typeof(TestResourceClass);
       
         private static readonly Lazy<ResourceManager> _ResourceManager = new Lazy<ResourceManager>(
-            () => new ResourceManager(_Type.FullName ?? string.Empty, _Type.Assembly),                   
+            () => new ResourceManager(""ResourceManager"" ?? string.Empty, _Type.Assembly),                   
             LazyThreadSafetyMode.PublicationOnly
         );
 
@@ -175,7 +175,7 @@ namespace TestNameSpace
             Some: v => CodeSnippetFactory.CreateResourceClassCodeSnippet(
                 "TestNameSpace",
                 "TestResourceClass",
-                CodeSnippetFactory.CreateResourceMangerMemberCodeSnippet("ResourceManager"),
+                CodeSnippetFactory.CreateResourceMangerMemberCodeSnippet("ResourceManager", "TestResourceClass"),
                 v.Resources
             ),
             None: () => throw new InvalidOperationException()

ResourceString.Net.Logic/Factories/CodeSnippetFactory.cs

@@ -2,15 +2,19 @@ using ResourceString.Net.Logic.DomainObjects.Resx;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.RegularExpressions;
 
 namespace ResourceString.Net.Logic.Factories;
 
 internal static class CodeSnippetFactory
 {
-    public static IResourceString CreateResourceMangerMemberCodeSnippet(string typeName)
+    public static IResourceString CreateResourceMangerMemberCodeSnippet(
+        string resourceName,
+        string className)
     {
         return Properties.Resources.ResourceManagerMemberTemplate.From(
-            LiteralString.Factory(typeName)
+            LiteralString.Factory(resourceName),
+            LiteralString.Factory(className)
         );
     }
 
@@ -24,8 +28,7 @@ internal static class CodeSnippetFactory
 
     public static IEnumerable<IResourceString> CreateMemberCodeSnippets(
         IEnumerable<Resource> resources,
-        IResourceString resourceManagerName
+        IResourceString resourceManagerName)
-        )
     {
         if (resources is null)
         {
@@ -95,8 +98,7 @@ internal static class CodeSnippetFactory
         string namespaceString,
         string resourceClassName,
         IResourceString resourceManagerSnippet,
-        IEnumerable<IResourceString> memberSnippets
+        IEnumerable<IResourceString> memberSnippets)
-        )
     {
         return Properties.Resources.ResourcesClassTemplate.From(
             LiteralString.Factory(namespaceString),
@@ -123,4 +125,28 @@ internal static class CodeSnippetFactory
             CreateMemberCodeSnippets(resources)
         );
     }
+
+    public static string TransformToClassName(string input)
+    {
+        // Remove invalid characters and replace them with underscores
+        string sanitizedInput = Regex.Replace(
+            input?.Trim() ?? string.Empty,
+            @"[^a-zA-Z0-9_]", "_"
+        );
+
+        // Remove leading digits if the string starts with a digit
+        return Regex.Replace(sanitizedInput, @"^\d+", "");
+    }
+
+    public static string TransformToNamespace(string input)
+    {
+        // Remove invalid characters and replace them with dots
+        string sanitizedInput = Regex.Replace(
+            input?.Trim() ?? string.Empty,
+            @"[^a-zA-Z0-9_.]", "."
+        );
+
+        // Remove leading dots if present
+        return sanitizedInput.TrimStart('.');
+    }
 }

ResourceString.Net.Logic/Properties/Resources.cs

@@ -12,18 +12,18 @@ namespace ResourceString.Net.Logic.Properties
         #region ResourceManager 
 
         private static readonly Type _Type = typeof(Resources);
-      
+
         private static readonly Lazy<ResourceManager> _ResourceManager = new Lazy<ResourceManager>(
-            () => new ResourceManager(_Type.FullName ?? string.Empty, _Type.Assembly),                   
+            () => new ResourceManager("ResourceString.Net.Logic.Properties.Resources" ?? string.Empty, _Type.Assembly),
             LazyThreadSafetyMode.PublicationOnly
         );
 
         public static ResourceManager ResourceManager => _ResourceManager.Value;
 
         #endregion // ResourceManager
-    
 
-        internal static class ResourceStringMembers 
+
+        internal static class ResourceStringMembers
         {
             private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
                 () => new ResourceManagerString("ResourceStringMembers", ResourceManager, CultureInfo.CurrentCulture),
@@ -31,16 +31,16 @@ namespace ResourceString.Net.Logic.Properties
             );
 
             public static IResourceString Format => LazyFormat.Value;
-            
+
             public static IResourceString From(IResourceString resourceId, IResourceString resourceManagerPropertyName) => new FormattedResourceString(
-                Format, 
+                Format,
                 resourceId,
                 resourceManagerPropertyName
             );
-    
+
-        } 
+        }
-    
+
-        internal static class ResourceFormatClassMembers 
+        internal static class ResourceFormatClassMembers
         {
             private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
                 () => new ResourceManagerString("ResourceFormatClassMembers", ResourceManager, CultureInfo.CurrentCulture),
@@ -48,17 +48,17 @@ namespace ResourceString.Net.Logic.Properties
             );
 
             public static IResourceString Format => LazyFormat.Value;
-            
+
             public static IResourceString From(IResourceString resourceId, IResourceString resourceManagerPropertyName, IResourceString fromMethodDefinition) => new FormattedResourceString(
-                Format, 
+                Format,
                 resourceId,
                 resourceManagerPropertyName,
                 fromMethodDefinition
             );
-    
+
-        } 
+        }
-    
+
-        internal static class ResourceFormatClassFromMethod 
+        internal static class ResourceFormatClassFromMethod
         {
             private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
                 () => new ResourceManagerString("ResourceFormatClassFromMethod", ResourceManager, CultureInfo.CurrentCulture),
@@ -66,16 +66,16 @@ namespace ResourceString.Net.Logic.Properties
             );
 
             public static IResourceString Format => LazyFormat.Value;
-            
+
             public static IResourceString From(IResourceString fromMethodSignature, IResourceString parameterNames) => new FormattedResourceString(
-                Format, 
+                Format,
                 fromMethodSignature,
                 parameterNames
             );
-    
+
-        } 
+        }
-    
+
-        internal static class ResourcesClassTemplate 
+        internal static class ResourcesClassTemplate
         {
             private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
                 () => new ResourceManagerString("ResourcesClassTemplate", ResourceManager, CultureInfo.CurrentCulture),
@@ -83,18 +83,18 @@ namespace ResourceString.Net.Logic.Properties
             );
 
             public static IResourceString Format => LazyFormat.Value;
-            
+
             public static IResourceString From(IResourceString ns, IResourceString className, IResourceString resourceManagerRegion, IResourceString resourceRegions) => new FormattedResourceString(
-                Format, 
+                Format,
                 ns,
                 className,
                 resourceManagerRegion,
                 resourceRegions
             );
-    
+
-        } 
+        }
-    
+
-        internal static class ResourceManagerMemberTemplate 
+        internal static class ResourceManagerMemberTemplate
         {
             private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
                 () => new ResourceManagerString("ResourceManagerMemberTemplate", ResourceManager, CultureInfo.CurrentCulture),
@@ -102,14 +102,15 @@ namespace ResourceString.Net.Logic.Properties
             );
 
             public static IResourceString Format => LazyFormat.Value;
-            
+
-            public static IResourceString From(IResourceString resourceManagerTypeName) => new FormattedResourceString(
+            public static IResourceString From(IResourceString className, IResourceString resourceManagerTypeName) => new FormattedResourceString(
-                Format, 
+                Format,
+                className,
                 resourceManagerTypeName
             );
-    
+
-        } 
+        }
-    
+
         #region DefaultPropertyName_ResourceManager 
 
         private static readonly Lazy<IResourceString> LazyDefaultPropertyName_ResourceManager = new Lazy<IResourceString>(
@@ -120,6 +121,6 @@ namespace ResourceString.Net.Logic.Properties
         public static IResourceString DefaultPropertyName_ResourceManager => LazyDefaultPropertyName_ResourceManager.Value;
 
         #endregion // DefaultPropertyName_ResourceManager 
-    
+
     }
-}
+}

ResourceString.Net.Logic/Properties/Resources.resx

@@ -62,10 +62,10 @@ namespace {0}
     <value>
         #region ResourceManager 
 
-        private static readonly Type _Type = typeof({0});
+        private static readonly Type _Type = typeof({1});
       
         private static readonly Lazy&lt;ResourceManager> _ResourceManager = new Lazy&lt;ResourceManager>(
-            () => new ResourceManager(_Type.FullName ?? string.Empty, _Type.Assembly),                   
+            () => new ResourceManager("{0}" ?? string.Empty, _Type.Assembly),                   
             LazyThreadSafetyMode.PublicationOnly
         );
 
@@ -73,7 +73,7 @@ namespace {0}
 
         #endregion // ResourceManager
     </value>
-    <comment>0 = ResourceManagerTypeName</comment>
+    <comment>0 = ResourceManagerTypeName, 1 = ClassName</comment>
   </data>
   <data name="DefaultPropertyName_ResourceManager">
     <value>ResourceManager</value>

ResourceString.Net/Generator.cs

@@ -36,14 +36,19 @@ public class Generator : IIncrementalGenerator
                     ? t.assembly.Name
                     : $"{t.assembly.Name}.{relativeNamespace}";
 
+                var resourceFileName = t.name;
+                var className = CodeSnippetFactory.TransformToClassName(t.name);
                 var snippet = CodeSnippetFactory.CreateResourceClassCodeSnippet(
-                    ns,
+                    CodeSnippetFactory.TransformToNamespace(ns),
-                    t.name,
+                    className,
-                    CodeSnippetFactory.CreateResourceMangerMemberCodeSnippet(t.name),
+                    CodeSnippetFactory.CreateResourceMangerMemberCodeSnippet(
+                        $"{ns}.{resourceFileName}",
+                        className
+                    ),
                     v.Resources
                 );
 
-                spc.AddSource(ns + t.name, snippet.Value);
+                spc.AddSource($"{ns}.{className}", snippet.Value);
             });
         });
     }

flake.nix

@@ -4,7 +4,7 @@
   outputs = { self, nixpkgs }:
     let
       name = "ResourceString.Net";
-      version = "0.0.2";
+      version = "0.0.3";
       supportedSystems =
         [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ];
       forAllSystems = nixpkgs.lib.genAttrs supportedSystems;