add version 0.0.1

2023-03-12 13:31:30 +00:00
parent 433e6a2727
commit b62e34eea2
35 changed files with 1227 additions and 327 deletions
--- a/ResourceString.Net.Logic/DomainObjects/Resx/Resource.cs
+++ b/ResourceString.Net.Logic/DomainObjects/Resx/Resource.cs
@@ -12,5 +12,7 @@ internal record Resource

    public Option<string> Type { get; init;}

+    public Option<string> Comment { get; init;}
+
    public string Value { get; }
 }
--- a/ResourceString.Net.Logic/Factories/CodeSnippetFactory.cs
+++ b/ResourceString.Net.Logic/Factories/CodeSnippetFactory.cs
@@ -9,13 +9,10 @@ internal static class CodeSnippetFactory
 {
    public static IResourceString CreateResourceMangerMemberCodeSnippet(string typeName)
    {
-        var formatString = Properties.Resources.ResourceManagerMemberTemplate;
-        return new FormattableResourceString(
-            formatString,
+        return Properties.Resources.ResourceManagerMemberTemplate.From(
            LiteralString.Factory(typeName)
        );
    }
-    

    public static IEnumerable<IResourceString> CreateMemberCodeSnippets(IEnumerable<Resource> resources)
    {
@@ -35,12 +32,63 @@ internal static class CodeSnippetFactory
            return Enumerable.Empty<IResourceString>();
        }

-        var formatString = Properties.Resources.ResourceStringMembers;
-        return resources.Select(r => new FormattableResourceString(
-            formatString,
-            LiteralString.Factory(r.Name),
-            resourceManagerName
+        var stringResourses = resources.Where(r => r.Type.Match(
+            v => typeof(string).IsAssignableFrom(Type.GetType(v.Trim(), false, true)),
+            () => true
        ));
+
+        return stringResourses.Select(r =>
+        {
+            var openBraces = r.Value
+                .Replace("{{", string.Empty)
+                .Replace("{{", string.Empty)
+                .Split('{')
+                .Skip(1)
+                .ToArray();
+
+            if (openBraces.Any())
+            {
+                var formatNames = new System.Collections.Generic.HashSet<string>(
+                    openBraces.Select(b => b.Split('}').First())
+                );
+
+                var resolveParameterNames = r.Comment.Match(
+                    c => c.Split(',')
+                        .Select(str => str.Split('='))
+                        .Where(parts => parts.Count() == 2)
+                        .Select(parts => (
+                            parts.First().Trim().Trim('{', '}').Split(' ').First(),
+                            parts.Last().Trim().Split(' ').First()
+                        )).Where(t => uint.TryParse(t.Item1, out var _))
+                        .GroupBy(t => t.Item1)
+                        .ToDictionary(k => k.Key, v => v.First().Item2),
+                    () => new Dictionary<string, string>()
+                );
+
+                var parameterNames = formatNames.Select(
+                    n => resolveParameterNames.TryGetValue(n.Trim(), out var paramName)
+                        ? paramName.Substring(0, 1).ToLower() + paramName.Substring(1)
+                        : uint.TryParse(n, out var value) ? $"p{value + 1}" : n
+                ).ToArray();
+
+                var from = Properties.Resources.ResourceFormatClassFromMethod.From(
+                    new JoinedResourceString(
+                        LiteralString.Factory(", "),
+                        parameterNames.Select(n => LiteralString.Factory($"{nameof(IResourceString)} {n}")).ToArray()
+                    ),
+                    new JoinedResourceString(
+                        LiteralString.Factory($",{System.Environment.NewLine}                "),
+                        parameterNames.Select(n => LiteralString.Factory($"{n}")).ToArray()
+                    )
+                );
+                return Properties.Resources.ResourceFormatClassMembers.From(
+                    LiteralString.Factory(r.Name), resourceManagerName, from
+                );
+            }
+            return Properties.Resources.ResourceStringMembers.From(
+                LiteralString.Factory(r.Name), resourceManagerName
+            );
+        });
    }

    public static IResourceString CreateResourceClassCodeSnippet(
@@ -50,11 +98,9 @@ internal static class CodeSnippetFactory
        IEnumerable<IResourceString> memberSnippets
        )
    {
-        var formatString = Properties.Resources.ResourcesClassTemplate;
-        return new FormattableResourceString(
-            formatString,
+        return Properties.Resources.ResourcesClassTemplate.From(
            LiteralString.Factory(namespaceString),
-            LiteralString.Factory(resourceClassName),    
+            LiteralString.Factory(resourceClassName),
            resourceManagerSnippet,
            new JoinedResourceString(
                LiteralString.Empty,
@@ -63,12 +109,12 @@ internal static class CodeSnippetFactory
        );
    }

-     public static IResourceString CreateResourceClassCodeSnippet(
-        string namespaceString,
-        string resourceClassName,
-        IResourceString resourceManagerSnippet,
-        IEnumerable<Resource> resources
-        )
+    public static IResourceString CreateResourceClassCodeSnippet(
+       string namespaceString,
+       string resourceClassName,
+       IResourceString resourceManagerSnippet,
+       IEnumerable<Resource> resources
+       )
    {
        return CreateResourceClassCodeSnippet(
            namespaceString,
--- a/ResourceString.Net.Logic/Parsers/Resx/Parser.cs
+++ b/ResourceString.Net.Logic/Parsers/Resx/Parser.cs
@@ -23,11 +23,17 @@ internal static class Parser
        {
            var name = i.GetAttribute("name");
            var type = i.GetAttribute("type");
-            var value = i.SelectSingleNode("descendant::value")?.InnerXml;
+            var comment = i.SelectSingleNode("descendant::comment")?.InnerXml ?? string.Empty;
+            var value = i.SelectSingleNode("descendant::value")?.InnerXml ?? string.Empty;

-            return new Resource(name, value ?? string.Empty)
+            return new Resource(name, value)
            {
-                Type = type
+                Type = string.IsNullOrWhiteSpace(type)
+                    ? Option<string>.None
+                    : Option<string>.Some(type),
+                Comment = string.IsNullOrWhiteSpace(comment)
+                    ? Option<string>.None
+                    : Option<string>.Some(comment)
            };
        }).ToArray();

--- a/ResourceString.Net.Logic/Properties/Resources.cs
+++ b/ResourceString.Net.Logic/Properties/Resources.cs
@@ -1,3 +1,4 @@
+using ResourceString.Net.Contract;
 using System;
 using System.Globalization;
 using System.Resources;
@@ -7,52 +8,108 @@ namespace ResourceString.Net.Logic.Properties
 {
    internal static class Resources
    {
+
        #region ResourceManager 

        private static readonly Type _Type = typeof(Resources);
      
        private static readonly Lazy<ResourceManager> _ResourceManager = new Lazy<ResourceManager>(
-            () => new ResourceManager(_Type.FullName, _Type.Assembly),                   
+            () => new ResourceManager(_Type.FullName ?? string.Empty, _Type.Assembly),                   
            LazyThreadSafetyMode.PublicationOnly
        );

        public static ResourceManager ResourceManager => _ResourceManager.Value;

        #endregion // ResourceManager
+    

-        #region ResourceStringMembers 
+        internal static class ResourceStringMembers 
+        {
+            private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
+                () => new ResourceManagerString("ResourceStringMembers", ResourceManager, CultureInfo.CurrentCulture),
+                LazyThreadSafetyMode.PublicationOnly
+            );

-        private static readonly Lazy<IResourceString> LazyResourceStringMembers = new Lazy<IResourceString>(
-            () => new ResourceManagerString("ResourceStringMembers", ResourceManager, CultureInfo.CurrentCulture),
-            LazyThreadSafetyMode.PublicationOnly
-        );
+            public static IResourceString Format => LazyFormat.Value;
+            
+            public static IResourceString From(IResourceString resourceId, IResourceString resourceManagerPropertyName) => new FormattedResourceString(
+                Format, 
+                resourceId,
+                resourceManagerPropertyName
+            );
+    
+        } 
+    
+        internal static class ResourceFormatClassMembers 
+        {
+            private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
+                () => new ResourceManagerString("ResourceFormatClassMembers", ResourceManager, CultureInfo.CurrentCulture),
+                LazyThreadSafetyMode.PublicationOnly
+            );

-        public static IResourceString ResourceStringMembers => LazyResourceStringMembers.Value;
+            public static IResourceString Format => LazyFormat.Value;
+            
+            public static IResourceString From(IResourceString resourceId, IResourceString resourceManagerPropertyName, IResourceString fromMethodDefinition) => new FormattedResourceString(
+                Format, 
+                resourceId,
+                resourceManagerPropertyName,
+                fromMethodDefinition
+            );
+    
+        } 
+    
+        internal static class ResourceFormatClassFromMethod 
+        {
+            private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
+                () => new ResourceManagerString("ResourceFormatClassFromMethod", ResourceManager, CultureInfo.CurrentCulture),
+                LazyThreadSafetyMode.PublicationOnly
+            );

-        #endregion // ResourceStringMembers 
+            public static IResourceString Format => LazyFormat.Value;
+            
+            public static IResourceString From(IResourceString fromMethodSignature, IResourceString parameterNames) => new FormattedResourceString(
+                Format, 
+                fromMethodSignature,
+                parameterNames
+            );
+    
+        } 
+    
+        internal static class ResourcesClassTemplate 
+        {
+            private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
+                () => new ResourceManagerString("ResourcesClassTemplate", ResourceManager, CultureInfo.CurrentCulture),
+                LazyThreadSafetyMode.PublicationOnly
+            );

-        #region ResourceManagerMemberTemplate 
-
-        private static readonly Lazy<IResourceString> LazyResourceManagerMemberTemplate = new Lazy<IResourceString>(
-            () => new ResourceManagerString("ResourceManagerMemberTemplate", ResourceManager, CultureInfo.CurrentCulture),
-            LazyThreadSafetyMode.PublicationOnly
-        );
-
-        public static IResourceString ResourceManagerMemberTemplate => LazyResourceManagerMemberTemplate.Value;
-
-        #endregion // ResourceManagerMemberTemplate 
-
-        #region ResourcesClassTemplate 
-
-        private static readonly Lazy<IResourceString> LazyResourcesClassTemplate = new Lazy<IResourceString>(
-            () => new ResourceManagerString("ResourcesClassTemplate", ResourceManager, CultureInfo.CurrentCulture),
-            LazyThreadSafetyMode.PublicationOnly
-        );
-
-        public static IResourceString ResourcesClassTemplate => LazyResourcesClassTemplate.Value;
-
-        #endregion // ResourcesClassTemplate 
+            public static IResourceString Format => LazyFormat.Value;
+            
+            public static IResourceString From(IResourceString ns, IResourceString className, IResourceString resourceManagerRegion, IResourceString resourceRegions) => new FormattedResourceString(
+                Format, 
+                ns,
+                className,
+                resourceManagerRegion,
+                resourceRegions
+            );
+    
+        } 
+    
+        internal static class ResourceManagerMemberTemplate 
+        {
+            private static readonly Lazy<IResourceString> LazyFormat = new Lazy<IResourceString>(
+                () => new ResourceManagerString("ResourceManagerMemberTemplate", ResourceManager, CultureInfo.CurrentCulture),
+                LazyThreadSafetyMode.PublicationOnly
+            );

+            public static IResourceString Format => LazyFormat.Value;
+            
+            public static IResourceString From(IResourceString resourceManagerTypeName) => new FormattedResourceString(
+                Format, 
+                resourceManagerTypeName
+            );
+    
+        } 
+    
        #region DefaultPropertyName_ResourceManager 

        private static readonly Lazy<IResourceString> LazyDefaultPropertyName_ResourceManager = new Lazy<IResourceString>(
@@ -63,5 +120,6 @@ namespace ResourceString.Net.Logic.Properties
        public static IResourceString DefaultPropertyName_ResourceManager => LazyDefaultPropertyName_ResourceManager.Value;

        #endregion // DefaultPropertyName_ResourceManager 
+    
    }
 }
--- a/ResourceString.Net.Logic/Properties/Resources.resx
+++ b/ResourceString.Net.Logic/Properties/Resources.resx
@@ -13,6 +13,31 @@

        #endregion // {0} 
    </value>
+    <comment>0 = ResourceId, 1 = ResourceManagerPropertyName</comment>
+  </data>
+  <data name="ResourceFormatClassMembers" xml:space="preserve">
+    <value>
+        internal static class {0} 
+        {{
+            private static readonly Lazy&lt;IResourceString> LazyFormat = new Lazy&lt;IResourceString>(
+                () => new ResourceManagerString("{0}", {1}, CultureInfo.CurrentCulture),
+                LazyThreadSafetyMode.PublicationOnly
+            );
+
+            public static IResourceString Format => LazyFormat.Value;
+            {2}
+        }} 
+    </value>
+    <comment>0 = ResourceId, 1 = ResourceManagerPropertyName, 2 = FromMethodDefinition</comment>
+  </data>
+  <data name="ResourceFormatClassFromMethod" xml:space="preserve">
+    <value>
+            public static IResourceString From({0}) => new FormattedResourceString(
+                Format, 
+                {1}
+            );
+    </value>
+    <comment>0 = FromMethodSignature, 1 = ParameterNames</comment>
  </data>
  <data name="ResourcesClassTemplate" xml:space="preserve">
    <value>
@@ -31,6 +56,7 @@ namespace {0}
    }}
 }}
    </value>
