stubbfel/ResourceString.Net.Contract
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix resource class name generation -> 0.0.3

Browse Source
This commit is contained in:
stubbfel
2023-05-19 18:43:41 +00:00
parent 4c1f36e5f8
commit 2075b35f7b
9 changed files with 173 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
Readme.md
View File

@@ -3,8 +3,10 @@
## What is ResourceString.Net? ## What is ResourceString.Net?
ResourceString.Net is a powerful .NET library that allows you to work with string resources in a type-safe manner. 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. 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. 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. 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 internal static class Resources
{ {
#region ResourceManager
#region ResourceManager private static readonly Type _Type = typeof(Resources);
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 Lazy<ResourceManager> _ResourceManager = new Lazy<ResourceManager>( public static ResourceManager ResourceManager => _ResourceManager.Value;
() => new ResourceManager(_Type.FullName ?? string.Empty, _Type.Assembly),
LazyThreadSafetyMode.PublicationOnly
);
public static ResourceManager ResourceManager => _ResourceManager.Value; #endregion // ResourceManager
#endregion // ResourceManager #region Greetings
internal static class Greetings
{
private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
() => new ResourceManagerString("Greetings", ResourceManager, CultureInfo.CurrentCulture),
LazyThreadSafetyMode.PublicationOnly
);
internal static class Greetings public static IResourceString Format => LazyFormat.Value;
{
private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
() => new ResourceManagerString("Greetings", ResourceManager, CultureInfo.CurrentCulture),
LazyThreadSafetyMode.PublicationOnly
);
public static IResourceString Format => LazyFormat.Value; public static IResourceString From(IResourceString name) => new FormattedResourceString(
Format,
name
);
public static IResourceString From(IResourceString name) => new FormattedResourceString( }
Format,
name
);
} #endregion // Greetings
#region World #region World
private static readonly Lazy<IResourceString> LazyWorld = new Lazy<IResourceString>( private static readonly Lazy<IResourceString> LazyWorld = new Lazy<IResourceString>(
() => new ResourceManagerString("World", ResourceManager, CultureInfo.CurrentCulture), () => new ResourceManagerString("World", ResourceManager, CultureInfo.CurrentCulture),
LazyThreadSafetyMode.PublicationOnly LazyThreadSafetyMode.PublicationOnly
); );
public static IResourceString World => LazyWorld.Value; public static IResourceString World => LazyWorld.Value;
#endregion // World
#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 ## The ResourceString-Classes
### IResourceString ### IResourceString
@@ -212,13 +246,13 @@ You can redirect the output to a file if desired.
## Third party packages ## 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 ## Development Notes

15
ResourceString.Net.App.Console/Program.cs
View File

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

3
ResourceString.Net.Logic.Tests/LogicResourcesTests.cs
View File

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

6
ResourceString.Net.Logic.Tests/ResxFileTests.cs
View File

@@ -36,10 +36,10 @@ namespace TestNameSpace
#region ResourceManager #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>( 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 LazyThreadSafetyMode.PublicationOnly
); );
@@ -175,7 +175,7 @@ namespace TestNameSpace
Some: v => CodeSnippetFactory.CreateResourceClassCodeSnippet( Some: v => CodeSnippetFactory.CreateResourceClassCodeSnippet(
"TestNameSpace", "TestNameSpace",
"TestResourceClass", "TestResourceClass",
CodeSnippetFactory.CreateResourceMangerMemberCodeSnippet("ResourceManager"), CodeSnippetFactory.CreateResourceMangerMemberCodeSnippet("ResourceManager", "TestResourceClass"),
v.Resources v.Resources
), ),
None: () => throw new InvalidOperationException() None: () => throw new InvalidOperationException()

38
ResourceString.Net.Logic/Factories/CodeSnippetFactory.cs
View File

@@ -2,15 +2,19 @@ using ResourceString.Net.Logic.DomainObjects.Resx;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Text.RegularExpressions;
namespace ResourceString.Net.Logic.Factories; namespace ResourceString.Net.Logic.Factories;
internal static class CodeSnippetFactory internal static class CodeSnippetFactory
{ {
public static IResourceString CreateResourceMangerMemberCodeSnippet(string typeName) public static IResourceString CreateResourceMangerMemberCodeSnippet(
string resourceName,
string className)
{ {
return Properties.Resources.ResourceManagerMemberTemplate.From( 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( public static IEnumerable<IResourceString> CreateMemberCodeSnippets(
IEnumerable<Resource> resources, IEnumerable<Resource> resources,
IResourceString resourceManagerName IResourceString resourceManagerName)
)
{ {
if (resources is null) if (resources is null)
{ {
@@ -95,8 +98,7 @@ internal static class CodeSnippetFactory
string namespaceString, string namespaceString,
string resourceClassName, string resourceClassName,
IResourceString resourceManagerSnippet, IResourceString resourceManagerSnippet,
IEnumerable<IResourceString> memberSnippets IEnumerable<IResourceString> memberSnippets)
)
{ {
return Properties.Resources.ResourcesClassTemplate.From( return Properties.Resources.ResourcesClassTemplate.From(
LiteralString.Factory(namespaceString), LiteralString.Factory(namespaceString),
@@ -123,4 +125,28 @@ internal static class CodeSnippetFactory
CreateMemberCodeSnippets(resources) 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('.');
}
} }

5
ResourceString.Net.Logic/Properties/Resources.cs
View File

@@ -14,7 +14,7 @@ namespace ResourceString.Net.Logic.Properties
private static readonly Type _Type = typeof(Resources); private static readonly Type _Type = typeof(Resources);
private static readonly Lazy<ResourceManager> _ResourceManager = new Lazy<ResourceManager>( 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 LazyThreadSafetyMode.PublicationOnly
); );
@@ -103,8 +103,9 @@ namespace ResourceString.Net.Logic.Properties
public static IResourceString Format => LazyFormat.Value; 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 resourceManagerTypeName
); );

6
ResourceString.Net.Logic/Properties/Resources.resx
View File

@@ -62,10 +62,10 @@ namespace {0}
<value> <value>
#region ResourceManager #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>( 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 LazyThreadSafetyMode.PublicationOnly
); );
@@ -73,7 +73,7 @@ namespace {0}
#endregion // ResourceManager #endregion // ResourceManager
</value> </value>
<comment>0 = ResourceManagerTypeName</comment> <comment>0 = ResourceManagerTypeName, 1 = ClassName</comment>
</data> </data>
<data name="DefaultPropertyName_ResourceManager"> <data name="DefaultPropertyName_ResourceManager">
<value>ResourceManager</value> <value>ResourceManager</value>

13
ResourceString.Net/Generator.cs
View File

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

2
flake.nix
View File

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