jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

28 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `ec6fd4bb5b60`

tarball

atagen <boss@atagen.co>2026-10-11 04:36 UTC

4 files changed+88-28

http: keep the shafts uncompressed and give the foreskin a body

gzip was stripping Content-Length from every response, so the ruler joke about a real Content-Length never reached a browser. Only JSON and XML compress now. GET /foreskin used to be an empty 204, so the ETag needed for its DELETE was a cold fact, and now it draws itself with inch ranges of its own. The UI prefills If-Match from the last ETag and the Digest nonce from her challenge, and lubes no longer vanish from the form when the combo partner has no opinion.

Modified file: src/http/middleware.rs+12 additions@@ -61,6 +61,18 @@ fn reject(request: &Request) -> Option<Problem> {
 }
 
 async fn compress(response: Response) -> Response {
+    let compressible = response
+        .headers()
+        .get(header::CONTENT_TYPE)
+        .and_then(|value| value.to_str().ok())
+        .is_some_and(|type_| {
+            type_.starts_with("application/json")
+                || type_.starts_with("application/problem+json")
+                || type_.starts_with("application/xml")
+        });
+    if !compressible {
+        return response;
+    }
     let (mut parts, body) = response.into_parts();
     let Ok(bytes) = axum::body::to_bytes(body, usize::MAX).await else {
         return Response::from_parts(parts, Body::empty());

Modified file: src/http/runs.rs+64 additions−24 deletions@@ -261,6 +261,37 @@ fn parse_inch_range(range: &str, total: f64) -> Option<InchRange> {
     })
 }
 
