feat : auto-generate manifest.json by CI

.github/workflows/manifest.yml

@@ -0,0 +1,42 @@
+name: Generate Manifest
+
+on:
+  push:
+    branches: [ main ]
+    paths:
+      - 'Translator/translations/**/*.json'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  manifest-generation:
+    runs-on: ubuntu-latest
+    env:
+      CI: true
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup .NET 10
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 10.0.x
+
+      - name: Build solution
+        run: dotnet build --configuration Release
+
+      - name: Generate manifest.json
+        run: dotnet run -- generate-manifest
+        working-directory: Translator
+
+      - name: Commit
+        uses: EndBug/add-and-commit@v10
+        with:
+          default_author: github_actor
+          add: ./manifest.json # if the working directory is the repo root dir
+          message: "Update manifest.json"
+          commit: ""
+          push: true

Translator.Tests/Services/ManifestGeneratorTests.cs

@@ -0,0 +1,315 @@
+using System.Security.Cryptography;
+using System.Text.Json;
+using BTCPayTranslator.Models;
+using BTCPayTranslator.Services;
+using Microsoft.Extensions.Logging.Abstractions;
+using Xunit;
+
+namespace BTCPayTranslator.Tests.Services;
+
+public class ManifestGeneratorTests
+{
+    [Fact]
+    public async Task GenerateManifest_WritesManifest_ForValidTranslationFile()
+    {
+        var tempDir = CreateTempDirectory();
+        var translationsDir = Path.Combine(tempDir, "translations");
+        Directory.CreateDirectory(translationsDir);
+        var translationFile = Path.Combine(translationsDir, "French.json");
+        var manifestPath = Path.Combine(tempDir, "manifest.json");
+
+        try
+        {
+            await File.WriteAllTextAsync(translationFile, """
+                {
+                  "_maintainer": "alice|https://github.com/alice",
+                  "hello": "bonjour"
+                }
+                """);
+
+            var sut = CreateSut();
+            var result = await sut.GenerateManifest(translationsDir, manifestPath);
+
+            Assert.True(result);
+            Assert.True(File.Exists(manifestPath));
+
+            var manifest = await ReadManifest(manifestPath);
+            var entry = Assert.Single(manifest.Languages);
+
+            Assert.Equal("fr", entry.Code);
+            Assert.Equal("fr-FR", entry.Bcp47);
+            Assert.Equal("French", entry.Name);
+            Assert.Equal("Français", entry.Native);
+            Assert.Equal("translations/French.json", entry.File);
+            Assert.Equal("alice|https://github.com/alice", entry.Maintainer);
+            Assert.Equal(ComputeSha256(translationFile), entry.Sha);
+            Assert.Matches("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$", entry.Updated);
+        }
+        finally
+        {
+            if (Directory.Exists(tempDir))
+            {
+                Directory.Delete(tempDir, recursive: true);
+            }
+        }
+    }
+
+    [Fact]
+    public async Task GenerateManifest_ReturnsFalse_WhenNoTranslationFilesExist()
+    {
+        var tempDir = CreateTempDirectory();
+        var manifestPath = Path.Combine(tempDir, "manifest.json");
+
+        try
+        {
+            var sut = CreateSut();
+
+            var result = await sut.GenerateManifest(tempDir, manifestPath);
+
+            Assert.False(result);
+            Assert.False(File.Exists(manifestPath));
+        }
+        finally
+        {
+            if (Directory.Exists(tempDir))
+            {
+                Directory.Delete(tempDir, recursive: true);
+            }
+        }
+    }
+
+    [Fact]
+    public async Task GenerateManifest_ReturnsFalse_WhenTranslationDirectoryDoesNotExist()
+    {
+        var translationsDir = Path.Combine(Path.GetTempPath(), "BTCPayTranslator.Tests", Guid.NewGuid().ToString("N"));
+        var manifestPath = Path.Combine(Path.GetTempPath(), "BTCPayTranslator.Tests", Guid.NewGuid().ToString("N"), "manifest.json");
+        var sut = CreateSut();
+
+        var result = await sut.GenerateManifest(translationsDir, manifestPath);
+
+        Assert.False(result);
+    }
+
+    [Fact]
+    public async Task GenerateManifest_RetainsUpdated_WhenExistingShaMatches()
+    {
+        var tempDir = CreateTempDirectory();
+        var translationsDir = Path.Combine(tempDir, "translations");
+        Directory.CreateDirectory(translationsDir);
+        var translationFile = Path.Combine(translationsDir, "French.json");
+        var manifestPath = Path.Combine(tempDir, "manifest.json");
+
+        try
+        {
+            await File.WriteAllTextAsync(translationFile, """
+                {
+                  "_maintainer": "alice|https://github.com/alice",
+                  "hello": "bonjour"
+                }
+                """);
+
+            var existingSha = ComputeSha256(translationFile);
+            var expectedUpdated = "2024-01-02T03:04:05Z";
+            var existingManifest = new Manifest(
+                new List<ManifestEntry>
+                {
+                    new(
+                        Code: "fr",
+                        Bcp47: "fr-FR",
+                        Name: "French",
+                        Native: "Français",
+                        File: "translations/French.json",
+                        Sha: existingSha,
+                        Maintainer: "old",
+                        Updated: expectedUpdated)
+                },
+                Redirect: null);
+
+            await File.WriteAllTextAsync(manifestPath, JsonSerializer.Serialize(existingManifest));
+
+            var sut = CreateSut();
+            var result = await sut.GenerateManifest(translationsDir, manifestPath);
+
+            Assert.True(result);
+            var generated = await ReadManifest(manifestPath);
+            var entry = Assert.Single(generated.Languages);
+            Assert.Equal(expectedUpdated, entry.Updated);
+        }
+        finally
+        {
+            if (Directory.Exists(tempDir))
+            {
+                Directory.Delete(tempDir, recursive: true);
+            }
+        }
+    }
+
+    [Fact]
+    public async Task GenerateManifest_UpdatesUpdated_WhenExistingShaDiffers()
+    {
+        var tempDir = CreateTempDirectory();
+        var translationsDir = Path.Combine(tempDir, "translations");
+        Directory.CreateDirectory(translationsDir);
+        var translationFile = Path.Combine(translationsDir, "French.json");
+        var manifestPath = Path.Combine(tempDir, "manifest.json");
+
+        try
+        {
+            await File.WriteAllTextAsync(translationFile, """
+                {
+                  "_maintainer": "alice|https://github.com/alice",
+                  "hello": "bonjour"
+                }
+                """);
+
+            var previousUpdated = "2024-01-02T03:04:05Z";
+            var existingManifest = new Manifest(
+                new List<ManifestEntry>
+                {
+                    new(
+                        Code: "fr",
+                        Bcp47: "fr-FR",
+                        Name: "French",
+                        Native: "Français",
+                        File: "translations/French.json",
+                        Sha: "deadbeef",
+                        Maintainer: "old",
+                        Updated: previousUpdated)
+                },
+                Redirect: null);
+
+            await File.WriteAllTextAsync(manifestPath, JsonSerializer.Serialize(existingManifest));
+
+            var sut = CreateSut();
+            var result = await sut.GenerateManifest(translationsDir, manifestPath);
+
+            Assert.True(result);
+            var generated = await ReadManifest(manifestPath);
+            var entry = Assert.Single(generated.Languages);
+
+            Assert.NotEqual(previousUpdated, entry.Updated);
+            Assert.Matches("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$", entry.Updated);
+        }
+        finally
+        {
+            if (Directory.Exists(tempDir))
+            {
+                Directory.Delete(tempDir, recursive: true);
+            }
+        }
+    }
+
+    [Fact]
+    public async Task GenerateManifest_SetsMaintainerToNull_WhenFieldMissing()
+    {
+        var tempDir = CreateTempDirectory();
+        var translationFile = Path.Combine(tempDir, "French.json");
+        var manifestPath = Path.Combine(tempDir, "manifest.json");
+
+        try
+        {
+            await File.WriteAllTextAsync(translationFile, """
+                {
+                  "hello": "bonjour"
+                }
+                """);
+
+            var sut = CreateSut();
+            var result = await sut.GenerateManifest(tempDir, manifestPath);
+
+            Assert.True(result);
+            var manifest = await ReadManifest(manifestPath);
+            var entry = Assert.Single(manifest.Languages);
+            Assert.Null(entry.Maintainer);
+        }
+        finally
+        {
+            if (Directory.Exists(tempDir))
+            {
+                Directory.Delete(tempDir, recursive: true);
+            }
+        }
+    }
+
+    [Fact]
+    public async Task GenerateManifest_ReturnsFalse_WhenLanguageNameMappingIsMissing()
+    {
+        var tempDir = CreateTempDirectory();
+        var translationFile = Path.Combine(tempDir, "Klingon.json");
+        var manifestPath = Path.Combine(tempDir, "manifest.json");
+
+        try
+        {
+            await File.WriteAllTextAsync(translationFile, """
+                {
+                  "_maintainer": "alice|https://github.com/alice",
+                  "hello": "nuqneH"
+                }
+                """);
+
+            var sut = CreateSut();
+            var result = await sut.GenerateManifest(tempDir, manifestPath);
+
+            Assert.False(result);
+        }
+        finally
+        {
+            if (Directory.Exists(tempDir))
+            {
+                Directory.Delete(tempDir, recursive: true);
+            }
+        }
+    }
+
+    [Fact]
+    public async Task GenerateManifest_ReturnsFalse_WhenTranslationFileHasInvalidJson()
+    {
+        var tempDir = CreateTempDirectory();
+        var translationFile = Path.Combine(tempDir, "French.json");
+        var manifestPath = Path.Combine(tempDir, "manifest.json");
+
+        try
+        {
+            await File.WriteAllTextAsync(translationFile, "{\"_maintainer\":");
+
+            var sut = CreateSut();
+            var result = await sut.GenerateManifest(tempDir, manifestPath);
+
+            Assert.False(result);
+        }
+        finally
+        {
+            if (Directory.Exists(tempDir))
+            {
+                Directory.Delete(tempDir, recursive: true);
+            }
+        }
+    }
+
+    private static ManifestGenerator CreateSut()
+    {
+        return new ManifestGenerator(NullLogger<ManifestGenerator>.Instance);
+    }
+
+    private static async Task<Manifest> ReadManifest(string path)
+    {
+        var json = await File.ReadAllTextAsync(path);
+        var manifest = JsonSerializer.Deserialize<Manifest>(json);
+        return Assert.IsType<Manifest>(manifest);
+    }
+
+    private static string ComputeSha256(string path)
+    {
+        using var sha256 = SHA256.Create();
+        using var stream = File.OpenRead(path);
+        var hash = sha256.ComputeHash(stream);
+        return Convert.ToHexString(hash).ToLowerInvariant();
+    }
+
+    private static string CreateTempDirectory()
+    {
+        var directory = Path.Combine(Path.GetTempPath(), "BTCPayTranslator.Tests", Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(directory);
+        return directory;
+    }
+}

Translator/Models/LanguageInfo.cs

@@ -1,4 +1,6 @@
+using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace BTCPayTranslator.Models;
 
@@ -119,4 +121,14 @@ public static IEnumerable<LanguageInfo> GetAllLanguages()
     {
         return Languages.Values;
     }
+
+    public static (string Code, LanguageInfo)? GetLanguageInfoByName(string name)
+    {
+        var match = Languages.FirstOrDefault(kvp =>
+            kvp.Value.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
+
+        if (match.Key == null) return null;
+
+        return (match.Key, match.Value);
+    }
 }