Fixes for the Localization package (#26)

This PR contains the work done to Reviewed-on: rock-n-code/loud-amsterdam#26 Co-authored-by: Javier Cicchelli <javier@rock-n-code.com> Co-committed-by: Javier Cicchelli <javier@rock-n-code.com>
2026-07-28 23:37:33 +00:00
parent cdded06ba3
commit 0887135328
16 changed files with 518 additions and 80 deletions
@@ -4,7 +4,8 @@ import Foundation
 ///
 /// Bound to a bundle's catalog languages via ``LanguageList``, an instance is invoked like a
 /// function — through ``callAsFunction(acceptLanguage:)`` — to resolve a header value to a
-/// supported language identifier, falling back to the default language.
+/// supported language identifier, honouring the header's `q` weights as RFC 9110 prescribes and
+/// falling back to the default language.
 public struct Negotiate: Sendable {

    // MARK: Properties
@@ -27,10 +28,12 @@ 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 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.
+    /// The header is parsed into its language ranges, which are ordered by descending `q` weight as
+    /// RFC 9110 prescribes: an entry without a weight counts as 1, entries weighted 0 are
+    /// "not acceptable" and dropped, and equal weights keep the header order. Each tag is then matched
+    /// against the supported languages in turn — first by an exact match, then by its primary language
+    /// subtag, so `de-AT` resolves to a supported `de` — while the `*` wildcard accepts the default
+    /// language. 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(
@@ -40,16 +43,20 @@ public struct Negotiate: Sendable {
            return list.default
        }

-        let tags = tags(from: language)
+        let ranges = ranges(from: language)

-        guard !tags.isEmpty else {
+        guard !ranges.isEmpty else {
            return list.default
        }

        let supported = list.all

-        for tag in tags {
-            if let match = match(tag: tag, in: supported) {
+        for range in ranges {
+            if range.tag == .wildcard {
+                return list.default
+            }
+
+            if let match = match(range.tag, in: supported) {
                return match
            }
        }
@@ -65,27 +72,69 @@ private extension Negotiate {

    // MARK: Methods

-    /// Extracts the ordered language tags from an `Accept-Language` header value.
+    /// Parses an `Accept-Language` header value into its ``LanguageRange`` list, ordered by preference.
    ///
-    /// Each comma-separated entry is reduced to its language tag by dropping the `;q=` weight, and
-    /// blank entries are removed. The original order is kept, which mirrors descending preference
-    /// closely enough for `preferredLocalizations(from:forPreferences:)` to resolve correctly.
+    /// Each comma-separated entry yields its language tag and `q` weight. The ranges are sorted by
+    /// descending weight, entries weighted 0 are dropped as "not acceptable", and equally weighted
+    /// entries keep the header order.
    /// - Parameter acceptLanguage: the raw `Accept-Language` header value.
-    /// - Returns: the ordered, weight-stripped language tags.
-    func tags(
+    /// - Returns: the language ranges, most preferred first.
+    func ranges(
        from acceptLanguage: String
-    ) -> [String] {
+    ) -> [LanguageRange] {
        acceptLanguage
            .split(separator: .Separator.comma)
-            .map { entry in
-                entry
-                    .split(separator: .Separator.semicolon)
-                    .first
-                    .map(String.init)?
-                    .trimmingCharacters(in: .whitespaces)
-                ?? .empty
+            .compactMap(range(from:))
+            .filter { $0.quality > 0 }
+            .enumerated()
+            .sorted { lhs, rhs in
+                lhs.element.quality == rhs.element.quality
+                    ? lhs.offset < rhs.offset
+                    : lhs.element.quality > rhs.element.quality
            }
-            .filter { !$0.isEmpty }
+            .map(\.element)
+    }
+
+    /// Parses a single `Accept-Language` header entry into its ``LanguageRange``.
+    ///
+    /// The entry's language tag precedes the first `;`; a `q` parameter after it sets the weight.
+    /// A missing or malformed weight counts as 1, the highest preference, matching a tag sent
+    /// without one.
+    /// - Parameter entry: a single comma-separated header entry.
+    /// - Returns: the entry's language range, or `nil` when it has no language tag.
+    func range(
+        from entry: Substring
+    ) -> LanguageRange? {
+        let parts = entry.split(separator: .Separator.semicolon)
+        let tag = parts.first
+            .map(String.init)?
+            .trimmingCharacters(in: .whitespaces)
+            ?? .empty
+
+        guard !tag.isEmpty else {
+            return nil
+        }
+
+        let quality = parts
+            .dropFirst()
+            .compactMap { parameter -> Double? in
+                let parameter = parameter
+                    .trimmingCharacters(in: .whitespaces)
+                    .lowercased()
+
+                guard parameter.hasPrefix(.Prefix.quality) else {
+                    return nil
+                }
+
+                return Double(parameter.dropFirst(String.Prefix.quality.count))
+            }
+            .first
+            ?? 1
+
+        return .init(
+            tag: tag,
+            quality: quality
+        )
    }

    /// Finds the supported language that best matches a single `Accept-Language` tag.
@@ -97,7 +146,7 @@ private extension Negotiate {
    ///   - supported: the supported language identifiers.
    /// - Returns: the matching supported language, or `nil` when the tag matches none.
    func match(
-        tag: String,
+        _ tag: String,
        in supported: [String]
    ) -> String? {
        let tag = tag.lowercased()
@@ -117,10 +166,32 @@ private extension Negotiate {

 }

+// MARK: - Character+Extensions
+
+private extension Character {
+    
+    // MARK: Constants
+    
+    enum Separator {
+        static let comma: Character = ","
+        static let dash: Character = "-"
+        static let semicolon: Character = ";"
+    }
+}
+
+
 // MARK: - String+Extensions

 private extension String {
+    
+    // MARK: Constants
+
    static let empty: String = ""
+    static let wildcard: String = "*"
+    
+    enum Prefix {
+        static let quality = "q="
+    }

    /// The primary language subtag, i.e. everything before the first `-` (`de-AT` becomes `de`).
    var primarySubtag: String {
@@ -130,13 +201,3 @@ private extension String {
        ?? self
    }
 }
-
-// MARK: - Constants
-
-private extension Character {
-    enum Separator {
-        static let comma: Character = ","
-        static let dash: Character = "-"
-        static let semicolon: Character = ";"
-    }
-}