motorino/internal/build/context.go
tgiachi eb2a8dc9b4 feat: take the menu from the site, not from the code
The menu entries were three lists in Go (the menu, the linked pages and
the required pages), so a new menu entry meant a new motorino release.
Now every page ID gets url_<id> and cur_<id> for the templates, and
header.html alone decides what is in the menu and in which order. Only
the home page and the news section stay required, since motorino builds
them itself.

Output of the real kmalloc.org site is byte for byte the same as 1.1.0.
2026-11-15 18:08:42 +01:00

210 lines
6.2 KiB
Go

// SPDX-License-Identifier: GPL-3.0-or-later
package build
import (
"fmt"
"strings"
"git.kmalloc.org/squid/motorino/internal/render"
)
// blockNames are the placeholders that expand to generated HTML. Until they
// are expanded they stand for themselves, so a page can hold them.
var blockNames = []string{"news_list", "latest_news", "categories_list"}
// document describes one output page for the shared page frame.
type document struct {
// lang is the language code of the page.
lang string
// id is the page ID; it is empty for news and category pages, which have
// no translation.
id string
// nav is the menu entry to mark as current; empty for none.
nav string
// lead is the footer lead template: "home", "back" or "news".
lead string
// path is the address of the page.
path string
// title is the title of the page as plain text.
title string
// prefixed puts "kmalloc.org: " before the title in the browser title.
prefixed bool
// description is the plain text of the description meta.
description string
// switches overrides the address of the language links, by language code.
switches map[string]string
// source names what produces the page, for error messages.
source string
}
// copyContext returns a copy of ctx.
func copyContext(ctx map[string]string) map[string]string {
out := make(map[string]string, len(ctx))
for k, v := range ctx {
out[k] = v
}
return out
}
// pageAddress returns the address of the page with this ID in lang, or in the
// default language when lang has no such page.
func (b *builder) pageAddress(lang, id string) string {
if p, ok := b.byKey[pageKey{id, lang}]; ok {
return p.Path
}
return b.byKey[pageKey{id, b.defaultLang}].Path
}
// languageContext returns the placeholders that depend on the language only:
// the site strings, the language strings (escaped), the menu labels and the
// addresses of the pages the templates link to.
func (b *builder) languageContext(lang string) map[string]string {
if cached, ok := b.langCtx[lang]; ok {
return copyContext(cached)
}
l := b.langs[lang]
ctx := copyContext(b.cfg.Strings)
for k, v := range l.Strings {
ctx[k] = render.Escape(v)
}
ctx["lang"] = lang
for k, label := range l.Nav {
ctx["nav_"+k] = render.Escape(label)
}
for _, id := range b.pageIDs {
if _, ok := b.byKey[pageKey{id, b.defaultLang}]; ok {
ctx["url_"+id] = b.pageAddress(lang, id)
}
}
ctx["history_attr"] = ""
if _, ok := b.byKey[pageKey{"history", lang}]; !ok {
ctx["history_attr"] = fmt.Sprintf(` hreflang="%s"`, b.defaultLang)
}
ctx["version_lc"] = render.Escape(strings.ToLower(l.Strings["version"]))
ctx["motorino_version"] = b.opts.Version
for _, name := range blockNames {
ctx[name] = "{{" + name + "}}"
}
b.langCtx[lang] = ctx
return copyContext(ctx)
}
// documentContext returns the placeholders of one page: the language ones plus
// the style, the address, the titles, the menu marks and the language links.
func (b *builder) documentContext(d document) map[string]string {
ctx := b.languageContext(d.lang)
ctx["css"] = b.css
ctx["path"] = d.path
docURL := b.cfg.Strings["base_url"] + d.path
ctx["doc_url"] = docURL
ctx["doc_q"] = strings.NewReplacer(":", "%3A", "/", "%2F").Replace(docURL)
title := d.title
if d.prefixed {
title = "kmalloc.org: " + title
}
ctx["title_html"] = render.EscapeAttr(title)
ctx["page_title"] = render.Escape(d.title)
ctx["description_attr"] = render.EscapeAttr(d.description)
for _, id := range b.pageIDs {
ctx["cur_"+id] = ""
if d.nav == id {
ctx["cur_"+id] = ` aria-current="page"`
}
}
ctx["lang_links"], ctx["alt_links"] = b.languageLinks(d)
return ctx
}
// languageLinks returns the links to the other languages for the menu and the
// alternate links for the head. A page without translations links to the home
// of the first other language that has one.
func (b *builder) languageLinks(d document) (links, alternates string) {
type target struct{ lang, path string }
var twins []target
if d.id != "" {
for _, l := range b.cfg.Languages {
if p, ok := b.byKey[pageKey{d.id, l}]; ok && l != d.lang {
twins = append(twins, target{l, p.Path})
}
}
}
if len(twins) == 0 {
for _, l := range b.cfg.Languages {
if p, ok := b.byKey[pageKey{"home", l}]; ok && l != d.lang {
twins = append(twins, target{l, p.Path})
break
}
}
}
anchors := make([]string, len(twins))
for i, t := range twins {
href := t.path
if override, ok := d.switches[t.lang]; ok {
href = override
}
anchors[i] = fmt.Sprintf(`<a href="%s" hreflang="%s" lang="%s">%s</a>`, render.EscapeAttr(href), t.lang, t.lang, render.Escape(b.langs[t.lang].Strings["lang_name"]))
}
links = strings.Join(anchors, "\n&middot;\n")
if d.id == "" {
return links, ""
}
var alts []string
for _, l := range b.cfg.Languages {
if p, ok := b.byKey[pageKey{d.id, l}]; ok {
alts = append(alts, fmt.Sprintf(`<link rel="alternate" hreflang="%s" href="%s">`, l, p.Path))
}
}
if len(alts) > 1 {
alternates = strings.Join(alts, "\n")
}
return links, alternates
}
// frame wraps the body of a page in the shared frame: lead, feed icon, badges,
// header, footer and the base template. It also records the page for the
// output and for robots.txt.
func (b *builder) frame(d document, ctx map[string]string, body string) error {
ctx["content"] = body
steps := []struct{ key, template string }{
{"lead", "lead-" + d.lead},
{"feed", "feed"},
{"badges", "badges"},
{"header", b.headerTemplate(d.lang)},
{"footer", "footer"},
}
for _, s := range steps {
tmpl, err := b.template(s.template)
if err != nil {
return err
}
text, err := render.Substitute("templates/"+s.template+".html", tmpl, ctx)
if err != nil {
return err
}
ctx[s.key] = text
}
base, err := b.template("base")
if err != nil {
return err
}
html, err := render.Substitute("templates/base.html", base, ctx)
if err != nil {
return err
}
if err := b.publish(outputPath(d.path), d.source, html); err != nil {
return err
}
b.indexable = append(b.indexable, d.path)
return nil
}
// headerTemplate returns the header template of a language: "header" unless
// its file says otherwise with the header key.
func (b *builder) headerTemplate(lang string) string {
if name := b.langs[lang].Strings["header"]; name != "" {
return name
}
return "header"
}