jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

16 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `ef7d6dee5976`

tarball

atagen <boss@atagen.co>2026-10-10 15:15 UTC

6 files changed+316-13

jelqd: localise into en-GB, en-US and en-AU by Accept-Language

The game is written once in en-GB and other locales rewrite regional phrases on the way out, skipping hrefs and problem type URIs so identifiers stay stable. Excuses typed in the player's locale are mapped back before Mum checks them, so Americans can carve the turkey.

Modified file: src/http/middleware.rs+68 additions−7 deletions@@ -9,7 +9,13 @@ use axum::{
 };
 use flate2::{Compression, write::GzEncoder};
 
-use crate::{headers::X_POWERED_BY, problem::Problem};
+use serde_json::Value;
+
+use crate::{
+    headers::{X_OBSERVED_BY, X_POWERED_BY},
+    locale::Locale,
+    problem::Problem,
+};
 
 const MAX_URI: usize = 512;
 const MAX_HEADER: usize = 1024;
@@ -74,22 +80,77 @@ async fn compress(response: Response) -> Response {
     Response::from_parts(parts, Body::from(gzipped))
 }
 
-pub async fn chrome(request: Request, next: Next) -> Response {
-    let gzip = request
-        .headers()
-        .get(header::ACCEPT_ENCODING)
+async fn localise(response: Response, locale: Locale) -> Response {
+    if locale == Locale::British {
+        return response;
+    }
+    let (mut parts, body) = response.into_parts();
+    for name in [header::VIA, header::VARY, X_OBSERVED_BY] {
+        let localised: Vec<HeaderValue> = parts
+            .headers
+            .get_all(&name)
+            .iter()
+            .filter_map(|v| v.to_str().ok())
+            .filter_map(|v| HeaderValue::from_str(&locale.localise(v)).ok())
+            .collect();
+        if !localised.is_empty() {
+            parts.headers.remove(&name);
+            for value in localised {
+                parts.headers.append(name.clone(), value);
+            }
+        }
+    }
+    let json = parts
+        .headers
+        .get(header::CONTENT_TYPE)
         .and_then(|v| v.to_str().ok())
-        .is_some_and(|e| e.to_ascii_lowercase().contains("gzip"));
-    let mut response = match reject(&request) {
+        .is_some_and(|ct| {
+            ct.starts_with("application/json") || ct.starts_with("application/problem+json")
+        });
+    if !json || parts.status == StatusCode::PARTIAL_CONTENT {
+        return Response::from_parts(parts, body);
+    }
+    let Ok(bytes) = axum::body::to_bytes(body, usize::MAX).await else {
+        return Response::from_parts(parts, Body::empty());
+    };
+    let Ok(mut value) = serde_json::from_slice::<Value>(&bytes) else {
+        return Response::from_parts(parts, Body::from(bytes));
+    };
+    locale.localise_json(&mut value);
+    parts.headers.remove(header::CONTENT_LENGTH);
+    Response::from_parts(parts, Body::from(value.to_string()))
+}
+
+pub async fn chrome(request: Request, next: Next) -> Response {
+    let (gzip, locale) = {
+        let header_text = |name| {
+            request
+                .headers()
+                .get(name)
+                .and_then(|v| v.to_str().ok())
+                .map(str::to_owned)
+        };
+        let gzip = header_text(header::ACCEPT_ENCODING)
+            .is_some_and(|e| e.to_ascii_lowercase().contains("gzip"));
+        let locale = Locale::negotiate(header_text(header::ACCEPT_LANGUAGE).as_deref());
+        (gzip, locale)
+    };
+    let response = match reject(&request) {
         Some(problem) => problem.into_response(),
         None => next.run(request).await,
     };
+    let mut response = localise(response, locale).await;
     if gzip && response.extensions().get::<Compress>().is_some() {
         response = compress(response).await;
     }
     let headers = response.headers_mut();
     headers.insert(header::SERVER, HeaderValue::from_static("jelqd/0.6.9"));
     headers.insert(X_POWERED_BY, HeaderValue::from_static("blood"));
+    headers.insert(
+        header::CONTENT_LANGUAGE,
+        HeaderValue::from_static(locale.tag()),
+    );
+    headers.append(header::VARY, HeaderValue::from_static("Accept-Language"));
     headers
         .entry(header::CACHE_CONTROL)
         .or_insert(HeaderValue::from_static("no-store, private"));

Modified file: src/http/run.rs+5 additions−1 deletions@@ -14,6 +14,7 @@ use crate::{
         X_CASH, X_EQ, X_FLOOR, X_FORESKIN, X_GIRTH, X_OBSERVED_BY, X_SELF_REPORTED_LENGTH, X_SHAME,
         X_STAMINA, X_SUSPICION,
     },
+    locale::Locale,
     problem::{PROBLEM_BASE, Problem},
     secret::Secret,
 };
@@ -79,7 +80,10 @@ fn gate(run: &mut Run, ctx: &Ctx, scope: Scope) -> Option<Response> {
             .into_response(),
         );
     }
-    run.answer_door(ctx.header(header::AUTHORIZATION))
+    let authorization = ctx
+        .header(header::AUTHORIZATION)
+        .map(|text| Locale::negotiate(ctx.header(header::ACCEPT_LANGUAGE)).canonicalise(text));
+    run.answer_door(authorization.as_deref())
         .err()
         .map(IntoResponse::into_response)
 }