+fn unsatisfied_range(inches: f64) -> Response {
+    Problem::new(
+        StatusCode::RANGE_NOT_SATISFIABLE,
+        "range-not-satisfiable",
+        format!("The requested range is not available. {inches:.2} inches are."),
+    )
+    .header(header::CONTENT_RANGE, format!("inches */{inches:.2}"))
+    .into_response()
+}
+
+fn partial_inches(body: &str, offset: usize, start: f64, end: f64, total: f64) -> Response {
+    let from = (millimetres(start) + offset).min(body.len() - 1);
+    let to = (millimetres(end) + offset).clamp(from + 1, body.len());
+    (
+        StatusCode::PARTIAL_CONTENT,
+        [
+            (
+                header::CONTENT_TYPE,
+                "text/plain; charset=us-ascii".to_owned(),
+            ),
+            (header::ACCEPT_RANGES, "inches".to_owned()),
+            (
+                header::CONTENT_RANGE,
+                format!("inches {start:.2}-{end:.2}/{total:.2}"),
+            ),
+        ],
+        body[from..to].to_owned(),
+    )
+        .into_response()
+}
+
 fn get_length(run: &mut Run, ctx: &Ctx) -> Response {
     let inches = if run.items.ruler {
         run.current_length()
@@ -278,27 +309,12 @@ fn get_length(run: &mut Run, ctx: &Ctx) -> Response {
         .header(header::RANGE)
         .and_then(|range| parse_inch_range(range, inches))
     {
-        let InchRange::Satisfiable(start, end) = range else {
-            return Problem::new(
-                StatusCode::RANGE_NOT_SATISFIABLE,
-                "range-not-satisfiable",
-                format!("The requested range is not available. {inches:.2} inches are."),
-            )
-            .header(header::CONTENT_RANGE, format!("inches */{inches:.2}"))
-            .into_response();
-        };
-        let from = millimetres(start).min(body.len() - 1);
-        let to = millimetres(end).clamp(from + 1, body.len());
-        let content_range = (
-            header::CONTENT_RANGE,
-            format!("inches {start:.2}-{end:.2}/{inches:.2}"),
-        );
-        return (
-            StatusCode::PARTIAL_CONTENT,
-            [content_type, accept_ranges, content_range],
-            body[from..to].to_owned(),
-        )
-            .into_response();
+        match range {
+            InchRange::Satisfiable(start, end) => {
+                return partial_inches(&body, 0, start, end, inches);
+            }
+            InchRange::Unsatisfiable => return unsatisfied_range(inches),
+        }
     }
 
     if run.items.ruler {
@@ -313,16 +329,40 @@ fn get_length(run: &mut Run, ctx: &Ctx) -> Response {
     (StatusCode::OK, [content_type, accept_ranges], body).into_response()
 }
 
-fn get_foreskin(run: &mut Run, _: &Ctx) -> Response {
-    if run.foreskin.is_none() {
+fn get_foreskin(run: &mut Run, ctx: &Ctx) -> Response {
+    let Some(inches) = run.foreskin else {
         return Problem::new(
             StatusCode::GONE,
             "foreskin-gone",
             "The foreskin is gone. It will not be returning.",
         )
         .into_response();
+    };
+    let body = format!("8({})D", "~".repeat(millimetres(inches)));
+    if let Some(range) = ctx
+        .header(header::RANGE)
+        .and_then(|range| parse_inch_range(range, inches))
+    {
+        match range {
+            InchRange::Satisfiable(start, end) => {
+                return partial_inches(&body, 2, start, end, inches);
+            }
+            InchRange::Unsatisfiable => return unsatisfied_range(inches),
+        }
     }
-    (StatusCode::NO_CONTENT, [(header::ETAG, run.etag())]).into_response()
+    (
+        StatusCode::OK,
+        [
+            (header::ETAG, run.etag()),
+            (
+                header::CONTENT_TYPE,
+                "text/plain; charset=us-ascii".to_owned(),
+            ),
+            (header::ACCEPT_RANGES, "inches".to_owned()),
+        ],
+        body,
+    )
+        .into_response()
 }
 
 fn delete_foreskin(run: &mut Run, ctx: &Ctx) -> Response {

Modified file: src/tests.rs+2 additions−1 deletions@@ -197,8 +197,9 @@ async fn deleting_the_foreskin_requires_certainty() {
     let response = send(&app, "DELETE", "/runs/cafebabe/foreskin", &[], "").await;
     assert_eq!(response.status(), StatusCode::PRECONDITION_REQUIRED);
     let look = send(&app, "GET", "/runs/cafebabe/foreskin", &[], "").await;
-    assert_eq!(look.status(), StatusCode::NO_CONTENT);
+    assert_eq!(look.status(), StatusCode::OK);
     let etag = header(&look, "etag").to_owned();
+    assert!(text(look).await.contains('~'));
     let response = send(
         &app,
         "DELETE",

Modified file: src/ui.html+10 additions−3 deletions@@ -112,6 +112,7 @@ let linked = [];
 let techniques = [];
 let offered = [];
 let challenged = false;
+const etags = {};
 let target = "/runs";
 let method = "POST";
 const values = {};
@@ -167,7 +168,7 @@ function fieldValue(name) {
 
 function lubeRule() {
   const picked = [technique(fieldValue("technique")), technique(fieldValue("also"))].filter(Boolean);
-  if (!picked.length || !picked[0].lubricant) return "none";
+  if (!picked.some(t => t.lubricant)) return "none";
   for (const rule of ["forbidden", "required"]) {
     if (picked.some(t => t.lubricant === rule)) return rule;
   }
@@ -275,7 +276,8 @@ function renderFields() {
   table.replaceChildren();
   for (const name of fieldNames()) {
     const f = FIELDS[name];
-    const value = fieldValue(name);
+    let value = fieldValue(name);
+    if (name === "ifMatch" && !value) value = values.ifMatch = etags[current().path] || "";
     const choices = options(name);
     let input;
     if (choices) {
@@ -351,13 +353,18 @@ function describe(r) {
     const range = (r.headers.find(h => h[0] === "content-range") || [])[1] || "";
     const partial = r.status === 206 && range.match(/^bytes (\d+)-(\d+)\/(\d+)$/);
     lines.push("  " + r.body);
-    if (partial) lines.push("  [bytes " + partial[1] + "-" + partial[2] + " of " + partial[3] + ". A 206 carries only part of the representation, as RFC 9110 requires.]");
+    if (partial) lines.push("  [bytes " + partial[1] + "-" + partial[2] + " of " + partial[3] + ". Half-mast.]");
   }
   return lines.join("\n");
 }
 
 function absorb(r, sentMethod, sentPath) {
   const headers = Object.fromEntries(r.headers.map(([n, v]) => [n.toLowerCase(), v]));
+  if (headers.etag) etags[sentPath] = headers.etag;
+  const digest = (headers["www-authenticate"] || "").match(/nonce="([^"]*)"/);
+  if (digest && !(values.authorization || "").includes(digest[1])) {
+    values.authorization = 'Digest username="", nonce="' + digest[1] + '"';
+  }
   let body = null;
   try { body = JSON.parse(r.body); } catch (e) {}
   const problem = body && typeof body.type === "string" ? body.type.split("/").pop() : null;

jelq

Commit ec6fd4bb5b60

Commit `ec6fd4bb5b60`