Work In Progress Adding Support For Resx

I am refactoring the areas that parse json to use interfaces to perform all relevant operations so that it makes working with multiple file types easier since we use DI to solve file types instead of have every class know about file types!!

src/Mocale.Providers.Azure.Blob/Abstractions/IBlobStorageConfig.cs

@@ -1,7 +1,6 @@
-using Mocale.Enums;
 namespace Mocale.Providers.Azure.Blob.Abstractions;
 
-public interface IBlobStorageConfig
+public interface IBlobStorageConfig : IExternalConfiguration
 {
     /// <summary>
     /// Uri for the blob container
@@ -21,14 +20,4 @@ public interface IBlobStorageConfig
     /// will require an extra api call but reduce exception noise.
     /// </summary>
     bool CheckForFile { get; }
-
-    /// <summary>
-    /// Folder prefix for the bloc container, this will be added to the blob
-    /// </summary>
-    string? VersionPrefix { get; }
-
-    /// <summary>
-    /// The type of file stored externally
-    /// </summary>
-    LocaleResourceType FileType { get; }
 }

src/Mocale.Providers.Azure.Blob/MocaleBuilderExtension.cs

@@ -1,4 +1,3 @@
-using Mocale.Abstractions;
 using Mocale.Exceptions;
 using Mocale.Managers;
 using Mocale.Providers.Azure.Blob.Managers;
@@ -18,9 +17,11 @@ public static MocaleBuilder UseBlobStorage(this MocaleBuilder builder, Action<Bl
             throw new InitializationException("You must set a blob container uri to use this provider");
         }
 
-        var configurationManager = new ConfigurationManager<IBlobStorageConfig>(config);
+        builder.RegisterExternalResourceFileTypeResources(config);
 
-        builder.AppBuilder.Services.AddSingleton<IConfigurationManager<IBlobStorageConfig>>(configurationManager);
+        // TODO: Is there a way I can avoid having 2 of the same config managers?
+        builder.AppBuilder.Services.AddSingleton<IConfigurationManager<IBlobStorageConfig>>(new ConfigurationManager<IBlobStorageConfig>(config));
+        builder.AppBuilder.Services.AddSingleton<IConfigurationManager<IExternalConfiguration>>(new ConfigurationManager<IExternalConfiguration>(config));
         builder.AppBuilder.Services.AddSingleton<IExternalLocalizationProvider, BlobLocalizationProvider>();
         builder.AppBuilder.Services.AddSingleton<IBlobResourceLocator, BlobResourceLocator>();
 

src/Mocale.Providers.Azure.Blob/Models/BlobStorageConfig.cs

@@ -17,5 +17,5 @@ public class BlobStorageConfig : IBlobStorageConfig
     public string? VersionPrefix { get; set; }
 
     /// <inheritdoc/>
-    public LocaleResourceType FileType { get; set; } = LocaleResourceType.Json;
+    public LocaleResourceType ResourceType { get; set; } = LocaleResourceType.Json;
 }

src/Mocale.Providers.GitHub.Raw/Abstractions/IGithubRawConfig.cs

@@ -1,6 +1,6 @@
 namespace Mocale.Providers.GitHub.Raw.Abstractions;
 
