// 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", "news_blog", "news_archive"}
// sitePrefix goes before the title of a page that has no title of its own in the
// browser, such as a post.
const sitePrefix = "kmalloc.org: "
// 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 = sitePrefix + title
}
ctx["title_html"] = render.EscapeAttr(title)
ctx["page_title"] = render.Escape(d.title)
ctx["description_attr"] = render.EscapeAttr(d.description)
ctx["og_type"] = "website"
ctx["article_meta"] = ""
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
}
// langTarget is a page in another language that a page links to.
type langTarget struct{ lang, path string }
// languageTargets returns the pages in the other languages that a page links
// to: its translations, with the address a Switch key gives instead of the
// translation, or, when it has none, the home of the first other language that
// has one.
func (b *builder) languageTargets(d document) []langTarget {
var twins []langTarget
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, langTarget{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, langTarget{l, p.Path})
break
}
}
}
for i, t := range twins {
if override, ok := d.switches[t.lang]; ok {
twins[i].path = override
}
}
return twins
}
// languageLinks returns the links to the other languages for the menu and the
// alternate links for the head.
func (b *builder) languageLinks(d document) (links, alternates string) {
twins := b.languageTargets(d)
anchors := make([]string, len(twins))
for i, t := range twins {
anchors[i] = fmt.Sprintf(`%s`, render.EscapeAttr(t.path), t.lang, t.lang, render.Escape(b.langs[t.lang].Strings["lang_name"]))
}
links = strings.Join(anchors, "\n·\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(``, 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"
}