bdeshi/khosra
0
0
Fork 0
Code Issues Pull Requests Releases Activity

serve language variants under a prefix

Browse Source 
The default locale stays at the root; every other language is the same key under
/{lang}/ (ADR-0009). /en/… is never live and redirects to the root form so the URL
space cannot fork. Lookup now takes a language and reports which one it served,
following requested → default → any rather than 404ing when a translation is
missing.

That is the second routing case, so the resolver is extracted to resolve.go and
the mux keeps one entry: URL shape is the resolver's business. A leading segment
counts as a language only when some bundle is written in it, so an unknown prefix
is a 404 rather than a stripped path — and a section may not be named after a
language in use, now recorded in content-model.md.

Because the served variant can differ from the URL requested, Page gained
.Canonical (the variant actually served) and .Alternates for hreflang. A theme
must never build a path, so both come from the engine.

Evidence: /bn/pages/about/ serves the Bengali body with lang="bn" and canonical
/bn/pages/about/; /bn/posts/hello-world/ falls back to English with canonical
/posts/hello-world/; /en/pages/about/ 301s to /pages/about/; /fr/… is 404.
This commit is contained in:
bdeshi
2026-08-01 02:23:34 +06:00
parent c6d5b4abb7
commit 80057aa183
12 changed files with 301 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/web/web.go
+15 -23
View File
@@ -5,7 +5,6 @@ package web
import (
"log/slog"
"net/http"
"strings"
"khosra/internal/content"
"khosra/internal/render"
@@ -13,8 +12,7 @@ import (
// Handler serves a site.
//
// One routing case for now: a path is a bundle key. Extracting a resolver waits for the second case,
// which language routing brings — check the counter in docs/state.md rather than anticipating it.
// One mux entry, because URL shape is the resolver's business rather than the mux's: see resolve.
func Handler(site *content.Site, r *render.Renderer) http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /", func(w http.ResponseWriter, req *http.Request) {
@@ -23,31 +21,25 @@ func Handler(site *content.Site, r *render.Renderer) http.Handler {
return mux
}
// serve resolves one request.
//
// The canonical form of every bundle URL ends in a slash (ADR-0008), so a slashless path that names a
// bundle redirects permanently rather than serving a second URL for the same content.
// serve resolves one request and writes its bundle.
func serve(w http.ResponseWriter, req *http.Request, site *content.Site, r *render.Renderer) {
p := req.URL.Path
if p == "/" {
http.NotFound(w, req)
return
}
key := content.Normalise(strings.Trim(p, "/"))
if !strings.HasSuffix(p, "/") {
if _, ok := site.Lookup(key); ok {
http.Redirect(w, req, p+"/", http.StatusMovedPermanently)
return
}
http.NotFound(w, req)
return
}
b, ok := site.Lookup(key)
res, ok := resolve(req.URL.Path, site)
if !ok {
http.NotFound(w, req)
return
}
out, err := r.Bundle(b)
// A redirect target only exists for a path that resolves, so check the bundle before sending one:
// otherwise a nonexistent page answers 301 and confirms nothing.
b, served, found := site.Lookup(res.key, res.lang)
if res.redirect != "" && (found || res.key == "") {
http.Redirect(w, req, res.redirect, http.StatusMovedPermanently)
return
}
if !found {
http.NotFound(w, req)
return
}
out, err := r.Bundle(b, served, site.Variants(res.key))
if err != nil {
// A render failure degrades: log it and say nothing more to the client than that it failed
// (conventions.md). It must never leak a template or filesystem detail.