-public interface IGithubRawConfig
+public interface IGithubRawConfig : IExternalConfiguration
 {
     string Username { get; }
 

src/Mocale.Providers.GitHub.Raw/GitHubRawProvider.cs

@@ -1,9 +1,5 @@
-using System;
-using System.Collections.Generic;
 using System.Globalization;
-using System.Net.Http;
 using System.Text.Json;
-using System.Threading.Tasks;
 using Ardalis.GuardClauses;
 using Mocale.Helper;
 using Mocale.Providers.GitHub.Raw.Helpers;
@@ -14,6 +10,8 @@ internal class GitHubRawProvider : IExternalLocalizationProvider
     #region Fields
 
     private readonly IGithubRawConfig githubConfig;
+    private readonly IExternalFileNameHelper externalFileNameHelper;
+    private readonly ILocalizationParser localizationParser;
     private readonly ILogger logger;
 
     private readonly HttpClient httpClient;
@@ -24,21 +22,25 @@ internal class GitHubRawProvider : IExternalLocalizationProvider
 
     public GitHubRawProvider(
         IConfigurationManager<IGithubRawConfig> githubConfigurationManager,
+        IExternalFileNameHelper externalFileNameHelper,
         HttpClient httpClient,
+        ILocalizationParser localizationParser,
         ILogger<GitHubRawProvider> logger)
     {
         githubConfigurationManager = Guard.Against.Null(githubConfigurationManager, nameof(githubConfigurationManager));
 
         this.githubConfig = githubConfigurationManager.Configuration;
+        this.externalFileNameHelper = Guard.Against.Null(externalFileNameHelper, nameof(externalFileNameHelper));
         this.httpClient = Guard.Against.Null(httpClient, nameof(httpClient));
+        this.localizationParser = Guard.Against.Null(localizationParser, nameof(localizationParser));
         this.logger = Guard.Against.Null(logger, nameof(logger));
     }
 
     #endregion Constructors
 
     private Uri GetResourceUrl(CultureInfo cultureInfo)
     {
-        var fileName = ExternalResourceHelper.GetExpectedJsonFileName(cultureInfo, null);
+        var fileName = externalFileNameHelper.GetExpectedFileName(cultureInfo);
 
         return RawUrlBuilder.BuildResourceUrl(githubConfig.Username, githubConfig.Repository, githubConfig.Branch, githubConfig.LocaleDirectory, fileName);
     }

src/Mocale.Providers.GitHub.Raw/MocaleBuilderExtension.cs

@@ -11,9 +11,11 @@ public static MocaleBuilder UseGitHubRaw(this MocaleBuilder builder, Action<Gith
         var config = new GithubRawConfig();
         configureGithub(config);
 
-        var configurationManager = new ConfigurationManager<IGithubRawConfig>(config);
+        builder.RegisterExternalResourceFileTypeResources(config);
 
-        builder.AppBuilder.Services.AddSingleton<IConfigurationManager<IGithubRawConfig>>(configurationManager);
+        // TODO: Is there a way I can avoid having 2 of the same config managers?
+        builder.AppBuilder.Services.AddSingleton<IConfigurationManager<IGithubRawConfig>>(new ConfigurationManager<IGithubRawConfig>(config));
+        builder.AppBuilder.Services.AddSingleton<IConfigurationManager<IExternalConfiguration>>(new ConfigurationManager<IExternalConfiguration>(config));
         builder.AppBuilder.Services.AddSingleton<IExternalLocalizationProvider, GitHubRawProvider>();
 
         if (configureHttpClient is not null)

src/Mocale.Providers.GitHub.Raw/Models/GithubRawConfig.cs

@@ -1,3 +1,4 @@
+using Mocale.Enums;
 using Mocale.Providers.GitHub.Raw.Abstractions;
 namespace Mocale.Providers.GitHub.Raw.Models;
 
@@ -10,4 +11,8 @@ public class GithubRawConfig : IGithubRawConfig
     public string Branch { get; set; } = "main";
 
     public string LocaleDirectory { get; set; } = string.Empty;
+
+    public LocaleResourceType ResourceType { get; set; } = LocaleResourceType.Json;
+
+    public string? VersionPrefix { get; set; }
 }

src/Mocale/Abstractions/IExternalConfiguration.cs

@@ -0,0 +1,14 @@
+namespace Mocale.Abstractions;
+
+public interface IExternalConfiguration
+{
+    /// <summary>
+    /// The type of file being stored externally
+    /// </summary>
+    LocaleResourceType ResourceType { get; }
+
+    /// <summary>
+    /// The version prefix of the files, this will be prepended after the url & before the file name
+    /// </summary>
+    string? VersionPrefix { get; }
+}

src/Mocale/Abstractions/IExternalFileNameHelper.cs

@@ -0,0 +1,8 @@
+using System.Globalization;
+
+namespace Mocale.Abstractions;
+
+internal interface IExternalFileNameHelper
+{
+    string GetExpectedFileName(CultureInfo culture);
+}

src/Mocale/Abstractions/ILocalizationParser.cs

@@ -1,8 +1,10 @@
+using System.Resources;
+
 namespace Mocale.Abstractions;
 
 internal interface ILocalizationParser
 {
-    Dictionary<string, string> ParseLocalizationString(string resourceString);
+    Dictionary<string, string>? ParseLocalizationString(string resourceString);
 
-    Dictionary<string, string> ParseLocalizationStream(Stream resourceStream);
+    Dictionary<string, string>? ParseLocalizationStream(Stream resourceStream);
 }

src/Mocale/Abstractions/IVersionPrefixHelper.cs

@@ -0,0 +1,6 @@
+namespace Mocale.Abstractions;
+
+internal interface IVersionPrefixHelper
+{
+    string ApplyVersionPrefix(string fileName);
+}

src/Mocale/AppBuilderExtensions.cs

@@ -1,4 +1,5 @@
 using Mocale.Exceptions;
+using Mocale.Helper;
 using Mocale.Managers;
 using Mocale.Wrappers;
 namespace Mocale;
@@ -33,6 +34,7 @@ public static MauiAppBuilder UseMocale(
         mauiAppBuilder.Services.AddSingleton<IMauiInitializeService, MocaleInitializeService>();
         mauiAppBuilder.Services.AddSingleton<ITranslationResolver, TranslationResolver>();
         mauiAppBuilder.Services.AddSingleton<ICurrentCultureManager, CurrentCultureManager>();
+        mauiAppBuilder.Services.AddSingleton<IVersionPrefixHelper, VersionPrefixHelper>();
 
         // https://andrewlock.net/how-to-register-a-service-with-multiple-interfaces-for-in-asp-net-core-di/
         mauiAppBuilder.Services.AddSingleton<TranslatorManager>();

src/Mocale/Helper/ExternalJsonFileNameHelper.cs

@@ -0,0 +1,21 @@
+using System.Globalization;
+using Ardalis.GuardClauses;
+
+namespace Mocale.Helper;
+
+internal class ExternalJsonFileNameHelper : IExternalFileNameHelper
+{
+    private readonly IVersionPrefixHelper versionPrefixHelper;
+
+    public ExternalJsonFileNameHelper(IVersionPrefixHelper versionPrefixHelper)
+    {
+        this.versionPrefixHelper = Guard.Against.Null(versionPrefixHelper, nameof(versionPrefixHelper));
+    }
+
+    public string GetExpectedFileName(CultureInfo culture)
+    {
+        var fileName = $"{culture.Name}.json";
+
+        return versionPrefixHelper.ApplyVersionPrefix(fileName);
+    }
+}

src/Mocale/Helper/ExternalResourceHelper.cs

@@ -15,15 +15,15 @@ public static string GetExpectedJsonFileName(CultureInfo cultureInfo, string? ve
         return string.Join("/", versionPrefix, fileName);
     }
 
-    //public static string GetExpectedResxFileName(CultureInfo cultureInfo, string resourceFileName, string? versionPrefix)
-    //{
-    //    var fileName = $"{resourceFileName}.{cultureInfo.Name}.resx";
+    public static string GetExpectedResxFileName(CultureInfo cultureInfo, string? versionPrefix)
+    {
+        var fileName = $"{cultureInfo.Name}.resx";
 
-    //    if (versionPrefix is null || string.IsNullOrEmpty(versionPrefix))
-    //    {
-    //        return fileName;
-    //    }
+        if (versionPrefix is null || string.IsNullOrEmpty(versionPrefix))
+        {
+            return fileName;
+        }
 
-    //    return string.Join("/", versionPrefix, fileName);
-    //}
+        return string.Join("/", versionPrefix, fileName);
+    }
 }

src/Mocale/Helper/ExternalResxFileNameHelper.cs

@@ -0,0 +1,20 @@
+using System.Globalization;
+using Ardalis.GuardClauses;
+
+namespace Mocale.Helper;
+internal class ExternalResxFileNameHelper : IExternalFileNameHelper
+{
+    private readonly IVersionPrefixHelper versionPrefixHelper;
+
+    public ExternalResxFileNameHelper(IVersionPrefixHelper versionPrefixHelper)
+    {
+        this.versionPrefixHelper = Guard.Against.Null(versionPrefixHelper, nameof(versionPrefixHelper));
+    }
+
+    public string GetExpectedFileName(CultureInfo culture)
+    {
+        var fileName = $"{culture.Name}.resx";
+
+        return versionPrefixHelper.ApplyVersionPrefix(fileName);
+    }
+}

src/Mocale/Helper/VersionPrefixHelper.cs

@@ -0,0 +1,24 @@
+using Ardalis.GuardClauses;
+
+namespace Mocale.Helper;
+internal class VersionPrefixHelper : IVersionPrefixHelper
+{
+    private readonly IExternalConfiguration externalConfiguration;
+
+    public VersionPrefixHelper(IConfigurationManager<IExternalConfiguration> externalConfigurationManager)
+    {
+        externalConfigurationManager = Guard.Against.Null(externalConfigurationManager, nameof(externalConfigurationManager));
+
+        this.externalConfiguration = externalConfigurationManager.Configuration;
+    }
+
+    public string ApplyVersionPrefix(string fileName)
+    {
+        if (string.IsNullOrEmpty(externalConfiguration.VersionPrefix))
+        {
+            return fileName;
+        }
+
+        return string.Join("/", externalConfiguration.VersionPrefix, fileName);
+    }
+}

src/Mocale/Mocale.csproj

@@ -26,11 +26,11 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <InternalsVisibleTo Include="$(AssemblyName).Providers.AWS.S3"/>
-    <InternalsVisibleTo Include="$(AssemblyName).Providers.Azure.Blob"/>
-    <InternalsVisibleTo Include="$(AssemblyName).Providers.GitHub.Raw"/>
-    <InternalsVisibleTo Include="$(AssemblyName).Cache.SQLite"/>
-    <InternalsVisibleTo Include="$(AssemblyName).UnitTests"/>
+    <InternalsVisibleTo Include="$(AssemblyName).Providers.AWS.S3" />
+    <InternalsVisibleTo Include="$(AssemblyName).Providers.Azure.Blob" />
+    <InternalsVisibleTo Include="$(AssemblyName).Providers.GitHub.Raw" />
+    <InternalsVisibleTo Include="$(AssemblyName).Cache.SQLite" />
+    <InternalsVisibleTo Include="$(AssemblyName).UnitTests" />
   </ItemGroup>
 
 </Project>

src/Mocale/MocaleBuilderExtensions.cs

@@ -1,5 +1,7 @@
 using Mocale.Exceptions;
+using Mocale.Helper;
 using Mocale.Managers;
+using Mocale.Parsers;
 using Mocale.Providers;
 namespace Mocale;
 
@@ -70,4 +72,29 @@ internal static void RegisterExternalProvider(this MocaleBuilder builder, Type p
         builder.ExternalProviderRegistered = true;
         builder.ExternalProviderName = provider.Name;
     }
+
+    internal static void RegisterExternalResourceFileTypeResources(this MocaleBuilder builder, IExternalConfiguration externalConfiguration)
+    {
+        switch (externalConfiguration.ResourceType)
+        {
+            case LocaleResourceType.Json:
+            {
+                builder.AppBuilder.Services.AddSingleton<IExternalFileNameHelper, ExternalJsonFileNameHelper>();
+                builder.AppBuilder.Services.AddSingleton<ILocalizationParser, JsonLocalizationParser>();
+                break;
+            }
+
+            case LocaleResourceType.Resx:
+            {
+                builder.AppBuilder.Services.AddSingleton<IExternalFileNameHelper, ExternalResxFileNameHelper>();
+                builder.AppBuilder.Services.AddSingleton<ILocalizationParser, ResxLocalizationParser>();
+                break;
+            }
+
+            default:
+            {
+                throw new NotSupportedException($"Invalid value for {nameof(LocaleResourceType)}");
+            }
+        }
+    }
 }