Modified file: src/lib.rs+1

@@ -2,6 +2,7 @@ mod config;

22 mod game;

33 mod headers;

44 mod http;

5+mod locale;

56 mod problem;

67 mod secret;

Added file: src/locale.rs+195 additions@@ -0,0 +1,195 @@
+//! The game is written in en-GB. Other locales are produced by rewriting regional phrases.
+
+use serde_json::Value;
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Default)]
+pub enum Locale {
+    #[default]
+    British,
+    American,
+    Australian,
+}
+
+/// Ordered so that longer phrases are rewritten before the words inside them.
+const EN_US: &[(&str, &str)] = &[
+    (
+        "Nan's house at Christmas",
+        "Grandma's house for Thanksgiving",
+    ),
+    ("Christmas dinner", "Thanksgiving dinner"),
+    (
+        "The King's speech is about to start.",
+        "The game is about to start.",
+    ),
+    ("wrapping presents", "carving the turkey"),
+    ("folding the washing", "folding laundry"),
+    ("your washing", "your laundry"),
+    ("changing room", "locker room"),
+    ("flatmate", "roommate"),
+    ("authorisation", "authorization"),
+    ("neighbour", "neighbor"),
+    ("cupboard", "pantry"),
+    ("Christmas", "Thanksgiving"),
+    ("Mum", "Mom"),
+    ("mum", "mom"),
+    ("Nan", "Grandma"),
+    ("nan", "grandma"),
+    ("zip", "zipper"),
+    ("£", "$"),
+];
+
+const EN_AU: &[(&str, &str)] = &[
+    ("Christmas dinner", "Christmas lunch"),
+    (
+        "The King's speech is about to start.",
+        "The cricket is about to start.",
+    ),
+    ("wrapping presents", "getting ice from the servo"),
+    ("changing room", "change rooms"),
+    ("flatmate", "housemate"),
+    ("cupboard", "pantry"),
+    ("zip", "fly"),
+    ("£", "$"),
+];
+
+const EXCUSES: &[&str] = &["wrapping presents", "folding the washing"];
+
+fn bounded(text: &str, at: usize, len: usize) -> bool {
+    let before = text[..at].chars().next_back();
+    let after = text[at + len..].chars().next();
+    let edge = |c: Option<char>| c.is_none_or(|c| !c.is_alphanumeric());
+    edge(before) && edge(after)
+}
+
+fn replace_words(text: &str, from: &str, to: &str) -> String {
+    let mut out = String::with_capacity(text.len());
+    let mut rest = 0;
+    for (at, _) in text.match_indices(from) {
+        if at < rest || !bounded(text, at, from.len()) {
+            continue;
+        }
+        out.push_str(&text[rest..at]);
+        out.push_str(to);
+        rest = at + from.len();
+    }
+    out.push_str(&text[rest..]);
+    out
+}
+
+impl Locale {
+    pub fn tag(self) -> &'static str {
+        match self {
+            Self::British => "en-GB",
+            Self::American => "en-US",
+            Self::Australian => "en-AU",
+        }
+    }
+
+    fn parse(tag: &str) -> Option<Self> {
+        match tag.trim().to_ascii_lowercase().as_str() {
+            "en-gb" | "en" => Some(Self::British),
+            "en-us" => Some(Self::American),
+            "en-au" => Some(Self::Australian),
+            _ => None,
+        }
+    }
+
+    /// Picks the most preferred supported locale from an `Accept-Language` header (RFC 9110 §12.5.4).
+    pub fn negotiate(accept_language: Option<&str>) -> Self {
+        let Some(header) = accept_language else {
+            return Self::default();
+        };
+        header
+            .split(',')
+            .filter_map(|range| {
+                let mut parts = range.split(';');
+                let locale = Self::parse(parts.next()?)?;
+                let quality = parts
+                    .find_map(|p| p.trim().strip_prefix("q="))
+                    .and_then(|q| q.parse::<f32>().ok())
+                    .unwrap_or(1.0);
+                (quality > 0.0).then_some((locale, quality))
+            })
+            .max_by(|a, b| a.1.total_cmp(&b.1))
+            .map_or_else(Self::default, |(locale, _)| locale)
+    }
+
+    fn phrases(self) -> &'static [(&'static str, &'static str)] {
+        match self {
+            Self::British => &[],
+            Self::American => EN_US,
+            Self::Australian => EN_AU,
+        }
+    }
+
+    pub fn localise(self, text: &str) -> String {
+        self.phrases()
+            .iter()
+            .fold(text.to_owned(), |text, (from, to)| {
+                replace_words(&text, from, to)
+            })
+    }
+
+    /// Translates the excuses a player types back into the en-GB phrases the game checks against.
+    pub fn canonicalise(self, text: &str) -> String {
+        let local = |excuse: &str| self.localise(excuse);
+        EXCUSES.iter().fold(text.to_owned(), |text, excuse| {
+            replace_words(&text, &local(excuse), excuse)
+        })
+    }
+
+    pub fn localise_json(self, value: &mut Value) {
+        match value {
+            Value::String(text) if !text.starts_with('/') && !text.starts_with("http") => {
+                *text = self.localise(text);
+            }
+            Value::Array(items) => items.iter_mut().for_each(|item| self.localise_json(item)),
+            Value::Object(fields) => {
+                for (key, field) in fields.iter_mut() {
+                    if !matches!(key.as_str(), "href" | "type" | "instance") {
+                        self.localise_json(field);
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn negotiates_by_quality() {
+        assert_eq!(Locale::negotiate(None), Locale::British);
+        assert_eq!(Locale::negotiate(Some("en-US")), Locale::American);
+        assert_eq!(
+            Locale::negotiate(Some("fr, en-AU;q=0.8, en-US;q=0.5")),
+            Locale::Australian
+        );
+        assert_eq!(Locale::negotiate(Some("de")), Locale::British);
+    }
+
+    #[test]
+    fn rewrites_whole_words_only() {
+        let us = Locale::American;
+        assert_eq!(
+            us.localise("Mum's zip, not gzip."),
+            "Mom's zipper, not gzip."
+        );
+        assert_eq!(us.localise("1.1 mum"), "1.1 mom");
+        assert_eq!(
+            Locale::Australian.localise("The request conflicts with the current state of the zip."),
+            "The request conflicts with the current state of the fly."
+        );
+    }
+
+    #[test]
+    fn excuses_come_back_to_en_gb() {
+        assert_eq!(
+            Locale::American.canonicalise("Digest username=\"carving the turkey\""),
+            "Digest username=\"wrapping presents\""
+        );
+    }
+}

Modified file: src/tests.rs+35 additions@@ -680,3 +680,38 @@ async fn http_1_0_gets_the_pdf_treatment() {
     let response = app().oneshot(request).await.unwrap();
     assert_eq!(response.status(), StatusCode::HTTP_VERSION_NOT_SUPPORTED);
 }
+
+#[tokio::test]
+async fn mom_speaks_american() {
+    let app = seeded_with(Floor::Nans, mum_at_the_door);
+    let us = [("accept-language", "en-US")];
+    let knock = send(&app, "GET", "/runs/cafebabe", &us, "").await;
+    assert_eq!(header(&knock, "content-language"), "en-US");
+    assert_eq!(header(&knock, "via"), "1.1 mom");
+    assert!(
+        json(knock).await["detail"]
+            .as_str()
+            .unwrap()
+            .contains("Someone is at the door.")
+    );
+    let excuse = [
+        ("accept-language", "en-US"),
+        (
+            "authorization",
+            "Digest username=\"carving the turkey\", nonce=\"abc\"",
+        ),
+    ];
+    let answered = send(&app, "GET", "/runs/cafebabe", &excuse, "").await;
+    assert_eq!(answered.status(), StatusCode::OK);
+    let floor = json(send(&app, "GET", "/runs/cafebabe/floor", &us, "").await).await;
+    assert_eq!(floor["name"], "Grandma's house for Thanksgiving");
+}
+
+#[tokio::test]
+async fn the_default_locale_is_british() {
+    let (app, _) = seeded(Floor::Nans);
+    let floor = send(&app, "GET", "/runs/cafebabe/floor", &[], "").await;
+    assert_eq!(header(&floor, "content-language"), "en-GB");
+    assert!(header(&floor, "vary").contains("Accept-Language"));
+    assert_eq!(json(floor).await["name"], "Nan's house at Christmas");
+}

Modified file: src/ui.html+12 additions−5 deletions@@ -12,7 +12,8 @@ pre, li, p, td, label { overflow-wrap: anywhere; }
 <body>
 
 <h1>jelqd</h1>
-<p>A roguelike played over HTTP. Pick a resource, pick a method, send it. The log on the right is everything the server has said to you.</p>
+<p>A roguelike played over HTTP. Pick a resource, pick a method, send it. The log on the right is everything the server has said to you.
+Language <select id="locale"><option>en-GB</option><option>en-US</option><option>en-AU</option></select></p>
 
 <table width="100%" cellspacing="6">
 <tr>
@@ -62,7 +63,6 @@ const STATS = [
   ["x-shame", "Shame"],
   ["x-cash", "Cash"],
 ];
-const OBSERVERS = { cat: "The cat is watching.", greg: "Greg is watching.", nan: "Nan is watching." };
 const QUIET = new Set(["link", "set-cookie", "server", "x-powered-by", "cache-control", "content-length", "content-type", "date"].concat(STATS.map(s => s[0])));
 
 const FIELDS = {
@@ -149,16 +149,20 @@ function renderStats(headers) {
   }
 }
 
+function titled(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
 function renderAlerts(list) {
   const box = $("alerts");
   box.replaceChildren();
   const alerts = [];
   for (const [name, value] of list || []) {
-    if (name === "via" && value.includes("mum")) alerts.push("Mum is at the door.");
-    if (name === "x-observed-by") alerts.push(OBSERVERS[value] || "Someone is watching.");
+    if (name === "via") alerts.push(titled(value.split(" ").pop()) + " is at the door.");
+    if (name === "x-observed-by") alerts.push((value === "cat" ? "The cat" : titled(value)) + " is watching.");
     if (name === "warning") {
       const text = (value.match(/"([^"]*)"/) || [, value])[1];
-      alerts.push(text.charAt(0).toUpperCase() + text.slice(1) + ".");
+      alerts.push(titled(text) + ".");
     }
   }
   for (const alert of alerts) box.append(el("h2", { textContent: alert }));
@@ -328,6 +332,7 @@ async function go(event) {
 
   log("> " + method + " " + short(path));
   for (const [name, v] of headers) log("> " + name + ": " + v);
+  headers.push(["Accept-Language", $("locale").value]);
   const response = await fetch("/ui/send", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -339,6 +344,8 @@ async function go(event) {
 }
 
 $("form").onsubmit = go;
+$("locale").value = localStorage.getItem("locale") || "en-GB";
+$("locale").onchange = () => localStorage.setItem("locale", $("locale").value);
 renderStats(null);
 render();
 log("Welcome. Choose \"start a new run\" and send POST to begin.\n");

jelq

Commit ef7d6dee5976

Commit `ef7d6dee5976`