bdeshi
449850c83d
One global namespace (ADR-0018): /tags/{term}/ spans every section and
/{section}/tags/{term}/ narrows it. Listings group by section so one busy term
stays readable, which needed List.Groups alongside Items — list.html renders
whichever is set.
This is Query's second use, so it gained a Tag field rather than being generalised
on speculation: one filter, two callers. Tag slugs lowercase and hyphenate,
preserving script, so "Long Monsoon" and "long monsoon" are one term while Bengali
passes through unchanged. Hand-chosen slugs per term still wait for the type
declaration that owns overrides.
`tags` is reserved at the top level and inside every section, alongside `page` and
the language prefixes. A tag listing redirects to its canonical URL only once it is
known to exist, matching the rule bundles already followed — otherwise a canonical
URL for nothing confirms what is not there.
One stale test expectation fixed rather than worked around: it asserted tags land
in Extra, which stopped being true when tags became a named field.
Evidence: /tags/monsoon/ lists Hello World under posts and First Rain under comics;
/comics/tags/monsoon/ shows one; /tags/monsoon 301s; /tags/nothing/ and /tags/ 404.
113 lines
3.7 KiB
Go
113 lines
3.7 KiB
Go
package web
|
|
|
|
import (
|
|
"strconv"
|
|
"strings"
|
|
|
|
"khosra/internal/content"
|
|
)
|
|
|
|
// resolution is what a request path means: which bundle key, in which language, or where to send the
|
|
// client instead.
|
|
type resolution struct {
|
|
key string
|
|
lang string
|
|
// page is 1 for a bundle or the first listing page, higher for /page/N/.
|
|
page int
|
|
// tag is a tag slug when the path named a tag listing; key then holds the section, or "" for the
|
|
// global listing.
|
|
tag string
|
|
// redirect is the canonical path when the request named a non-canonical one. Non-empty means answer
|
|
// with a permanent redirect and nothing else.
|
|
redirect string
|
|
}
|
|
|
|
// resolve maps a request path to a bundle key and language.
|
|
//
|
|
// Two cases, which is why this is a resolver rather than an inline branch: the default locale lives at
|
|
// the root of the URL space, every other language under a prefix on the same key (ADR-0009). `/en/…` is
|
|
// never a live URL — it redirects to the root form so the space cannot fork. The canonical form ends in
|
|
// a slash (ADR-0008).
|
|
//
|
|
// A language prefix wins over a section of the same name, so a site with Bengali content cannot also
|
|
// have a section called `bn` (content-model.md).
|
|
func resolve(path string, site *content.Site) (resolution, bool) {
|
|
if path == "" || path[0] != '/' {
|
|
return resolution{}, false
|
|
}
|
|
trimmed := strings.Trim(path, "/")
|
|
if trimmed == "" {
|
|
return resolution{}, false
|
|
}
|
|
|
|
lang := content.DefaultLang
|
|
key := content.Normalise(trimmed)
|
|
if head, rest, found := strings.Cut(key, "/"); found && head != "" {
|
|
switch {
|
|
case head == content.DefaultLang:
|
|
// /en/… is a second spelling of the root form; send the client to the real one.
|
|
return resolution{redirect: content.URL(rest, content.DefaultLang)}, true
|
|
case site.HasLang(head):
|
|
lang, key = head, rest
|
|
}
|
|
} else if key == content.DefaultLang {
|
|
return resolution{redirect: "/"}, true
|
|
}
|
|
|
|
page := 1
|
|
// A trailing /page/N/ is pagination, not part of the key (ADR-0028). Page one is the bare listing
|
|
// URL, so /page/1/ is a second spelling and redirects.
|
|
if rest, n, isPaged := cutPage(key); isPaged {
|
|
if n == 1 {
|
|
return resolution{redirect: content.PageURL(rest, lang, 1)}, true
|
|
}
|
|
key, page = rest, n
|
|
}
|
|
// tags/<term> at the top level, or <section>/tags/<term> inside one (ADR-0018). Recognised by shape
|
|
// here, so URL knowledge stays in the resolver.
|
|
tag, section, isTag := cutTag(key)
|
|
|
|
if !strings.HasSuffix(path, "/") {
|
|
if isTag {
|
|
return resolution{key: section, tag: tag, lang: lang, page: page,
|
|
redirect: content.TagURL(section, tag, lang, page)}, true
|
|
}
|
|
return resolution{key: key, lang: lang, page: page, redirect: content.PageURL(key, lang, page)}, true
|
|
}
|
|
if isTag {
|
|
return resolution{key: section, tag: tag, lang: lang, page: page}, true
|
|
}
|
|
return resolution{key: key, lang: lang, page: page}, true
|
|
}
|
|
|
|
// cutTag splits a tag listing key into its term and the section it is narrowed to.
|
|
func cutTag(key string) (tag, section string, ok bool) {
|
|
if rest, found := strings.CutPrefix(key, content.TagsSegment+"/"); found {
|
|
return rest, "", rest != ""
|
|
}
|
|
if i := strings.Index(key, "/"+content.TagsSegment+"/"); i >= 0 {
|
|
term := key[i+len(content.TagsSegment)+2:]
|
|
return term, key[:i], term != ""
|
|
}
|
|
return "", "", false
|
|
}
|
|
|
|
// cutPage strips a trailing "page/N" off a key, reporting the page number.
|
|
func cutPage(key string) (rest string, page int, ok bool) {
|
|
i := strings.LastIndex(key, "/")
|
|
if i < 0 {
|
|
return key, 1, false
|
|
}
|
|
n, err := strconv.Atoi(key[i+1:])
|
|
if err != nil || n < 1 {
|
|
return key, 1, false
|
|
}
|
|
switch base := key[:i]; {
|
|
case base == "page":
|
|
return "", n, true
|
|
case strings.HasSuffix(base, "/page"):
|
|
return strings.TrimSuffix(base, "/page"), n, true
|
|
}
|
|
return key, 1, false
|
|
}
|