motorino/internal/content/pages.go
tgiachi 1298a98f30 fix: escape the title attribute, refuse clashing addresses and unsafe paths, check Switch
A quote in a title broke the og:title attribute (a regression from build.py).
Two sources that give the same output address now stop the build and name
both, instead of one replacing the other. Asset names and sources must be
paths inside the site, language codes must look like codes, and the Switch key
is escaped, must point to a path and may name only listed languages.
2026-11-15 10:03:58 +01:00

187 lines
5.7 KiB
Go

// SPDX-License-Identifier: GPL-3.0-or-later
package content
import (
"fmt"
"io/fs"
"os"
"path"
"path/filepath"
"strings"
"git.kmalloc.org/squid/motorino/internal/header"
"git.kmalloc.org/squid/motorino/internal/mdx"
)
// Page is a page of the site in one language.
type Page struct {
// Lang is the language code, such as "en".
Lang string
// ID names the page; the translations of a page share it.
ID string
// Path is the address of the page, such as "/services.html".
Path string
// Title, Description and Note come from the header.
Title, Description, Note string
// Layout is "page", "bare" or "manifesto".
Layout string
// Switch overrides the address of the language links, by language code.
Switch map[string]string
// ManifestoVersion and ManifestoDate, when set, replace the current
// manifesto version and date on this page: a translation of an older
// version says which one it translates.
ManifestoVersion, ManifestoDate string
// Source is the file the page was read from, relative to the site.
Source string
// Body is the Markdown after the header.
Body string
}
// pageKeys are the keys a page header may have.
var pageKeys = []string{"Title", "ID", "Description", "Layout", "Note", "Switch", "ManifestoVersion", "ManifestoDate"}
// layouts are the values of the Layout key; the first is the default.
var layouts = []string{"page", "bare", "manifesto"}
// PagePath returns the address of the page file rel, given with slashes and
// relative to the folder of its language. An index.md is the address of its
// folder; the default language lives at the root and the others under
// /<lang>/.
func PagePath(defaultLang, lang, rel string) string {
rel = strings.TrimSuffix(rel, ".md")
var p string
switch {
case rel == "index":
p = "/"
case strings.HasSuffix(rel, "/index"):
p = "/" + strings.TrimSuffix(rel, "index")
default:
p = "/" + rel + ".html"
}
if lang != defaultLang {
p = "/" + lang + p
}
return p
}
// LoadPages reads every Markdown file under content/<lang>/ for each language.
// The first language is the default. The em dash rule applies to every page
// except those with the manifesto layout, which is rewritten when it is built.
func LoadPages(dir string, languages []string) ([]Page, error) {
if len(languages) == 0 {
return nil, fmt.Errorf("no languages")
}
var pages []Page
for _, lang := range languages {
folder := path.Join("content", lang)
if info, err := os.Stat(filepath.Join(dir, filepath.FromSlash(folder))); err != nil || !info.IsDir() {
return nil, fmt.Errorf("%s: the folder of language %q is missing", folder, lang)
}
found, err := loadLanguagePages(dir, languages[0], lang, folder)
if err != nil {
return nil, err
}
pages = append(pages, found...)
}
return pages, nil
}
// loadLanguagePages reads the pages of one language and rejects duplicate IDs.
func loadLanguagePages(dir, defaultLang, lang, folder string) ([]Page, error) {
var pages []Page
seen := map[string]string{}
root := filepath.Join(dir, filepath.FromSlash(folder))
err := filepath.WalkDir(root, func(file string, d fs.DirEntry, err error) error {
if err != nil || d.IsDir() || !strings.HasSuffix(file, ".md") {
return err
}
rel, err := filepath.Rel(root, file)
if err != nil {
return err
}
rel = filepath.ToSlash(rel)
page, err := loadPage(file, path.Join(folder, rel), defaultLang, lang, rel)
if err != nil {
return err
}
if other, dup := seen[page.ID]; dup {
return fmt.Errorf("%s: the ID %q is also used by %s", page.Source, page.ID, other)
}
seen[page.ID] = page.Source
pages = append(pages, page)
return nil
})
return pages, err
}
// loadPage reads and checks one page file.
func loadPage(file, source, defaultLang, lang, rel string) (Page, error) {
data, err := os.ReadFile(file)
if err != nil {
return Page{}, fmt.Errorf("read %s: %w", source, err)
}
h, body, err := header.Parse(source, data)
if err != nil {
return Page{}, err
}
if err := h.Only(source, pageKeys...); err != nil {
return Page{}, err
}
if err := h.Require(source, "Title", "ID", "Description"); err != nil {
return Page{}, err
}
layout := h.Get("Layout")
if layout == "" {
layout = layouts[0]
}
if !contains(layouts, layout) {
return Page{}, fmt.Errorf("%s: unknown Layout %q (use %s)", source, layout, strings.Join(layouts, ", "))
}
if layout != "manifesto" {
if err := mdx.RejectEmDash(source, string(data)); err != nil {
return Page{}, err
}
}
switches, err := parseSwitch(source, h.Get("Switch"))
if err != nil {
return Page{}, err
}
return Page{
Lang: lang, ID: h.Get("ID"), Path: PagePath(defaultLang, lang, rel),
Title: h.Get("Title"), Description: h.Get("Description"), Note: h.Get("Note"),
Layout: layout, Switch: switches, Source: source, Body: body,
ManifestoVersion: h.Get("ManifestoVersion"), ManifestoDate: h.Get("ManifestoDate"),
}, nil
}
// parseSwitch reads "en=/path, de=/path" into a map; an empty value is an
// empty map.
func parseSwitch(source, value string) (map[string]string, error) {
out := map[string]string{}
if strings.TrimSpace(value) == "" {
return out, nil
}
for _, entry := range strings.Split(value, ",") {
lang, target, ok := strings.Cut(strings.TrimSpace(entry), "=")
lang, target = strings.TrimSpace(lang), strings.TrimSpace(target)
if !ok || lang == "" || !strings.HasPrefix(target, "/") {
return nil, fmt.Errorf("%s: Switch entry %q is not of the form lang=/path", source, strings.TrimSpace(entry))
}
if _, dup := out[lang]; dup {
return nil, fmt.Errorf("%s: Switch lists the language %q twice", source, lang)
}
out[lang] = target
}
return out, nil
}
// contains reports whether list has s.
func contains(list []string, s string) bool {
for _, item := range list {
if item == s {
return true
}
}
return false
}