src/Mocale/Parsers/JsonLocalizationParser.cs

@@ -0,0 +1,15 @@
+namespace Mocale.Parsers;
+
+internal class JsonLocalizationParser : ILocalizationParser
+{
+    public Dictionary<string, string>? ParseLocalizationStream(Stream resourceStream)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Dictionary<string, string>? ParseLocalizationString(string resourceString)
+    {
+        throw new NotImplementedException();
+    }
+}
+

src/Mocale/Parsers/ResxLocalizationParser.cs

@@ -0,0 +1,21 @@
+using System.Resources;
+
+namespace Mocale.Parsers;
+internal class ResxLocalizationParser : ILocalizationParser
+{
+    public Dictionary<string, string>? ParseLocalizationStream(Stream resourceStream)
+    {
+        var reader = new ResourceReader(resourceStream);
+
+        //return resourceSet.Cast<DictionaryEntry>().ToDictionary(r => r.Key.ToString(), r => r.Value.ToString())
+        //    ?? new Dictionary<string, string>();
+
+        throw new NotImplementedException();
+    }
+
+    public Dictionary<string, string>? ParseLocalizationString(string resourceString)
+    {
+        throw new NotImplementedException();
+    }
+}
+

src/Mocale/Providers/EmbeddedResourceProvider.cs

@@ -1,7 +1,6 @@
 using System.Globalization;
 using System.Reflection;
 using System.Text.Json;
-using Microsoft.Extensions.Logging;
 namespace Mocale.Providers;
 
 internal class EmbeddedResourceProvider : IInternalLocalizationProvider