Website service Makefile and Localization package fixes (#12)

This PR contains the work done to get the Website service building and running correctly in its Linux container. The service depends on the local _Localization_ package, whose String-Catalog localization was Darwin-only and broke the Docker build. Thus the localization internals have been reworked to be platform-agnostic and fixes the container build context so the local package is actually available during the build.

* Localization package
  * Replaced the Darwin-only `String.LocalizationValue` / `String(localized:)` path with a StringCatalog type that reads raw JSON from a given `.xcstrings` file, so lookups resolve identically on macOS and Linux.
  * The `LanguageList` now derives available languages from the catalog instead of `Bundle.localizations`
  * The `Negotiate` does explicit _Accept-Language_ matching (exact tag, then primary subtag) instead of the Linux-broken `Bundle.preferredLocalizations`.
  * Switched the catalog resource rule from `.process` to `.copy` (in both Localization and Website manifests) so the raw `.xcstrings` ships verbatim on every platform.
  * Introduced a `CatalogResolving` protocol as a seam between the localizers and the storage backend, enabling test injection and a future native-Apple backend without changing callers.

* Website Docker build
  * Build context moved to the repository root so the relative-path `Localization` package is inside the context; `Dockerfile`, `docker-compose.override.yml`, and the _img-release_ make target updated to the new context/paths.
  *  Added a root `.dockerignore` to keep the context lean.

Reviewed-on: rock-n-code/loud-amsterdam#12
Co-authored-by: Javier Cicchelli <javier@rock-n-code.com>
Co-committed-by: Javier Cicchelli <javier@rock-n-code.com>

Packages/Localization/Sources/Methods/Localize.swift

@@ -9,17 +9,33 @@ public struct Localize: Sendable {
 
     // MARK: Properties
 
-    /// The bundle whose compiled String Catalog the keys are resolved against.
-    private let bundle: Bundle
+    /// The backend that resolves keys against the catalog.
+    private let resolver: any CatalogResolving
 
     // MARK: Initializers
 
-    /// Creates a localizer backed by the given bundle.
-    /// - Parameter bundle: the bundle whose String Catalog contains the keys to resolve.
+    /// Creates a localizer backed by the String Catalog in the given bundle.
+    /// - Parameters:
+    ///   - bundle: the bundle whose String Catalog contains the keys to resolve.
+    ///   - table: the name of the String Catalog resource, without the `.xcstrings` extension.
     public init(
-        bundle: Bundle
+        bundle: Bundle,
+        table: String = "Localizable"
     ) {
-        self.bundle = bundle
+        self.init(resolver: StringCatalog(
+            bundle: bundle,
+            table: table
+        ))
+    }
+
+    /// Creates a localizer backed by the given resolver.
+    ///
+    /// The seam for tests and alternative backends; the public API resolves against a bundled catalog.
+    /// - Parameter resolver: the backend that resolves keys to localized strings.
+    init(
+        resolver: any CatalogResolving
+    ) {
+        self.resolver = resolver
     }
 
     // MARK: Methods
@@ -30,16 +46,16 @@ public struct Localize: Sendable {
     /// - Parameters:
     ///   - key: the String Catalog key to look up.
     ///   - locale: the locale to resolve the key in.
-    /// - Returns: the localized string for the locale, or the key itself when the bundle's catalog has no entry for it.
+    /// - Returns: the localized string for the locale, the source-language string when the locale has no
+    ///   entry, or the key itself when the catalog has no entry for it.
     public func callAsFunction(
-        _ key: String.LocalizationValue,
+        _ key: String,
         locale: Locale
     ) -> String {
-        .init(localized: .init(
-            key,
-            locale: locale,
-            bundle: .atURL(bundle.bundleURL)
-        ))
+        resolver.string(
+            for: key,
+            in: locale
+        )
     }
 
 }

Packages/Localization/Sources/Methods/Negotiate.swift

@@ -27,9 +27,10 @@ public struct Negotiate: Sendable {
     /// Picks the best supported language for the given `Accept-Language` header value.
     ///
     /// Invoked by calling the instance directly, for example `negotiate(acceptLanguage: header)`.
-    /// The header is split into its language tags (dropping any `q` weights), then matched against
-    /// the supported languages with `Bundle.preferredLocalizations(from:forPreferences:)`. When the
-    /// header is absent or matches nothing, the default language is returned.
+    /// The header is split into its language tags (dropping any `q` weights), then each tag is matched
+    /// against the supported languages in order of preference — first by an exact match, then by its
+    /// primary language subtag, so `de-AT` resolves to a supported `de`. When the header is absent or
+    /// matches nothing, the default language is returned.
     /// - Parameter acceptLanguage: the raw `Accept-Language` header value, if any.
     /// - Returns: the identifier of the supported language to serve.
     public func callAsFunction(
@@ -45,13 +46,15 @@ public struct Negotiate: Sendable {
             return list.default
         }
 
-        let preferred = Bundle.preferredLocalizations(
-            from: list.all,
-            forPreferences: tags
-        )
+        let supported = list.all
 
-        return preferred.first
-            ?? list.default
+        for tag in tags {
+            if let match = match(tag: tag, in: supported) {
+                return match
+            }
+        }
+
+        return list.default
     }
 
 }
@@ -85,6 +88,47 @@ private extension Negotiate {
             .filter { !$0.isEmpty }
     }
 
+    /// Finds the supported language that best matches a single `Accept-Language` tag.
+    ///
+    /// An exact, case-insensitive match wins; otherwise the tag's primary subtag is matched against the
+    /// supported languages' primary subtags, so a regional tag such as `de-AT` resolves to `de`.
+    /// - Parameters:
+    ///   - tag: a single language tag from the header.
+    ///   - supported: the supported language identifiers.
+    /// - Returns: the matching supported language, or `nil` when the tag matches none.
+    func match(
+        tag: String,
+        in supported: [String]
+    ) -> String? {
+        let tag = tag.lowercased()
+
+        if let exact = supported.first(
+            where: { $0.lowercased() == tag }
+        ) {
+            return exact
+        }
+
+        let primary = tag.primarySubtag
+
+        return supported.first {
+            $0.lowercased().primarySubtag == primary
+        }
+    }
+
+}
+
+// MARK: - String+Extensions
+
+private extension String {
+    static let empty: String = ""
+
+    /// The primary language subtag, i.e. everything before the first `-` (`de-AT` becomes `de`).
+    var primarySubtag: String {
+        split(separator: .Separator.dash)
+            .first
+            .map(String.init)
+        ?? self
+    }
 }
 
 // MARK: - Constants
@@ -92,10 +136,7 @@ private extension Negotiate {
 private extension Character {
     enum Separator {
         static let comma: Character = ","
+        static let dash: Character = "-"
         static let semicolon: Character = ";"
     }
 }
-
-private extension String {
-    static let empty: String = ""
-}