+    <comment>0 = ns, 1 = ClassName, 2 = ResourceManagerRegion, 3 = ResourceRegions</comment>
  </data>
  <data name="ResourceManagerMemberTemplate" xml:space="preserve">
    <value>
@@ -39,7 +65,7 @@ namespace {0}
        private static readonly Type _Type = typeof({0});
      
        private static readonly Lazy&lt;ResourceManager> _ResourceManager = new Lazy&lt;ResourceManager>(
-            () => new ResourceManager(_Type.FullName, _Type.Assembly),                   
+            () => new ResourceManager(_Type.FullName ?? string.Empty, _Type.Assembly),                   
            LazyThreadSafetyMode.PublicationOnly
        );

@@ -47,6 +73,7 @@ namespace {0}

        #endregion // ResourceManager
    </value>
+    <comment>0 = ResourceManagerTypeName</comment>
  </data>
  <data name="DefaultPropertyName_ResourceManager">
    <value>ResourceManager</value>
--- a/ResourceString.Net.Logic/ResourceString.Net.Logic.csproj
+++ b/ResourceString.Net.Logic/ResourceString.Net.Logic.csproj
@@ -7,7 +7,7 @@
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="LanguageExt.Core" Version="4.4.2" />
+    <PackageReference Include="LanguageExt.Core" Version="4.4.3" />
    <PackageReference Include="System.Resources.Extensions" Version="7.0.0" />
  </ItemGroup>

@@ -19,5 +19,11 @@
    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
      <_Parameter1>$(MSBuildProjectName).Tests</_Parameter1>
    </AssemblyAttribute>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+      <_Parameter1>ResourceString.Net.App.Console</_Parameter1>
+    </AssemblyAttribute>
+    <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
+      <_Parameter1>ResourceString.Net</_Parameter1>
+    </AssemblyAttribute>
  </ItemGroup>
 </Project>