News as blog posts: richer post page, blog list with pages, archives, drafts and motorino new #11
23 changed files with 2306 additions and 74 deletions
32
README.md
32
README.md
|
|
@ -8,11 +8,16 @@ Licence: GPL-3.0-or-later, see `LICENSE`.
|
|||
|
||||
```
|
||||
motorino build -site DIR -out DIR build the site in DIR into the output folder (defaults: . and public)
|
||||
motorino build -drafts ... the same, with the drafts and the posts dated in the future, for a preview
|
||||
motorino build -clean ... empty the output folder first, if it is new, empty or holds .motorino-out
|
||||
motorino new -site DIR "A title" write news/a-title.md, a draft with the header ready, and print its path
|
||||
motorino version print the version
|
||||
```
|
||||
|
||||
The binary is a single static Go program. The version comes from semantic-release.
|
||||
|
||||
A build writes the files it makes and leaves the others in the output folder, so the pages of a list that got shorter (`news/page/3/`) stay behind. When that happens the command prints a warning that names the old files. The deploy never has them: it builds into a new folder and publishes it with `rsync --delete`. For a folder you reuse, `-clean` empties it first. It does that only for a folder that is new, empty or holds the `.motorino-out` file that an earlier `-clean` left, never for any other folder with files in it and never for the folder of the site or one that holds it. A build without `-clean` writes no extra file.
|
||||
|
||||
## What a site looks like
|
||||
|
||||
```
|
||||
|
|
@ -38,11 +43,36 @@ Author: Matteo Bini
|
|||
Date: 2026-09-18T17:00:45+0200
|
||||
Categories: Linux Day, FLUG
|
||||
Description: An optional one-line summary.
|
||||
Mastodon: https://social.kmalloc.org/@squid/115000000000000000
|
||||
Language: it
|
||||
Draft: true
|
||||
-
|
||||
The text of the news.
|
||||
```
|
||||
|
||||
A news file `news/name.md` is published as `/news/YYYY/MM/name.html`, with the year and the month of `Date` as written. Every category gets a page, `/news/category/<name>.html`.
|
||||
A news file `news/name.md` is published as `/news/YYYY/MM/name.html`, with the year and the month of `Date` as written. Every category gets a page, `/news/category/<name>.html`. The optional keys:
|
||||
|
||||
- `Description`: the summary of the post. When it is written the post page shows it under the title; when it is not, the first sentence of the text is used for the meta description and the lists, and the page does not repeat it.
|
||||
- `Mastodon`: an `https` address, the post on Mastodon. The post page then has a link to reply there (the language needs `reply_mastodon`).
|
||||
- `Language`: the language the post is written in; the default is the language of the news (below).
|
||||
- `Draft`: `true` or `yes` keeps the post out of the site. So does a `Date` in the future, until that moment. `motorino build -drafts` publishes both, for a preview.
|
||||
|
||||
#### The news and their language
|
||||
|
||||
The news exist once, not once per language. Their language is `news_language` in `site.json`, else `en` when the site has it, else the default language. The news index page (`content/<lang>/news/index.md`, ID `news`) must be in that language; the posts, the lists, the archive, the categories and the feed are all in it, with the interface strings of its language file. A post can say another language with `Language`; its page then uses that language file. The other languages of the site link to the news from their home.
|
||||
|
||||
#### The blog
|
||||
|
||||
Everything below is opt in, so a site that does not use it builds as it did.
|
||||
|
||||
- **The post page** (`templates/post.html`) has, besides `post_title`, `date`, `post_body` and `post_byline`: `date_long` (such as "14 November 2026"), `post_summary` (the written description as a lead paragraph), `post_meta` (a line with the date, the author, the category links and the reading time), `post_reading`, `post_mastodon` (the reply link) and `post_nav` (the newer post, the older post and all the news). `og_type` is `article` there and `website` on every other page, and `article_meta` holds the published time and a tag for each category, for the head of `base.html`.
|
||||
- **The blog list**: a paragraph with only `{{news_blog}}` on the news index lists the posts as note panels (`<p class="note" role="note">`: a small line with the long date and the categories, the title in bold with a full stop unless it ends with `.`, `?` or `!`, the description, and a read more link named after the post), 10 to a page. The other pages are written under the index, at `page/2/`, `page/3/`, with a pager. The block needs an index page.
|
||||
- **The archive**: when `templates/archive.html` exists, every year and month with posts gets a page, `/news/2026/` and `/news/2026/11/`, with `archive_name`, `archive_nav` and `archive_posts`. The posts of an archive page, of a category page and of the blog list are the same panels; where the language has no `read_more` the title is the link instead, except on the blog list, where it is an error. `{{news_list}}` and the latest news of the home page stay plain lists. `{{news_archive}}` lists the years and the months with their counts, and needs the template.
|
||||
- **The feed** (`/news/feed.xml`) has the summary in `description` and the full text, with absolute links, in `content:encoded`, plus the categories and the author.
|
||||
|
||||
The strings come from the language files. These are required when the feature is used: `read_more`, `pager_label`, `pager_newer`, `pager_older` and `pager_page` (`Page {n} of {total}`) for the blog list, and `reply_mastodon` for a post with a Mastodon address. These are optional, and without them the feature is left out: `date_long` (`{d} {month} {y}`) and `month_01` to `month_12` (without them the date is `2026-11-14`), `date_month_year` (`{month} {y}`), `reading_time` (`{n} min read`), and `post_older`, `post_newer` and `post_nav` for the links between posts. The archive uses `archive_h` in its template and, optionally, `archive_up`.
|
||||
|
||||
A new post is a draft: `motorino new "A title"` writes `news/a-title.md` with the date of now and `Draft: true`, and the author from the `author` key of `site.json` when there is one.
|
||||
|
||||
Pages: `Title`, `ID` (the same in every language, it links the translations), `Description`, and optionally `Layout` (`page`, `bare` or `manifesto`), `Note`, `Switch` (`lang=/path, lang=/path`, overrides the language links) and `ManifestoVersion` and `ManifestoDate` (a translation of an older manifesto says which version it translates).
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,8 @@
|
|||
//
|
||||
// Usage:
|
||||
//
|
||||
// motorino build [-site DIR] [-out DIR]
|
||||
// motorino build [-site DIR] [-out DIR] [-drafts] [-clean]
|
||||
// motorino new [-site DIR] "title"
|
||||
// motorino version
|
||||
package main
|
||||
|
||||
|
|
@ -16,13 +17,16 @@ import (
|
|||
"io"
|
||||
"os"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.kmalloc.org/squid/motorino/internal/build"
|
||||
"git.kmalloc.org/squid/motorino/internal/content"
|
||||
"git.kmalloc.org/squid/motorino/internal/site"
|
||||
"git.kmalloc.org/squid/motorino/internal/version"
|
||||
)
|
||||
|
||||
// usage is the text printed for a missing or unknown command.
|
||||
const usage = "usage: motorino build [-site DIR] [-out DIR] | motorino version"
|
||||
const usage = "usage: motorino build [-site DIR] [-out DIR] [-drafts] [-clean] | motorino new [-site DIR] \"title\" | motorino version"
|
||||
|
||||
// main runs the command line and exits with its status code.
|
||||
func main() {
|
||||
|
|
@ -42,6 +46,8 @@ func run(args []string, stdout, stderr io.Writer) int {
|
|||
return 0
|
||||
case "build":
|
||||
return runBuild(args[1:], stdout, stderr)
|
||||
case "new":
|
||||
return runNew(args[1:], stdout, stderr)
|
||||
default:
|
||||
fmt.Fprintf(stderr, "motorino: unknown command %q\n%s\n", args[0], usage)
|
||||
return 2
|
||||
|
|
@ -54,6 +60,8 @@ func runBuild(args []string, stdout, stderr io.Writer) int {
|
|||
flags.SetOutput(stderr)
|
||||
site := flags.String("site", ".", "the folder of the site")
|
||||
out := flags.String("out", "public", "the folder the HTML is written to")
|
||||
drafts := flags.Bool("drafts", false, "publish the drafts and the posts dated in the future, for a preview")
|
||||
clean := flags.Bool("clean", false, "empty the output folder first, if it is new, empty or was emptied this way before")
|
||||
if err := flags.Parse(args); err != nil {
|
||||
if errors.Is(err, flag.ErrHelp) {
|
||||
return 0
|
||||
|
|
@ -64,11 +72,54 @@ func runBuild(args []string, stdout, stderr io.Writer) int {
|
|||
fmt.Fprintf(stderr, "motorino: unexpected arguments: %s\n%s\n", strings.Join(flags.Args(), " "), usage)
|
||||
return 2
|
||||
}
|
||||
result, err := build.Build(build.Options{SiteDir: *site, OutDir: *out, Version: version.String()})
|
||||
result, err := build.Build(build.Options{SiteDir: *site, OutDir: *out, Version: version.String(), Drafts: *drafts, Clean: *clean})
|
||||
if err != nil {
|
||||
fmt.Fprintf(stderr, "motorino: %v\n", err)
|
||||
return 1
|
||||
}
|
||||
fmt.Fprintf(stdout, "built %d pages into %s\n", result.Pages, *out)
|
||||
warnStale(stderr, *out, result.Stale)
|
||||
return 0
|
||||
}
|
||||
|
||||
// warnStale tells the files of the output folder that the build did not write,
|
||||
// which stay there unless -clean is used.
|
||||
func warnStale(stderr io.Writer, out string, stale []string) {
|
||||
if len(stale) == 0 {
|
||||
return
|
||||
}
|
||||
noun := "files"
|
||||
if len(stale) == 1 {
|
||||
noun = "file"
|
||||
}
|
||||
fmt.Fprintf(stderr, "motorino: warning: %d %s in %s were not written by this build, such as %s; build into a new folder or use -clean\n", len(stale), noun, out, stale[0])
|
||||
}
|
||||
|
||||
// runNew parses the flags of the new command and writes the file of a new post.
|
||||
// The author is the author key of site.json, when it has one.
|
||||
func runNew(args []string, stdout, stderr io.Writer) int {
|
||||
flags := flag.NewFlagSet("new", flag.ContinueOnError)
|
||||
flags.SetOutput(stderr)
|
||||
dir := flags.String("site", ".", "the folder of the site")
|
||||
if err := flags.Parse(args); err != nil {
|
||||
if errors.Is(err, flag.ErrHelp) {
|
||||
return 0
|
||||
}
|
||||
return 2
|
||||
}
|
||||
if flags.NArg() != 1 {
|
||||
fmt.Fprintf(stderr, "motorino: new takes one title\n%s\n", usage)
|
||||
return 2
|
||||
}
|
||||
author := ""
|
||||
if cfg, _, err := site.Load(*dir); err == nil {
|
||||
author = cfg.Strings["author"]
|
||||
}
|
||||
rel, err := content.NewPost(*dir, flags.Arg(0), author, time.Now())
|
||||
if err != nil {
|
||||
fmt.Fprintf(stderr, "motorino: %v\n", err)
|
||||
return 1
|
||||
}
|
||||
fmt.Fprintln(stdout, rel)
|
||||
return 0
|
||||
}
|
||||
|
|
|
|||
|
|
@ -122,3 +122,122 @@ func TestRunBuildBadFlag(t *testing.T) {
|
|||
t.Errorf("run(build -nope) = %d, want 2", code)
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunNewCreatesADraft checks the new command: it prints the file, writes a draft and
|
||||
// takes the author from site.json.
|
||||
func TestRunNewCreatesADraft(t *testing.T) {
|
||||
dir := miniSite(t)
|
||||
site := filepath.Join(dir, "site.json")
|
||||
if err := os.WriteFile(site, []byte(`{"base_url": "https://x.org", "languages": ["en"], "mastodon_url": "m", "motorino_url": "u", "author": "squid"}`), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var out, errOut bytes.Buffer
|
||||
if code := run([]string{"new", "-site", dir, "My first post"}, &out, &errOut); code != 0 {
|
||||
t.Fatalf("run(new) = %d, stderr %q", code, errOut.String())
|
||||
}
|
||||
if got := strings.TrimSpace(out.String()); got != "news/my-first-post.md" {
|
||||
t.Errorf("stdout = %q, want news/my-first-post.md", got)
|
||||
}
|
||||
data, err := os.ReadFile(filepath.Join(dir, "news", "my-first-post.md"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, want := range []string{"Title: My first post\n", "Author: squid\n", "Draft: true\n"} {
|
||||
if !strings.Contains(string(data), want) {
|
||||
t.Errorf("the file does not contain %q\n%s", want, data)
|
||||
}
|
||||
}
|
||||
if code := run([]string{"new", "-site", dir, "My first post"}, &out, &errOut); code != 1 || !strings.Contains(errOut.String(), "already exists") {
|
||||
t.Errorf("the same title again: code %d, stderr %q, want 1 and an error", code, errOut.String())
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunNewNeedsATitle checks the usage mistakes of the new command.
|
||||
func TestRunNewNeedsATitle(t *testing.T) {
|
||||
for _, args := range [][]string{{"new"}, {"new", "-site", t.TempDir()}, {"new", "one", "two"}} {
|
||||
var out, errOut bytes.Buffer
|
||||
if code := run(args, &out, &errOut); code != 2 || !strings.Contains(errOut.String(), "usage") {
|
||||
t.Errorf("run(%v) = %d, stderr %q, want 2 and the usage", args, code, errOut.String())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunBuildDraftsFlag checks that a draft is only published with -drafts.
|
||||
func TestRunBuildDraftsFlag(t *testing.T) {
|
||||
dir := miniSite(t)
|
||||
if err := os.MkdirAll(filepath.Join(dir, "news"), 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(dir, "news", "wip.md"), []byte("Title: Work in progress\nDate: 2026-01-01T12:00:00+0100\nDraft: true\n-\nSoon.\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var out, errOut bytes.Buffer
|
||||
plain := filepath.Join(t.TempDir(), "plain")
|
||||
if code := run([]string{"build", "-site", dir, "-out", plain}, &out, &errOut); code != 0 {
|
||||
t.Fatalf("build = %d, stderr %q", code, errOut.String())
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(plain, "news", "2026", "01", "wip.html")); err == nil {
|
||||
t.Error("a draft is published without -drafts")
|
||||
}
|
||||
preview := filepath.Join(t.TempDir(), "preview")
|
||||
if code := run([]string{"build", "-drafts", "-site", dir, "-out", preview}, &out, &errOut); code != 0 {
|
||||
t.Fatalf("build -drafts = %d, stderr %q", code, errOut.String())
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(preview, "news", "2026", "01", "wip.html")); err != nil {
|
||||
t.Errorf("a draft is missing from the build with -drafts: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunBuildWarnsAboutOldFiles checks that old files in the output folder are named in a warning and left alone.
|
||||
func TestRunBuildWarnsAboutOldFiles(t *testing.T) {
|
||||
site := miniSite(t)
|
||||
outDir := t.TempDir()
|
||||
if err := os.WriteFile(filepath.Join(outDir, "old.html"), []byte("old"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var out, errOut bytes.Buffer
|
||||
if code := run([]string{"build", "-site", site, "-out", outDir}, &out, &errOut); code != 0 {
|
||||
t.Fatalf("run(build) = %d, stderr %q", code, errOut.String())
|
||||
}
|
||||
for _, want := range []string{"warning", "1 file", "old.html", "-clean"} {
|
||||
if !strings.Contains(errOut.String(), want) {
|
||||
t.Errorf("stderr %q does not contain %q", errOut.String(), want)
|
||||
}
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(outDir, "old.html")); err != nil {
|
||||
t.Error("a build without -clean removed the old file")
|
||||
}
|
||||
errOut.Reset()
|
||||
if code := run([]string{"build", "-site", site, "-out", filepath.Join(t.TempDir(), "new")}, &out, &errOut); code != 0 || errOut.Len() != 0 {
|
||||
t.Errorf("a build into a new folder: code %d, stderr %q, want 0 and nothing", code, errOut.String())
|
||||
}
|
||||
}
|
||||
|
||||
// TestRunBuildClean checks -clean on a folder that is marked and on one that is not.
|
||||
func TestRunBuildClean(t *testing.T) {
|
||||
site := miniSite(t)
|
||||
var out, errOut bytes.Buffer
|
||||
outDir := filepath.Join(t.TempDir(), "public")
|
||||
if code := run([]string{"build", "-clean", "-site", site, "-out", outDir}, &out, &errOut); code != 0 {
|
||||
t.Fatalf("run(build -clean) into a new folder = %d, stderr %q", code, errOut.String())
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(outDir, "old.html"), []byte("old"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if code := run([]string{"build", "-clean", "-site", site, "-out", outDir}, &out, &errOut); code != 0 || errOut.Len() != 0 {
|
||||
t.Fatalf("run(build -clean) again = %d, stderr %q", code, errOut.String())
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(outDir, "old.html")); err == nil {
|
||||
t.Error("-clean left the old file")
|
||||
}
|
||||
other := t.TempDir()
|
||||
if err := os.WriteFile(filepath.Join(other, "mine.txt"), []byte("mine"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if code := run([]string{"build", "-clean", "-site", site, "-out", other}, &out, &errOut); code != 1 || !strings.Contains(errOut.String(), ".motorino-out") {
|
||||
t.Errorf("run(build -clean) into a folder that is not motorino's = %d, stderr %q, want 1 and the marker named", code, errOut.String())
|
||||
}
|
||||
if _, err := os.Stat(filepath.Join(other, "mine.txt")); err != nil {
|
||||
t.Error("-clean removed a file of a folder that is not motorino's")
|
||||
}
|
||||
}
|
||||
|
|
|
|||
239
internal/build/blog.go
Normal file
239
internal/build/blog.go
Normal file
|
|
@ -0,0 +1,239 @@
|
|||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
package build
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"git.kmalloc.org/squid/motorino/internal/content"
|
||||
"git.kmalloc.org/squid/motorino/internal/render"
|
||||
)
|
||||
|
||||
// newsPerPage is how many posts one page of the blog list has.
|
||||
const newsPerPage = 10
|
||||
|
||||
// pageCount returns how many pages n posts make: at least one.
|
||||
func pageCount(n int) int {
|
||||
if n <= newsPerPage {
|
||||
return 1
|
||||
}
|
||||
return (n + newsPerPage - 1) / newsPerPage
|
||||
}
|
||||
|
||||
// pagePath returns the address of page n of an index: the index itself for the
|
||||
// first page, then base + "page/2/", "page/3/" and so on. base ends with "/".
|
||||
func pagePath(base string, n int) string {
|
||||
if n <= 1 {
|
||||
return base
|
||||
}
|
||||
return base + "page/" + strconv.Itoa(n) + "/"
|
||||
}
|
||||
|
||||
// pageLabel is "Page 2 of 3" in the language lang, from the string pager_page.
|
||||
func (b *builder) pageLabel(lang string, n, total int) (string, error) {
|
||||
text := b.langs[lang].Strings["pager_page"]
|
||||
if text == "" {
|
||||
return "", fmt.Errorf("lang/%s.json: the language has no pager_page string, which the pages of the blog list need", lang)
|
||||
}
|
||||
return strings.NewReplacer("{n}", strconv.Itoa(n), "{total}", strconv.Itoa(total)).Replace(text), nil
|
||||
}
|
||||
|
||||
// newsBlog returns the page n of the blog list of the language lang, with the
|
||||
// pager when the list has more than one page. A site without posts gets the
|
||||
// news_empty text.
|
||||
func (b *builder) newsBlog(lang string, n int, ctx map[string]string) (string, error) {
|
||||
if len(b.posts) == 0 {
|
||||
return "<p>\n" + ctx["news_empty"] + "\n</p>", nil
|
||||
}
|
||||
total := pageCount(len(b.posts))
|
||||
if n < 1 || n > total {
|
||||
n = 1
|
||||
}
|
||||
end := n * newsPerPage
|
||||
if end > len(b.posts) {
|
||||
end = len(b.posts)
|
||||
}
|
||||
entries := make([]string, 0, newsPerPage)
|
||||
for _, p := range b.posts[(n-1)*newsPerPage : end] {
|
||||
entry, err := b.newsPanel(p, lang, true)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
entries = append(entries, entry)
|
||||
}
|
||||
html := strings.Join(entries, "\n")
|
||||
if total == 1 {
|
||||
return html, nil
|
||||
}
|
||||
pager, err := b.pager(lang, n, total)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
return html + "\n" + pager, nil
|
||||
}
|
||||
|
||||
// pager returns the navigation between the pages of the blog list.
|
||||
func (b *builder) pager(lang string, n, total int) (string, error) {
|
||||
l := b.langs[lang]
|
||||
label, newer, older := l.Strings["pager_label"], l.Strings["pager_newer"], l.Strings["pager_older"]
|
||||
if label == "" || newer == "" || older == "" {
|
||||
return "", fmt.Errorf("lang/%s.json: the language lacks pager_label, pager_newer or pager_older, which the pages of the blog list need", lang)
|
||||
}
|
||||
page, err := b.pageLabel(lang, n, total)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
var parts []string
|
||||
if n > 1 {
|
||||
parts = append(parts, fmt.Sprintf(`<a href="%s" rel="prev">%s</a>`, pagePath(b.newsPath, n-1), render.Escape(newer)))
|
||||
}
|
||||
parts = append(parts, render.Escape(page))
|
||||
if n < total {
|
||||
parts = append(parts, fmt.Sprintf(`<a href="%s" rel="next">%s</a>`, pagePath(b.newsPath, n+1), render.Escape(older)))
|
||||
}
|
||||
return fmt.Sprintf("<nav aria-label=\"%s\">\n<p>\n%s\n</p>\n</nav>", render.EscapeAttr(label), strings.Join(parts, "\n·\n")), nil
|
||||
}
|
||||
|
||||
// archiveMonth is the posts of one month; archiveYear the posts of one year.
|
||||
type (
|
||||
archiveMonth struct {
|
||||
year, month int
|
||||
posts []content.Post
|
||||
}
|
||||
archiveYear struct {
|
||||
year int
|
||||
posts []content.Post
|
||||
months []archiveMonth
|
||||
}
|
||||
)
|
||||
|
||||
// groupArchive groups posts by year and by month, as written in their dates.
|
||||
// The years and the months are newest first, and the posts of a group keep the
|
||||
// order they were given. A post is put in its group by its own year and month,
|
||||
// not by the group before it: two posts near midnight at the end of a month,
|
||||
// written with different offsets, can be in the order of their instants and in
|
||||
// the opposite order of their months.
|
||||
func groupArchive(posts []content.Post) []archiveYear {
|
||||
type key struct{ year, month int }
|
||||
years := map[int]*archiveYear{}
|
||||
months := map[key]*archiveMonth{}
|
||||
for _, p := range posts {
|
||||
y, m := p.Date.Year(), int(p.Date.Month())
|
||||
year := years[y]
|
||||
if year == nil {
|
||||
year = &archiveYear{year: y}
|
||||
years[y] = year
|
||||
}
|
||||
year.posts = append(year.posts, p)
|
||||
month := months[key{y, m}]
|
||||
if month == nil {
|
||||
month = &archiveMonth{year: y, month: m}
|
||||
months[key{y, m}] = month
|
||||
}
|
||||
month.posts = append(month.posts, p)
|
||||
}
|
||||
var out []archiveYear
|
||||
for _, year := range years {
|
||||
for k, month := range months {
|
||||
if k.year == year.year {
|
||||
year.months = append(year.months, *month)
|
||||
}
|
||||
}
|
||||
sort.Slice(year.months, func(i, j int) bool { return year.months[i].month > year.months[j].month })
|
||||
out = append(out, *year)
|
||||
}
|
||||
sort.Slice(out, func(i, j int) bool { return out[i].year > out[j].year })
|
||||
return out
|
||||
}
|
||||
|
||||
// yearPath and monthPath are the addresses of an archive year and month.
|
||||
func (b *builder) yearPath(year int) string { return fmt.Sprintf("%s%04d/", b.newsPath, year) }
|
||||
func (b *builder) monthPath(year, month int) string {
|
||||
return fmt.Sprintf("%s%04d/%02d/", b.newsPath, year, month)
|
||||
}
|
||||
|
||||
// hasArchive reports whether the site has the template of an archive page.
|
||||
func (b *builder) hasArchive() bool {
|
||||
_, ok := b.templates["archive"]
|
||||
return ok
|
||||
}
|
||||
|
||||
// monthList returns the list of the months of a year, each with its posts.
|
||||
func (b *builder) monthList(y archiveYear, lang string) string {
|
||||
items := make([]string, len(y.months))
|
||||
for i, m := range y.months {
|
||||
items[i] = fmt.Sprintf(`<li><a href="%s">%s</a> (%d)</li>`, b.monthPath(m.year, m.month), render.Escape(monthYear(m.year, m.month, b.langs[lang])), len(m.posts))
|
||||
}
|
||||
return "<ul>\n" + strings.Join(items, "\n") + "\n</ul>"
|
||||
}
|
||||
|
||||
// newsArchive returns the nested list of the years and the months that have
|
||||
// posts, or nothing when there are none: the blog list says there is no news. It
|
||||
// needs the archive pages.
|
||||
func (b *builder) newsArchive(lang string, ctx map[string]string) (string, error) {
|
||||
if _, err := b.template("archive"); err != nil {
|
||||
return "", fmt.Errorf("the {{news_archive}} block needs the archive pages: %w", err)
|
||||
}
|
||||
years := groupArchive(b.posts)
|
||||
if len(years) == 0 {
|
||||
return "", nil
|
||||
}
|
||||
items := make([]string, len(years))
|
||||
for i, y := range years {
|
||||
items[i] = fmt.Sprintf("<li><a href=\"%s\">%d</a> (%d)\n%s</li>", b.yearPath(y.year), y.year, len(y.posts), b.monthList(y, lang))
|
||||
}
|
||||
return "<ul>\n" + strings.Join(items, "\n") + "\n</ul>", nil
|
||||
}
|
||||
|
||||
// renderArchives writes the page of every year and every month that has posts,
|
||||
// when the site has templates/archive.html.
|
||||
func (b *builder) renderArchives() error {
|
||||
if !b.hasArchive() {
|
||||
return nil
|
||||
}
|
||||
tmpl, err := b.template("archive")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
lang := b.newsLang
|
||||
l := b.langs[lang]
|
||||
page := func(path, name, nav string, posts []content.Post, source string) error {
|
||||
d := document{
|
||||
lang: lang, nav: "news", lead: "news", path: path, title: name, prefixed: true,
|
||||
description: l.Strings["archive_h"] + ": " + name, source: source,
|
||||
}
|
||||
ctx := b.documentContext(d)
|
||||
ctx["archive_name"] = render.Escape(name)
|
||||
ctx["archive_nav"] = nav
|
||||
panels, err := b.newsPanels(posts, lang)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ctx["archive_posts"] = panels
|
||||
body, err := render.Substitute("templates/archive.html", tmpl, ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return b.frame(d, ctx, body)
|
||||
}
|
||||
for _, y := range groupArchive(b.posts) {
|
||||
year := strconv.Itoa(y.year)
|
||||
if err := page(b.yearPath(y.year), year, b.monthList(y, lang), y.posts, "the archive of "+year); err != nil {
|
||||
return err
|
||||
}
|
||||
up := ""
|
||||
if text := l.Strings["archive_up"]; text != "" {
|
||||
up = fmt.Sprintf("<p><a href=\"%s\">%s %s</a></p>", b.yearPath(y.year), render.Escape(text), year)
|
||||
}
|
||||
for _, m := range y.months {
|
||||
name := monthYear(m.year, m.month, l)
|
||||
if err := page(b.monthPath(m.year, m.month), name, up, m.posts, "the archive of "+name); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
706
internal/build/blog_test.go
Normal file
706
internal/build/blog_test.go
Normal file
|
|
@ -0,0 +1,706 @@
|
|||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
package build
|
||||
|
||||
import (
|
||||
"encoding/xml"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
// fixedNow is the moment the blog tests build at, so that drafts and future
|
||||
// dates do not depend on the clock.
|
||||
var fixedNow = time.Date(2026, 11, 15, 12, 0, 0, 0, time.FixedZone("CET", 3600))
|
||||
|
||||
// withFiles returns the base site with files added or replaced; an empty value removes the file.
|
||||
func withFiles(extra map[string]string) map[string]string {
|
||||
files := baseFiles()
|
||||
for name, content := range extra {
|
||||
if content == "" {
|
||||
delete(files, name)
|
||||
continue
|
||||
}
|
||||
files[name] = content
|
||||
}
|
||||
return files
|
||||
}
|
||||
|
||||
// buildWith builds the site made of files with the options changed by tune.
|
||||
func buildWith(t *testing.T, files map[string]string, tune func(*Options)) (string, error) {
|
||||
t.Helper()
|
||||
out := filepath.Join(t.TempDir(), "public")
|
||||
opts := Options{SiteDir: writeFiles(t, files), OutDir: out, Version: "1.2.3", Now: fixedNow}
|
||||
if tune != nil {
|
||||
tune(&opts)
|
||||
}
|
||||
_, err := Build(opts)
|
||||
return out, err
|
||||
}
|
||||
|
||||
// exists reports whether the output has the file rel.
|
||||
func exists(t *testing.T, out, rel string) bool {
|
||||
t.Helper()
|
||||
_, err := readOutMaybe(out, rel)
|
||||
return err == nil
|
||||
}
|
||||
|
||||
// postNews returns the news files used by the draft and future tests.
|
||||
func postNews() map[string]string {
|
||||
return map[string]string{
|
||||
"news/a-draft.md": "Title: A draft\nDate: 2026-11-10T12:00:00+0100\nCategories: Secret\nDraft: true\n-\nNot yet.\n",
|
||||
"news/in-future.md": "Title: In the future\nDate: 2026-12-24T12:00:00+0100\nCategories: Later\n-\nSoon.\n",
|
||||
}
|
||||
}
|
||||
|
||||
// TestDraftsAndFutureStayHidden checks that a draft and a post dated in the
|
||||
// future are not published anywhere, and that no category exists only for them.
|
||||
func TestDraftsAndFutureStayHidden(t *testing.T) {
|
||||
out, err := buildWith(t, withFiles(postNews()), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
for _, rel := range []string{"news/2026/11/a-draft.html", "news/2026/12/in-future.html", "news/category/secret.html", "news/category/later.html"} {
|
||||
if exists(t, out, rel) {
|
||||
t.Errorf("%s is published, but the post is hidden", rel)
|
||||
}
|
||||
}
|
||||
for _, rel := range []string{"news/index.html", "news/feed.xml", "index.html"} {
|
||||
got := readOut(t, out, rel)
|
||||
for _, hidden := range []string{"A draft", "In the future", "Secret", "Later"} {
|
||||
if strings.Contains(got, hidden) {
|
||||
t.Errorf("%s mentions %q, but the post is hidden", rel, hidden)
|
||||
}
|
||||
}
|
||||
}
|
||||
mustContain(t, "news index", readOut(t, out, "news/index.html"), "Status page")
|
||||
}
|
||||
|
||||
// TestDraftsFlagShowsHiddenPosts checks the preview build.
|
||||
func TestDraftsFlagShowsHiddenPosts(t *testing.T) {
|
||||
out, err := buildWith(t, withFiles(postNews()), func(o *Options) { o.Drafts = true })
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
for _, rel := range []string{"news/2026/11/a-draft.html", "news/2026/12/in-future.html", "news/category/secret.html"} {
|
||||
if !exists(t, out, rel) {
|
||||
t.Errorf("%s is missing from a build with drafts", rel)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestFuturePostAppearsWhenItsDateComes checks the moment of publication.
|
||||
func TestFuturePostAppearsWhenItsDateComes(t *testing.T) {
|
||||
later := time.Date(2026, 12, 24, 12, 0, 0, 0, time.FixedZone("CET", 3600))
|
||||
out, err := buildWith(t, withFiles(postNews()), func(o *Options) { o.Now = later })
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
if !exists(t, out, "news/2026/12/in-future.html") {
|
||||
t.Error("a post is published from the moment of its date")
|
||||
}
|
||||
if exists(t, out, "news/2026/11/a-draft.html") {
|
||||
t.Error("a draft stays hidden whatever the date")
|
||||
}
|
||||
}
|
||||
|
||||
// TestNewsLanguage checks the language of the news and its errors.
|
||||
func TestNewsLanguage(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
extra map[string]string
|
||||
want string
|
||||
}{
|
||||
{"unknown language in site.json", map[string]string{
|
||||
"site.json": strings.Replace(baseFiles()["site.json"], `"languages"`, `"news_language": "xx", "languages"`, 1)}, `news_language "xx"`},
|
||||
{"no news page in that language", map[string]string{
|
||||
"site.json": strings.Replace(baseFiles()["site.json"], `"languages"`, `"news_language": "it", "languages"`, 1)}, `content/it`},
|
||||
{"post in a language the site does not have", map[string]string{
|
||||
"news/tedesco.md": "Title: Deutsch\nDate: 2026-11-01T12:00:00+0100\nLanguage: de\n-\nText.\n"}, `Language "de"`},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
_, err := buildWith(t, withFiles(tt.extra), nil)
|
||||
if err == nil || !strings.Contains(err.Error(), tt.want) {
|
||||
t.Errorf("error = %v, want one that contains %q", err, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// monthsJSON writes the month_01..month_12 strings of a test language.
|
||||
func monthsJSON(names ...string) string {
|
||||
var b strings.Builder
|
||||
for i, n := range names {
|
||||
b.WriteString(`"month_` + string(rune('0'+(i+1)/10)) + string(rune('0'+(i+1)%10)) + `": "` + n + `", `)
|
||||
}
|
||||
return b.String()
|
||||
}
|
||||
|
||||
// blogLangEn and blogLangIt are the English and Italian language files with the strings the blog features need.
|
||||
var (
|
||||
blogLangEn = `{"lang_name": "English", "sections": "Sections", "home_link": "/", "nojs": "No JavaScript.",
|
||||
"powered_by": "Powered by", "back": "kmalloc.org", "version": "Version", "toc": "Contents", "history_a": "Manifesto history",
|
||||
"news_p": "What is new.", "news_all": "All news", "news_empty": "No news yet.", "category_h": "Category",
|
||||
"date_long": "{d} {month} {y}", "date_month_year": "{month} {y}", "reading_time": "{n} min read",
|
||||
` + monthsJSON("January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December") + `
|
||||
"post_older": "Older", "post_newer": "Newer", "post_nav": "Other news", "reply_mastodon": "Reply on Mastodon",
|
||||
"read_more": "Read more", "pager_label": "News pages", "pager_newer": "Newer news", "pager_older": "Older news", "pager_page": "Page {n} of {total}",
|
||||
"archive_h": "Archive", "archive_year_h": "Year", "archive_up": "Archive of the year",
|
||||
"nav": {"manifesto": "Manifesto", "people": "People", "services": "Services", "news": "News"}}`
|
||||
blogLangIt = `{"lang_name": "Italiano", "sections": "Sezioni", "home_link": "/it/", "nojs": "Niente JavaScript.",
|
||||
"powered_by": "Powered by", "back": "kmalloc.org", "version": "Versione", "toc": "Indice", "history_a": "Cronologia",
|
||||
"news_p": "Le novita.", "news_all": "Tutte le news", "news_empty": "Nessuna news.", "category_h": "Categoria",
|
||||
"date_long": "{d} {month} {y}", "date_month_year": "{month} {y}", "reading_time": "{n} min di lettura",
|
||||
` + monthsJSON("gennaio", "febbraio", "marzo", "aprile", "maggio", "giugno", "luglio", "agosto", "settembre", "ottobre", "novembre", "dicembre") + `
|
||||
"post_older": "Piu vecchia", "post_newer": "Piu recente", "post_nav": "Altre news", "reply_mastodon": "Rispondi su Mastodon",
|
||||
"read_more": "Leggi tutto", "pager_label": "Pagine delle news", "pager_newer": "News piu recenti", "pager_older": "News piu vecchie", "pager_page": "Pagina {n} di {total}",
|
||||
"archive_h": "Archivio", "archive_year_h": "Anno", "archive_up": "Archivio dell'anno",
|
||||
"nav": {"manifesto": "Manifesto", "people": "Persone", "services": "Servizi", "news": "News"}}`
|
||||
)
|
||||
|
||||
// blogPostTemplate is a post page that uses every placeholder of the blog.
|
||||
const blogPostTemplate = `<h1>{{post_title}}</h1>
|
||||
|
||||
{{post_summary}}
|
||||
{{post_meta}}
|
||||
{{post_body}}
|
||||
{{post_mastodon}}
|
||||
{{post_nav}}
|
||||
`
|
||||
|
||||
// blogBaseTemplate is the base template with the Open Graph placeholders.
|
||||
const blogBaseTemplate = `<!doctype html>
|
||||
<html lang="{{lang}}">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<title>{{title_html}}</title>
|
||||
<meta property="og:type" content="{{og_type}}">
|
||||
<meta property="og:title" content="{{title_html}}">
|
||||
{{article_meta}}
|
||||
<meta name="description" content="{{description_attr}}">
|
||||
{{alt_links}}
|
||||
<style>
|
||||
{{css}}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
{{header}}
|
||||
|
||||
{{content}}
|
||||
{{footer}}
|
||||
</body>
|
||||
</html>
|
||||
`
|
||||
|
||||
// blogSite is the base site with the blog language strings and templates.
|
||||
func blogSite(extra map[string]string) map[string]string {
|
||||
files := map[string]string{
|
||||
"lang/en.json": blogLangEn, "lang/it.json": blogLangIt,
|
||||
"templates/post.html": blogPostTemplate, "templates/base.html": blogBaseTemplate,
|
||||
"news/shop.md": "Title: A shop\nAuthor: squid\nDate: 2026-11-14T12:00:00+0100\nCategories: FLUG\nDescription: About the shop.\nMastodon: https://social.kmalloc.org/@squid/115\n-\nThere is a shop.\n",
|
||||
}
|
||||
for k, v := range extra {
|
||||
files[k] = v
|
||||
}
|
||||
return withFiles(files)
|
||||
}
|
||||
|
||||
// TestPostPageHasTheBlogFields checks the long date, the byline, the summary,
|
||||
// the reading time, the Mastodon link and the links to the other news.
|
||||
func TestPostPageHasTheBlogFields(t *testing.T) {
|
||||
out, err := buildWith(t, blogSite(nil), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
shop := readOut(t, out, "news/2026/11/shop.html")
|
||||
mustContain(t, "shop post", shop,
|
||||
`<p class="lede">About the shop.</p>`,
|
||||
`<p class="meta"><time datetime="2026-11-14">14 November 2026</time> · squid · <a href="/news/category/flug.html">FLUG</a> · 1 min read</p>`,
|
||||
`<p><a href="https://social.kmalloc.org/@squid/115" rel="noopener">Reply on Mastodon</a></p>`,
|
||||
`<nav aria-label="Other news">`,
|
||||
`<li><a href="/news/2026/11/status.html" rel="prev">Older: Status page</a></li>`,
|
||||
`<li><a href="/news/">All news</a></li>`,
|
||||
)
|
||||
if strings.Contains(shop, "Newer:") {
|
||||
t.Error("the newest post links to a newer one")
|
||||
}
|
||||
status := readOut(t, out, "news/2026/11/status.html")
|
||||
mustContain(t, "status post", status,
|
||||
`<p class="meta"><time datetime="2026-11-12">12 November 2026</time> · 1 min read</p>`,
|
||||
`<li><a href="/news/2026/11/shop.html" rel="next">Newer: A shop</a></li>`,
|
||||
`<li><a href="/news/2026/09/gnu-linux-day-2026.html" rel="prev">Older: GNU/Linux Day 2026</a></li>`,
|
||||
)
|
||||
for _, absent := range []string{"lede", "Reply on Mastodon"} {
|
||||
if strings.Contains(status, absent) {
|
||||
t.Errorf("a post without a written description or a Mastodon address shows %q", absent)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestPostPageSkipsFeaturesWithoutStrings checks that a language file without
|
||||
// the optional strings gives plain pages and not an error.
|
||||
func TestPostPageSkipsFeaturesWithoutStrings(t *testing.T) {
|
||||
files := blogSite(map[string]string{"lang/en.json": baseFiles()["lang/en.json"], "news/shop.md": baseFiles()["news/shop.md"]})
|
||||
out, err := buildWith(t, files, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
status := readOut(t, out, "news/2026/11/status.html")
|
||||
mustContain(t, "status post", status, `<time datetime="2026-11-12">2026-11-12</time>`)
|
||||
for _, absent := range []string{"min read", "<nav", "Older"} {
|
||||
if strings.Contains(status, absent) {
|
||||
t.Errorf("without the strings the page shows %q", absent)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestMastodonNeedsItsString checks that an address with no label is an error, not a silent omission.
|
||||
func TestMastodonNeedsItsString(t *testing.T) {
|
||||
files := blogSite(map[string]string{"lang/en.json": baseFiles()["lang/en.json"]})
|
||||
_, err := buildWith(t, files, nil)
|
||||
if err == nil || !strings.Contains(err.Error(), "reply_mastodon") {
|
||||
t.Errorf("error = %v, want one that names reply_mastodon", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPostInAnotherLanguage checks that a post with Language uses the strings and the page language of that language.
|
||||
func TestPostInAnotherLanguage(t *testing.T) {
|
||||
out, err := buildWith(t, blogSite(map[string]string{
|
||||
"news/ciao.md": "Title: Ciao\nDate: 2026-11-05T09:00:00+0100\nLanguage: it\n-\nUn testo.\n"}), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
ciao := readOut(t, out, "news/2026/11/ciao.html")
|
||||
mustContain(t, "italian post", ciao, `<html lang="it">`, `5 novembre 2026`, `1 min di lettura`, `<nav aria-label="Altre news">`)
|
||||
list := readOut(t, out, "news/index.html")
|
||||
mustContain(t, "news index", list, `hreflang="it" lang="it">Ciao</a>`)
|
||||
if strings.Contains(list, `hreflang="en"`) {
|
||||
t.Error("an English post on the English index is marked as another language")
|
||||
}
|
||||
}
|
||||
|
||||
// TestPostOpenGraphArticle checks og:type and the article meta on posts only.
|
||||
func TestPostOpenGraphArticle(t *testing.T) {
|
||||
out, err := buildWith(t, blogSite(nil), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
mustContain(t, "post", readOut(t, out, "news/2026/09/gnu-linux-day-2026.html"),
|
||||
`<meta property="og:type" content="article">`,
|
||||
`<meta property="article:published_time" content="2026-09-18T17:00:45+02:00">`,
|
||||
`<meta property="article:tag" content="Linux Day">`,
|
||||
`<meta property="article:tag" content="FLUG">`)
|
||||
for _, rel := range []string{"index.html", "news/index.html", "news/category/flug.html", "it/index.html"} {
|
||||
got := readOut(t, out, rel)
|
||||
mustContain(t, rel, got, `<meta property="og:type" content="website">`)
|
||||
if strings.Contains(got, "article:") {
|
||||
t.Errorf("%s has article meta", rel)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// blogIndex is a news index that uses the blog list and the archive.
|
||||
const blogIndex = "Title: News\nID: news\nDescription: About News.\n-\n# News\n\n{{news_blog}}\n\n## Archive\n\n{{news_archive}}\n"
|
||||
|
||||
// archiveTemplate is the page of a year or a month of the archive.
|
||||
const archiveTemplate = "<h1>{{archive_h}}: {{archive_name}}</h1>\n\n{{archive_nav}}\n\n{{archive_posts}}\n"
|
||||
|
||||
// manyPosts adds n posts, dated one per day from 2026-10-01, to the files.
|
||||
func manyPosts(files map[string]string, n int) map[string]string {
|
||||
for i := 1; i <= n; i++ {
|
||||
day := "2026-10-" + string(rune('0'+i/10)) + string(rune('0'+i%10))
|
||||
name := "p" + string(rune('0'+i/10)) + string(rune('0'+i%10))
|
||||
files["news/"+name+".md"] = "Title: Post " + name[1:] + "\nDate: " + day + "T12:00:00+0100\nCategories: Many\n-\nText of " + name + ".\n"
|
||||
}
|
||||
return files
|
||||
}
|
||||
|
||||
// TestNewsBlogEntries checks one entry of the blog list and the absence of a pager for a short list.
|
||||
func TestNewsBlogEntries(t *testing.T) {
|
||||
out, err := buildWith(t, blogSite(map[string]string{"content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate}), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
index := readOut(t, out, "news/index.html")
|
||||
mustContain(t, "news index", index,
|
||||
"<p class=\"note\" role=\"note\">\n"+
|
||||
`<span class="meta"><time datetime="2026-11-14">14 November 2026</time> · <a href="/news/category/flug.html">FLUG</a></span><br>`+"\n"+
|
||||
"<strong>A shop.</strong>\n"+
|
||||
"About the shop.\n"+
|
||||
`<a href="/news/2026/11/shop.html" aria-label="Read more: A shop">Read more</a>.`+"\n</p>",
|
||||
// a post with two categories, and one with a description made of its first sentence
|
||||
`<a href="/news/category/linux-day.html">Linux Day</a>, <a href="/news/category/flug.html">FLUG</a></span><br>`,
|
||||
`<strong>Status page.</strong>`,
|
||||
)
|
||||
if got := strings.Count(index, `role="note"`); got != 3 {
|
||||
t.Errorf("the index has %d panels, want 3", got)
|
||||
}
|
||||
if strings.Contains(index, "<article") {
|
||||
t.Error("the index has an article element, the panels replaced them")
|
||||
}
|
||||
if strings.Contains(index, "News pages") {
|
||||
t.Error("a list that fits one page has a pager")
|
||||
}
|
||||
}
|
||||
|
||||
// TestNewsBlogPagination checks the pages of a long list.
|
||||
func TestNewsBlogPagination(t *testing.T) {
|
||||
files := blogSite(map[string]string{"content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate})
|
||||
out, err := buildWith(t, manyPosts(files, 22), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
first := readOut(t, out, "news/index.html")
|
||||
mustContain(t, "page 1", first, `<nav aria-label="News pages">`, `Page 1 of 3`, `<a href="/news/page/2/" rel="next">Older news</a>`)
|
||||
if strings.Contains(first, `rel="prev"`) || strings.Count(first, `role="note"`) != 10 || !strings.Contains(first, "Post 15") || strings.Contains(first, "Post 14") {
|
||||
t.Errorf("page 1 is wrong:\n%s", first)
|
||||
}
|
||||
second := readOut(t, out, "news/page/2/index.html")
|
||||
mustContain(t, "page 2", second, `Page 2 of 3`, `<a href="/news/" rel="prev">Newer news</a>`, `<a href="/news/page/3/" rel="next">Older news</a>`,
|
||||
"<title>News, Page 2 of 3</title>", "Post 14", "Post 05")
|
||||
if strings.Count(second, `role="note"`) != 10 || strings.Contains(second, "Post 15") || strings.Contains(second, "Post 04") {
|
||||
t.Errorf("page 2 is wrong:\n%s", second)
|
||||
}
|
||||
third := readOut(t, out, "news/page/3/index.html")
|
||||
mustContain(t, "page 3", third, `Page 3 of 3`, `<a href="/news/page/2/" rel="prev">Newer news</a>`, "GNU/Linux Day 2026")
|
||||
if strings.Contains(third, `rel="next"`) || strings.Count(third, `role="note"`) != 5 {
|
||||
t.Errorf("page 3 is wrong:\n%s", third)
|
||||
}
|
||||
if exists(t, out, "news/page/4/index.html") || exists(t, out, "news/page/1/index.html") {
|
||||
t.Error("there is a page 4 or a page 1 under /news/page/")
|
||||
}
|
||||
robots := readOut(t, out, "robots.txt")
|
||||
mustContain(t, "robots.txt", robots, "/news/page/2/")
|
||||
}
|
||||
|
||||
// TestNewsBlogNeedsItsStrings checks that a blog list without read_more is an error.
|
||||
func TestNewsBlogNeedsItsStrings(t *testing.T) {
|
||||
files := blogSite(map[string]string{"content/en/news/index.md": blogIndex, "lang/en.json": strings.Replace(blogLangEn, `"read_more": "Read more", `, "", 1), "templates/archive.html": archiveTemplate})
|
||||
_, err := buildWith(t, files, nil)
|
||||
if err == nil || !strings.Contains(err.Error(), "read_more") {
|
||||
t.Errorf("error = %v, want one that names read_more", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestNewsBlogOnlyOnAnIndex checks that the blog list needs an index page.
|
||||
func TestNewsBlogOnlyOnAnIndex(t *testing.T) {
|
||||
files := blogSite(map[string]string{"content/en/news/index.md": blogIndex, "content/en/extra.md": page("extra", "Extra", "", "{{news_blog}}\n"), "templates/archive.html": archiveTemplate})
|
||||
_, err := buildWith(t, files, nil)
|
||||
if err == nil || !strings.Contains(err.Error(), "index") {
|
||||
t.Errorf("error = %v, want one about an index page", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestArchivePages checks the pages of a year and of a month, and the block.
|
||||
func TestArchivePages(t *testing.T) {
|
||||
out, err := buildWith(t, blogSite(map[string]string{"content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate}), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
mustContain(t, "news index", readOut(t, out, "news/index.html"),
|
||||
`<li><a href="/news/2026/">2026</a> (3)`,
|
||||
`<li><a href="/news/2026/11/">November 2026</a> (2)</li>`,
|
||||
`<li><a href="/news/2026/09/">September 2026</a> (1)</li>`)
|
||||
year := readOut(t, out, "news/2026/index.html")
|
||||
mustContain(t, "year", year, "<h1>Archive: 2026</h1>", `<a href="/news/2026/11/">November 2026</a> (2)`, "A shop", "Status page", "GNU/Linux Day 2026")
|
||||
month := readOut(t, out, "news/2026/11/index.html")
|
||||
mustContain(t, "month", month, "<h1>Archive: November 2026</h1>", `<a href="/news/2026/">Archive of the year 2026</a>`, "A shop", "Status page")
|
||||
if strings.Contains(month, "GNU/Linux Day 2026") {
|
||||
t.Error("the month of November lists a post of September")
|
||||
}
|
||||
if exists(t, out, "news/2026/12/index.html") || exists(t, out, "news/2025/index.html") {
|
||||
t.Error("an archive page exists for a month or a year without posts")
|
||||
}
|
||||
}
|
||||
|
||||
// TestNoArchiveWithoutTemplate checks that the archive is opt in, and that its block then is an error.
|
||||
func TestNoArchiveWithoutTemplate(t *testing.T) {
|
||||
out, err := buildWith(t, blogSite(map[string]string{"content/en/news/index.md": strings.Replace(blogIndex, "{{news_archive}}", "", 1)}), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
if exists(t, out, "news/2026/index.html") {
|
||||
t.Error("an archive page is built without templates/archive.html")
|
||||
}
|
||||
_, err = buildWith(t, blogSite(map[string]string{"content/en/news/index.md": blogIndex}), nil)
|
||||
if err == nil || !strings.Contains(err.Error(), "archive") {
|
||||
t.Errorf("error = %v, want one that names the archive template", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestNewsPanelTitlePunctuation checks the full stop after the title of a panel: added, unless the title ends with one, a question mark or an exclamation mark.
|
||||
func TestNewsPanelTitlePunctuation(t *testing.T) {
|
||||
files := blogSite(map[string]string{"content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate,
|
||||
"news/q.md": "Title: Why a shop?\nDate: 2026-11-01T12:00:00+0100\n-\nText.\n",
|
||||
"news/e.md": "Title: It is open!\nDate: 2026-11-02T12:00:00+0100\n-\nText.\n",
|
||||
"news/d.md": "Title: Done.\nDate: 2026-11-03T12:00:00+0100\n-\nText.\n",
|
||||
"news/a.md": "Title: Tom & Jerry\nDate: 2026-11-04T12:00:00+0100\n-\nText.\n"})
|
||||
out, err := buildWith(t, files, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
index := readOut(t, out, "news/index.html")
|
||||
mustContain(t, "news index", index, "<strong>Why a shop?</strong>", "<strong>It is open!</strong>", "<strong>Done.</strong>", "<strong>Tom & Jerry.</strong>",
|
||||
`aria-label="Read more: Tom & Jerry"`)
|
||||
for _, wrong := range []string{"shop?.", "open!.", "Done..", "Done.</strong>."} {
|
||||
if strings.Contains(index, wrong) {
|
||||
t.Errorf("the index has %q", wrong)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestNewsPanelWithoutCategoriesOrDescription checks the two optional lines of a panel.
|
||||
func TestNewsPanelWithoutCategoriesOrDescription(t *testing.T) {
|
||||
out, err := buildWith(t, blogSite(map[string]string{"content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate,
|
||||
"news/bare.md": "Title: Bare\nDate: 2026-11-13T12:00:00+0100\nDescription:\n-\n"}), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
mustContain(t, "news index", readOut(t, out, "news/index.html"),
|
||||
"<p class=\"note\" role=\"note\">\n"+
|
||||
`<span class="meta"><time datetime="2026-11-13">13 November 2026</time></span><br>`+"\n"+
|
||||
"<strong>Bare.</strong>\n"+
|
||||
`<a href="/news/2026/11/bare.html" aria-label="Read more: Bare">Read more</a>.`+"\n</p>")
|
||||
}
|
||||
|
||||
// TestPanelsOnCategoryAndArchivePages checks that the lists of the categories and of the archives are panels too,
|
||||
// and that the page of a post and the latest news of the home page are not.
|
||||
func TestPanelsOnCategoryAndArchivePages(t *testing.T) {
|
||||
out, err := buildWith(t, blogSite(map[string]string{"content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate}), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
shop := "<strong>A shop.</strong>\nAbout the shop.\n" + `<a href="/news/2026/11/shop.html" aria-label="Read more: A shop">Read more</a>.`
|
||||
for rel, want := range map[string]int{"news/category/flug.html": 2, "news/2026/index.html": 3, "news/2026/11/index.html": 2} {
|
||||
got := readOut(t, out, rel)
|
||||
if n := strings.Count(got, `role="note"`); n != want {
|
||||
t.Errorf("%s has %d panels, want %d", rel, n, want)
|
||||
}
|
||||
if !strings.Contains(got, shop) {
|
||||
t.Errorf("%s lacks the panel of the shop post", rel)
|
||||
}
|
||||
if strings.Contains(got, "<li><time") {
|
||||
t.Errorf("%s still has the list of dates", rel)
|
||||
}
|
||||
}
|
||||
if post := readOut(t, out, "news/2026/11/shop.html"); strings.Contains(post, `role="note"`) {
|
||||
t.Error("the page of a post has a panel")
|
||||
}
|
||||
if home := readOut(t, out, "index.html"); strings.Contains(home, `role="note"`) || !strings.Contains(home, "<li><time") {
|
||||
t.Error("the latest news of the home page changed")
|
||||
}
|
||||
}
|
||||
|
||||
// TestPanelsWithoutReadMore checks that a language without read_more gets panels whose title is the link on the
|
||||
// category and archive pages, as before the panels, and an error on the blog list, which has no other link.
|
||||
func TestPanelsWithoutReadMore(t *testing.T) {
|
||||
withoutMore := strings.Replace(blogLangEn, `"read_more": "Read more", `, "", 1)
|
||||
out, err := buildWith(t, blogSite(map[string]string{"lang/en.json": withoutMore, "templates/archive.html": archiveTemplate}), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
for _, rel := range []string{"news/category/flug.html", "news/2026/11/index.html"} {
|
||||
got := readOut(t, out, rel)
|
||||
mustContain(t, rel, got, `<strong><a href="/news/2026/11/shop.html">A shop.</a></strong>`+"\nAbout the shop.\n</p>")
|
||||
if strings.Contains(got, "aria-label") || strings.Contains(got, "Read more") {
|
||||
t.Errorf("%s has a read more link without the string", rel)
|
||||
}
|
||||
}
|
||||
_, err = buildWith(t, blogSite(map[string]string{"lang/en.json": withoutMore, "content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate}), nil)
|
||||
if err == nil || !strings.Contains(err.Error(), "read_more") {
|
||||
t.Errorf("error = %v, want one that names read_more", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPanelOfAPostInAnotherLanguage checks that the link of a panel says the language of a post that is not in the language of the page.
|
||||
func TestPanelOfAPostInAnotherLanguage(t *testing.T) {
|
||||
out, err := buildWith(t, blogSite(map[string]string{"content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate,
|
||||
"news/ciao.md": "Title: Ciao\nDate: 2026-11-05T09:00:00+0100\nLanguage: it\n-\nUn testo.\n"}), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
index := readOut(t, out, "news/index.html")
|
||||
mustContain(t, "news index", index, `<a href="/news/2026/11/ciao.html" aria-label="Read more: Ciao" hreflang="it" lang="it">Read more</a>.`)
|
||||
if strings.Count(index, `hreflang="it" lang="it">Read more`) != 1 {
|
||||
t.Error("an English post is marked as written in Italian")
|
||||
}
|
||||
}
|
||||
|
||||
// TestArchiveGroupsByTheDateAsWritten checks that two posts either side of midnight, written with different
|
||||
// offsets, land in their own months and that no month is listed twice, whatever the order of the instants.
|
||||
func TestArchiveGroupsByTheDateAsWritten(t *testing.T) {
|
||||
files := blogSite(map[string]string{"content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate,
|
||||
"news/late.md": "Title: Late\nDate: 2026-11-30T23:45:00+0000\n-\nText.\n",
|
||||
"news/early.md": "Title: Early\nDate: 2026-12-01T00:30:00+0100\n-\nText.\n",
|
||||
"news/mid.md": "Title: Mid\nDate: 2026-11-29T12:00:00+0100\n-\nText.\n"})
|
||||
out, err := buildWith(t, files, func(o *Options) { o.Now = time.Date(2026, 12, 20, 12, 0, 0, 0, time.UTC) })
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
index := readOut(t, out, "news/index.html")
|
||||
mustContain(t, "news index", index, `<a href="/news/2026/">2026</a> (6)`)
|
||||
dec, nov, sep := strings.Index(index, ">December 2026</a> (1)"), strings.Index(index, ">November 2026</a> (4)"), strings.Index(index, ">September 2026</a> (1)")
|
||||
if dec < 0 || nov < dec || sep < nov {
|
||||
t.Errorf("the months are not December, November, September, one each:\n%s", index)
|
||||
}
|
||||
if strings.Count(index, "November 2026</a>") != 1 {
|
||||
t.Error("November is listed more than once")
|
||||
}
|
||||
month := readOut(t, out, "news/2026/11/index.html")
|
||||
late, mid, shop := strings.Index(month, "<strong>Late.</strong>"), strings.Index(month, "<strong>Mid.</strong>"), strings.Index(month, "<strong>A shop.</strong>")
|
||||
if late < 0 || mid < late || shop < mid || strings.Contains(month, "<strong>Early.</strong>") {
|
||||
t.Errorf("the month of November is wrong:\n%s", month)
|
||||
}
|
||||
mustContain(t, "month of December", readOut(t, out, "news/2026/12/index.html"), "<strong>Early.</strong>")
|
||||
}
|
||||
|
||||
// TestNoNewsAtAll checks that a site without posts says so once, and that the empty lists take their headings with them.
|
||||
func TestNoNewsAtAll(t *testing.T) {
|
||||
index := "Title: News\nID: news\nDescription: About News.\n-\n# News\n\n{{news_blog}}\n\n## Categories\n\n{{categories_list}}\n\n## Archive\n\n{{news_archive}}\n"
|
||||
files := blogSite(map[string]string{"content/en/news/index.md": index, "templates/archive.html": archiveTemplate,
|
||||
"news/shop.md": "", "news/gnu-linux-day-2026.md": "", "news/status.md": ""})
|
||||
out, err := buildWith(t, files, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
got := readOut(t, out, "news/index.html")
|
||||
if n := strings.Count(got, "No news yet."); n != 1 {
|
||||
t.Errorf("the index says there is no news %d times, want once:\n%s", n, got)
|
||||
}
|
||||
for _, heading := range []string{">Categories</h2>", ">Archive</h2>"} {
|
||||
if strings.Contains(got, heading) {
|
||||
t.Errorf("the index keeps the heading %q of an empty list", heading)
|
||||
}
|
||||
}
|
||||
mustContain(t, "news index", got, "<h1>News</h1>")
|
||||
}
|
||||
|
||||
// TestHomeKeepsItsHeadingWithoutNews checks that the heading before the latest news is the page's own and stays.
|
||||
func TestHomeKeepsItsHeadingWithoutNews(t *testing.T) {
|
||||
files := blogSite(map[string]string{"news/shop.md": "", "news/gnu-linux-day-2026.md": "", "news/status.md": ""})
|
||||
out, err := buildWith(t, files, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
mustContain(t, "home", readOut(t, out, "index.html"), `<h1 class="hero">Technology.</h1>`)
|
||||
}
|
||||
|
||||
// TestHeadingStaysWithAListThatHasItems checks that the heading of a generated list is dropped only when the list is empty.
|
||||
func TestHeadingStaysWithAListThatHasItems(t *testing.T) {
|
||||
index := "Title: News\nID: news\nDescription: About News.\n-\n# News\n\n## Categories\n\n{{categories_list}}\n\n## Archive\n\n{{news_archive}}\n"
|
||||
out, err := buildWith(t, blogSite(map[string]string{"content/en/news/index.md": index, "templates/archive.html": archiveTemplate}), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
mustContain(t, "news index", readOut(t, out, "news/index.html"), ">Categories</h2>", ">Archive</h2>")
|
||||
}
|
||||
|
||||
// listFiles returns the site of the pagination tests: the three base posts and extra ones, so that n posts in all.
|
||||
func listFiles(t *testing.T, n int) map[string]string {
|
||||
t.Helper()
|
||||
files := blogSite(map[string]string{"content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate})
|
||||
return manyPosts(files, n-3)
|
||||
}
|
||||
|
||||
// TestExactlyOnePageOfPosts checks that ten posts make one page with no pager and no second page.
|
||||
func TestExactlyOnePageOfPosts(t *testing.T) {
|
||||
out, err := buildWith(t, listFiles(t, 10), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
index := readOut(t, out, "news/index.html")
|
||||
if n := strings.Count(index, `role="note"`); n != 10 {
|
||||
t.Errorf("the index has %d panels, want 10", n)
|
||||
}
|
||||
if strings.Contains(index, "News pages") || strings.Contains(index, "Page 1 of") || exists(t, out, "news/page/2/index.html") {
|
||||
t.Error("ten posts have a pager or a second page")
|
||||
}
|
||||
}
|
||||
|
||||
// TestEleventhPostIsAloneOnPageTwo checks the page that holds the one post that does not fit.
|
||||
func TestEleventhPostIsAloneOnPageTwo(t *testing.T) {
|
||||
out, err := buildWith(t, listFiles(t, 11), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
first := readOut(t, out, "news/index.html")
|
||||
mustContain(t, "page 1", first, "Page 1 of 2", `<a href="/news/page/2/" rel="next">Older news</a>`)
|
||||
if n := strings.Count(first, `role="note"`); n != 10 || strings.Contains(first, "GNU/Linux Day 2026.") {
|
||||
t.Errorf("page 1 has %d panels or the oldest post", n)
|
||||
}
|
||||
second := readOut(t, out, "news/page/2/index.html")
|
||||
mustContain(t, "page 2", second, "Page 2 of 2", `<a href="/news/" rel="prev">Newer news</a>`, "<strong>GNU/Linux Day 2026.</strong>")
|
||||
if n := strings.Count(second, `role="note"`); n != 1 || strings.Contains(second, `rel="next"`) {
|
||||
t.Errorf("page 2 has %d panels or a link to a third page", n)
|
||||
}
|
||||
if exists(t, out, "news/page/3/index.html") {
|
||||
t.Error("eleven posts have a third page")
|
||||
}
|
||||
}
|
||||
|
||||
// TestOnlyOnePost checks that the one post has no link to a newer or an older post anywhere, and no pager.
|
||||
func TestOnlyOnePost(t *testing.T) {
|
||||
files := blogSite(map[string]string{"content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate,
|
||||
"news/gnu-linux-day-2026.md": "", "news/status.md": ""})
|
||||
out, err := buildWith(t, files, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
for _, rel := range []string{"news/2026/11/shop.html", "news/index.html", "news/2026/11/index.html"} {
|
||||
got := readOut(t, out, rel)
|
||||
for _, absent := range []string{"Older", "Newer", `rel="prev"`, `rel="next"`, "News pages"} {
|
||||
if strings.Contains(got, absent) {
|
||||
t.Errorf("%s has %q, but there is one post", rel, absent)
|
||||
}
|
||||
}
|
||||
}
|
||||
mustContain(t, "the post", readOut(t, out, "news/2026/11/shop.html"), `<li><a href="/news/">All news</a></li>`)
|
||||
}
|
||||
|
||||
// TestUnusualTitle checks that a title with quotes, an ampersand, a tag and non Latin letters is escaped everywhere.
|
||||
func TestUnusualTitle(t *testing.T) {
|
||||
title := `Say "hi" & <b>go</b> ünï 日本語`
|
||||
files := blogSite(map[string]string{"content/en/news/index.md": blogIndex, "templates/archive.html": archiveTemplate,
|
||||
"news/odd.md": "Title: " + title + "\nDate: 2026-11-15T09:00:00+0100\nCategories: Odd\n-\nText.\n"})
|
||||
out, err := buildWith(t, files, nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
escaped := `Say "hi" & <b>go</b> ünï 日本語`
|
||||
attr := `Say "hi" & <b>go</b> ünï 日本語`
|
||||
for _, rel := range []string{"news/index.html", "news/category/odd.html", "news/2026/11/index.html"} {
|
||||
mustContain(t, rel, readOut(t, out, rel), "<strong>"+escaped+".</strong>", `aria-label="Read more: `+attr+`"`)
|
||||
}
|
||||
mustContain(t, "the post", readOut(t, out, "news/2026/11/odd.html"), "<h1>"+escaped+"</h1>")
|
||||
mustContain(t, "the post below", readOut(t, out, "news/2026/11/shop.html"), `Newer: `+escaped)
|
||||
for _, rel := range []string{"news/index.html", "news/category/odd.html", "news/2026/11/odd.html", "news/feed.xml"} {
|
||||
if strings.Contains(readOut(t, out, rel), "<b>go</b>") {
|
||||
t.Errorf("%s has the tag of the title as markup", rel)
|
||||
}
|
||||
}
|
||||
var feed struct {
|
||||
Channel struct {
|
||||
Items []struct {
|
||||
Title string `xml:"title"`
|
||||
} `xml:"item"`
|
||||
} `xml:"channel"`
|
||||
}
|
||||
if err := xml.Unmarshal([]byte(readOut(t, out, "news/feed.xml")), &feed); err != nil {
|
||||
t.Fatalf("the feed is not well formed: %v", err)
|
||||
}
|
||||
if len(feed.Channel.Items) == 0 || feed.Channel.Items[0].Title != title {
|
||||
t.Errorf("the first item of the feed is %+v, want the title %q", feed.Channel.Items, title)
|
||||
}
|
||||
}
|
||||
|
||||
// TestNeighbourInAnotherLanguageIsMarked checks that the link to an older post in another language names the language.
|
||||
func TestNeighbourInAnotherLanguageIsMarked(t *testing.T) {
|
||||
out, err := buildWith(t, blogSite(map[string]string{"news/ciao.md": "Title: Ciao\nDate: 2026-11-05T09:00:00+0100\nLanguage: it\n-\nUn testo.\n"}), nil)
|
||||
if err != nil {
|
||||
t.Fatalf("Build() error = %v", err)
|
||||
}
|
||||
mustContain(t, "status post", readOut(t, out, "news/2026/11/status.html"), `rel="prev">Older: <span lang="it">Ciao</span></a>`)
|
||||
mustContain(t, "italian post", readOut(t, out, "news/2026/11/ciao.html"), `rel="next">Piu recente: <span lang="en">Status page</span></a>`)
|
||||
}
|
||||
|
|
@ -9,6 +9,7 @@ import (
|
|||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.kmalloc.org/squid/motorino/internal/content"
|
||||
"git.kmalloc.org/squid/motorino/internal/site"
|
||||
|
|
@ -24,12 +25,23 @@ type Options struct {
|
|||
OutDir string
|
||||
// Version is the version of motorino, shown in the generator meta.
|
||||
Version string
|
||||
// Now is the moment the site is built at: a post dated later is not
|
||||
// published yet. The zero value means the current time.
|
||||
Now time.Time
|
||||
// Drafts publishes the drafts and the posts dated in the future too, for a
|
||||
// preview of the site.
|
||||
Drafts bool
|
||||
// Clean empties OutDir before the site is written, when it is new, empty or
|
||||
// was emptied this way before (it holds the file .motorino-out); any other
|
||||
// folder with files in it is an error. Without it old files stay.
|
||||
Clean bool
|
||||
}
|
||||
|
||||
// requiredPages are the IDs every site must have in its default language,
|
||||
// because motorino builds the home page and the news section itself. The
|
||||
// other pages, and the menu that links to them, are the site's own: a template
|
||||
// can link to any page with url_<id> and mark it with cur_<id>.
|
||||
// requiredPages are the IDs every site must have, because motorino builds the
|
||||
// home page and the news section itself: the home in the default language and
|
||||
// the news page in the language of the news. The other pages, and the menu
|
||||
// that links to them, are the site's own: a template can link to any page with
|
||||
// url_<id> and mark it with cur_<id>.
|
||||
var requiredPages = []string{"home", "news"}
|
||||
|
||||
// newsOnHome is how many news the home page lists; feedLimit is how many the feed has.
|
||||
|
|
@ -47,12 +59,20 @@ type builder struct {
|
|||
cfg site.Config
|
||||
langs map[string]site.Lang
|
||||
defaultLang string
|
||||
pages []content.Page
|
||||
posts []content.Post
|
||||
categories []categoryEntry
|
||||
templates map[string]string
|
||||
css string
|
||||
byKey map[pageKey]content.Page
|
||||
// newsLang is the language the news are written in, and so the language of
|
||||
// the news pages: the posts, the index, the archives, the categories and
|
||||
// the feed exist once, in this language. A post can say another one.
|
||||
newsLang string
|
||||
// newsPath is the address of the news index, such as "/news/".
|
||||
newsPath string
|
||||
// now is the moment the site is built at.
|
||||
now time.Time
|
||||
pages []content.Page
|
||||
posts []content.Post
|
||||
categories []categoryEntry
|
||||
templates map[string]string
|
||||
css string
|
||||
byKey map[pageKey]content.Page
|
||||
// pageIDs lists the ID of every page, once, whatever the language.
|
||||
pageIDs []string
|
||||
// files holds the rendered output: relative path to content.
|
||||
|
|
@ -77,13 +97,18 @@ type categoryEntry struct {
|
|||
type Result struct {
|
||||
// Pages is the number of HTML pages written: pages, news and categories.
|
||||
Pages int
|
||||
// Stale lists the files that were already in the output folder and that this
|
||||
// build did not write, such as the pages of a list that got shorter. They are
|
||||
// left alone unless Clean is set, which removes them first.
|
||||
Stale []string
|
||||
}
|
||||
|
||||
// Build reads the site in opts.SiteDir and writes it to opts.OutDir. It renders
|
||||
// everything in memory first, so a failure in the content leaves the output
|
||||
// folder untouched. Writing the files is not atomic, and files of an earlier
|
||||
// build that are no longer produced are not removed: build into a fresh folder
|
||||
// when that matters, as the deploy does.
|
||||
// build that are no longer produced are not removed, but listed in Result.Stale:
|
||||
// build into a fresh folder when that matters, as the deploy does (it publishes
|
||||
// the new folder with rsync --delete), or set Options.Clean.
|
||||
func Build(opts Options) (Result, error) {
|
||||
b, err := load(opts)
|
||||
if err != nil {
|
||||
|
|
@ -98,6 +123,9 @@ func Build(opts Options) (Result, error) {
|
|||
if err := b.renderCategories(); err != nil {
|
||||
return Result{}, err
|
||||
}
|
||||
if err := b.renderArchives(); err != nil {
|
||||
return Result{}, err
|
||||
}
|
||||
if err := b.renderFeed(); err != nil {
|
||||
return Result{}, err
|
||||
}
|
||||
|
|
@ -108,10 +136,18 @@ func Build(opts Options) (Result, error) {
|
|||
if err != nil {
|
||||
return Result{}, err
|
||||
}
|
||||
if err := b.write(assets); err != nil {
|
||||
files := make(map[string][]byte, len(b.files)+len(assets))
|
||||
for rel, text := range b.files {
|
||||
files[rel] = []byte(text)
|
||||
}
|
||||
for rel, data := range assets {
|
||||
files[rel] = data
|
||||
}
|
||||
stale, err := writeOutput(opts.OutDir, opts.SiteDir, opts.Clean, files)
|
||||
if err != nil {
|
||||
return Result{}, err
|
||||
}
|
||||
return Result{Pages: len(b.indexable)}, nil
|
||||
return Result{Pages: len(b.indexable), Stale: stale}, nil
|
||||
}
|
||||
|
||||
// load reads the configuration, the content, the templates and the style.
|
||||
|
|
@ -121,14 +157,24 @@ func load(opts Options) (*builder, error) {
|
|||
return nil, err
|
||||
}
|
||||
b := &builder{
|
||||
opts: opts, cfg: cfg, langs: langs, defaultLang: cfg.Languages[0],
|
||||
opts: opts, cfg: cfg, langs: langs, defaultLang: cfg.Languages[0], now: opts.Now,
|
||||
byKey: map[pageKey]content.Page{}, files: map[string]string{}, owners: map[string]string{},
|
||||
langCtx: map[string]map[string]string{},
|
||||
}
|
||||
if b.now.IsZero() {
|
||||
b.now = time.Now()
|
||||
}
|
||||
if b.newsLang, err = newsLanguage(cfg); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if b.pages, err = content.LoadPages(opts.SiteDir, cfg.Languages); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if b.posts, err = content.LoadPosts(opts.SiteDir); err != nil {
|
||||
all, err := content.LoadPosts(opts.SiteDir)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if b.posts, err = b.publishedPosts(all); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
seenID := map[string]bool{}
|
||||
|
|
@ -145,13 +191,19 @@ func load(opts Options) (*builder, error) {
|
|||
}
|
||||
}
|
||||
for _, id := range requiredPages {
|
||||
if _, ok := b.byKey[pageKey{id, b.defaultLang}]; !ok {
|
||||
return nil, fmt.Errorf("content/%s: there is no page with ID %q", b.defaultLang, id)
|
||||
lang := b.defaultLang
|
||||
if id == "news" {
|
||||
lang = b.newsLang
|
||||
}
|
||||
if _, ok := b.byKey[pageKey{id, lang}]; !ok {
|
||||
return nil, fmt.Errorf("content/%s: there is no page with ID %q", lang, id)
|
||||
}
|
||||
}
|
||||
if news := b.byKey[pageKey{"news", b.defaultLang}]; !strings.HasSuffix(news.Path, "/") {
|
||||
news := b.byKey[pageKey{"news", b.newsLang}]
|
||||
if !strings.HasSuffix(news.Path, "/") {
|
||||
return nil, fmt.Errorf("%s: the news page must be an index (news/index.md), so that the feed has an address next to it", news.Source)
|
||||
}
|
||||
b.newsPath = news.Path
|
||||
if b.templates, err = readTemplates(opts.SiteDir); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
|
@ -164,6 +216,49 @@ func load(opts Options) (*builder, error) {
|
|||
return b, nil
|
||||
}
|
||||
|
||||
// newsLanguage returns the language of the news: news_language in site.json,
|
||||
// else English when the site has it, else the default language.
|
||||
func newsLanguage(cfg site.Config) (string, error) {
|
||||
listed := func(code string) bool {
|
||||
for _, l := range cfg.Languages {
|
||||
if l == code {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
switch code := cfg.Strings["news_language"]; {
|
||||
case code == "" && listed("en"):
|
||||
return "en", nil
|
||||
case code == "":
|
||||
return cfg.Languages[0], nil
|
||||
case !listed(code):
|
||||
return "", fmt.Errorf("site.json: news_language %q is not one of the languages of the site", code)
|
||||
default:
|
||||
return code, nil
|
||||
}
|
||||
}
|
||||
|
||||
// publishedPosts gives every post the language of the news when it names none,
|
||||
// checks that the language is one of the site, and keeps the posts that are
|
||||
// published at the moment of the build: not a draft and not dated in the
|
||||
// future, unless the build is a preview with drafts.
|
||||
func (b *builder) publishedPosts(all []content.Post) ([]content.Post, error) {
|
||||
var out []content.Post
|
||||
for _, p := range all {
|
||||
if p.Language == "" {
|
||||
p.Language = b.newsLang
|
||||
}
|
||||
if _, ok := b.langs[p.Language]; !ok {
|
||||
return nil, fmt.Errorf("%s: Language %q is not one of the languages of site.json", p.Source, p.Language)
|
||||
}
|
||||
if b.opts.Drafts || p.Visible(b.now) {
|
||||
out = append(out, p)
|
||||
}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// groupCategories lists the categories of the posts, sorted by name, each with
|
||||
// its posts.
|
||||
func groupCategories(posts []content.Post) []categoryEntry {
|
||||
|
|
@ -253,21 +348,6 @@ func (b *builder) readAssets() (map[string][]byte, error) {
|
|||
return out, nil
|
||||
}
|
||||
|
||||
// write creates the output folder and writes the pages and the assets.
|
||||
func (b *builder) write(assets map[string][]byte) error {
|
||||
for rel, text := range b.files {
|
||||
if err := writeFile(b.opts.OutDir, rel, []byte(text)); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
for rel, data := range assets {
|
||||
if err := writeFile(b.opts.OutDir, rel, data); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// writeFile writes data to rel under dir, creating the folders.
|
||||
func writeFile(dir, rel string, data []byte) error {
|
||||
path := filepath.Join(dir, filepath.FromSlash(rel))
|
||||
|
|
|
|||
|
|
@ -454,7 +454,7 @@ func TestBuildFeed(t *testing.T) {
|
|||
feed := readOut(t, out, "news/feed.xml")
|
||||
mustContain(t, "feed", feed,
|
||||
"<guid isPermaLink=\"true\">https://kmalloc.org/news/2026/11/shop.html</guid>",
|
||||
`<a href="https://kmalloc.org/people.html">people</a>`)
|
||||
`<content:encoded><![CDATA[<p>The programme is out. See <a href="https://kmalloc.org/people.html">people</a>.</p>`)
|
||||
}
|
||||
|
||||
// TestBuildErrorsOnMissingTemplate checks that a missing layout template is named.
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ import (
|
|||
|
||||
// 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"}
|
||||
var blockNames = []string{"news_list", "latest_news", "categories_list", "news_blog", "news_archive"}
|
||||
|
||||
// document describes one output page for the shared page frame.
|
||||
type document struct {
|
||||
|
|
@ -106,6 +106,8 @@ func (b *builder) documentContext(d document) map[string]string {
|
|||
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 {
|
||||
|
|
|
|||
51
internal/build/date.go
Normal file
51
internal/build/date.go
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
package build
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.kmalloc.org/squid/motorino/internal/site"
|
||||
)
|
||||
|
||||
// longDate writes a date for a reader, in the language l, from the strings
|
||||
// date_long (a layout with {d}, {month} and {y}) and month_01 to month_12. The
|
||||
// day, the month and the year are those of the date as written, not converted
|
||||
// to another time zone. A language without the layout, or without the name of
|
||||
// the month, gets the ISO date.
|
||||
func longDate(date time.Time, l site.Lang) string {
|
||||
layout := l.Strings["date_long"]
|
||||
month := l.Strings[fmt.Sprintf("month_%02d", int(date.Month()))]
|
||||
if layout == "" || month == "" {
|
||||
return date.Format(dateOnly)
|
||||
}
|
||||
return strings.NewReplacer(
|
||||
"{d}", strconv.Itoa(date.Day()), "{month}", month, "{y}", strconv.Itoa(date.Year()),
|
||||
).Replace(layout)
|
||||
}
|
||||
|
||||
// monthYear is the label of an archive month in the language l, from the
|
||||
// strings date_month_year (a layout with {month} and {y}) and month_01 to
|
||||
// month_12; without them it is the year and the month, "2026-11".
|
||||
func monthYear(year, month int, l site.Lang) string {
|
||||
layout := l.Strings["date_month_year"]
|
||||
name := l.Strings[fmt.Sprintf("month_%02d", month)]
|
||||
if layout == "" || name == "" {
|
||||
return fmt.Sprintf("%04d-%02d", year, month)
|
||||
}
|
||||
return strings.NewReplacer("{month}", name, "{y}", strconv.Itoa(year)).Replace(layout)
|
||||
}
|
||||
|
||||
// readingText is the reading time of a post in the language l, from the string
|
||||
// reading_time (a sentence with {n}); without the string it is empty and no
|
||||
// reading time is shown.
|
||||
func readingText(minutes int, l site.Lang) string {
|
||||
layout := l.Strings["reading_time"]
|
||||
if layout == "" {
|
||||
return ""
|
||||
}
|
||||
return strings.ReplaceAll(layout, "{n}", strconv.Itoa(minutes))
|
||||
}
|
||||
73
internal/build/date_test.go
Normal file
73
internal/build/date_test.go
Normal file
|
|
@ -0,0 +1,73 @@
|
|||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
package build
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.kmalloc.org/squid/motorino/internal/site"
|
||||
)
|
||||
|
||||
// dateLang returns a language with the strings that write a date.
|
||||
func dateLang(layout string, months ...string) site.Lang {
|
||||
l := site.Lang{Code: "xx", Strings: map[string]string{}}
|
||||
if layout != "" {
|
||||
l.Strings["date_long"] = layout
|
||||
}
|
||||
for i, m := range months {
|
||||
l.Strings["month_"+string(rune('0'+(i+1)/10))+string(rune('0'+(i+1)%10))] = m
|
||||
}
|
||||
return l
|
||||
}
|
||||
|
||||
// allMonths lists twelve month names for a test language.
|
||||
var allMonths = []string{"gennaio", "febbraio", "marzo", "aprile", "maggio", "giugno", "luglio", "agosto", "settembre", "ottobre", "novembre", "dicembre"}
|
||||
|
||||
// TestLongDate checks the long date in a language, as written in the date.
|
||||
func TestLongDate(t *testing.T) {
|
||||
date, err := time.Parse("2006-01-02T15:04:05-0700", "2026-11-05T23:30:00-0500")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got := longDate(date, dateLang("{d} {month} {y}", allMonths...)); got != "5 novembre 2026" {
|
||||
t.Errorf("longDate() = %q, want the day without a zero, the month name and the year", got)
|
||||
}
|
||||
if got := longDate(date, dateLang("{month} {d}, {y}", allMonths...)); got != "novembre 5, 2026" {
|
||||
t.Errorf("longDate() with another layout = %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
// TestLongDateFallsBack checks the ISO date when the language has no layout or a month.
|
||||
func TestLongDateFallsBack(t *testing.T) {
|
||||
date, _ := time.Parse("2006-01-02T15:04:05-0700", "2026-11-14T12:00:00+0100")
|
||||
if got := longDate(date, dateLang("")); got != "2026-11-14" {
|
||||
t.Errorf("no layout: longDate() = %q, want the ISO date", got)
|
||||
}
|
||||
if got := longDate(date, dateLang("{d} {month} {y}", "uno", "due")); got != "2026-11-14" {
|
||||
t.Errorf("a missing month name: longDate() = %q, want the ISO date", got)
|
||||
}
|
||||
}
|
||||
|
||||
// TestMonthYear checks the label of an archive month.
|
||||
func TestMonthYear(t *testing.T) {
|
||||
l := dateLang("{d} {month} {y}", allMonths...)
|
||||
l.Strings["date_month_year"] = "{month} {y}"
|
||||
if got := monthYear(2026, 11, l); got != "novembre 2026" {
|
||||
t.Errorf("monthYear() = %q", got)
|
||||
}
|
||||
if got := monthYear(2026, 3, dateLang("")); got != "2026-03" {
|
||||
t.Errorf("monthYear() without strings = %q, want 2026-03", got)
|
||||
}
|
||||
}
|
||||
|
||||
// TestReadingText checks the reading time sentence and its absence.
|
||||
func TestReadingText(t *testing.T) {
|
||||
l := site.Lang{Strings: map[string]string{"reading_time": "{n} min di lettura"}}
|
||||
if got := readingText(3, l); got != "3 min di lettura" {
|
||||
t.Errorf("readingText() = %q", got)
|
||||
}
|
||||
if got := readingText(3, site.Lang{Strings: map[string]string{}}); got != "" {
|
||||
t.Errorf("readingText() without a string = %q, want empty", got)
|
||||
}
|
||||
}
|
||||
|
|
@ -15,10 +15,16 @@ import (
|
|||
// href="/people.html", but not one that is relative to the protocol (href="//host/x").
|
||||
var siteRelative = regexp.MustCompile(`\b(href|src)="/([^/])`)
|
||||
|
||||
// cdata wraps text in a CDATA section; the end marker inside the text is split
|
||||
// over two sections, so it cannot close the first one.
|
||||
func cdata(text string) string {
|
||||
return "<![CDATA[" + strings.ReplaceAll(text, "]]>", "]]]]><![CDATA[>") + "]]>"
|
||||
}
|
||||
|
||||
// feed returns the RSS 2.0 feed of the latest limit posts, which must be sorted
|
||||
// newest first. Each item carries the full text with absolute links. The
|
||||
// channel is described by the language l, and newsURL is the address of the
|
||||
// news page, such as "/news/".
|
||||
// newest first. Each item has the description as a plain summary and the full
|
||||
// text, with absolute links, in content:encoded. The channel is described by
|
||||
// the language l, and newsURL is the address of the news page, such as "/news/".
|
||||
func feed(base string, l site.Lang, newsURL string, posts []renderedPost, limit int) string {
|
||||
if limit < len(posts) {
|
||||
posts = posts[:limit]
|
||||
|
|
@ -32,7 +38,16 @@ func feed(base string, l site.Lang, newsURL string, posts []renderedPost, limit
|
|||
items.WriteString("<link>" + link + "</link>\n")
|
||||
items.WriteString(`<guid isPermaLink="true">` + link + "</guid>\n")
|
||||
items.WriteString("<pubDate>" + p.Date.Format(time.RFC1123Z) + "</pubDate>\n")
|
||||
items.WriteString("<description>" + render.Escape(text) + "</description>\n")
|
||||
if p.Description != "" {
|
||||
items.WriteString("<description>" + render.Escape(p.Description) + "</description>\n")
|
||||
}
|
||||
if p.Author != "" {
|
||||
items.WriteString("<dc:creator>" + render.Escape(p.Author) + "</dc:creator>\n")
|
||||
}
|
||||
for _, c := range p.Categories {
|
||||
items.WriteString("<category>" + render.Escape(c.Name) + "</category>\n")
|
||||
}
|
||||
items.WriteString("<content:encoded>" + cdata(text) + "</content:encoded>\n")
|
||||
items.WriteString("</item>\n")
|
||||
}
|
||||
built := ""
|
||||
|
|
@ -41,7 +56,7 @@ func feed(base string, l site.Lang, newsURL string, posts []renderedPost, limit
|
|||
}
|
||||
url := base + newsURL
|
||||
return `<?xml version="1.0" encoding="utf-8"?>
|
||||
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
|
||||
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:dc="http://purl.org/dc/elements/1.1/">
|
||||
<channel>
|
||||
<title>kmalloc.org: ` + render.Escape(l.Nav["news"]) + `</title>
|
||||
<link>` + url + `</link>
|
||||
|
|
|
|||
|
|
@ -18,7 +18,7 @@ func feedLang() site.Lang {
|
|||
// TestFeedItems checks the channel, the item fields, the limit and the dates.
|
||||
func TestFeedItems(t *testing.T) {
|
||||
items := []renderedPost{
|
||||
{Post: testPost("new", "2026-11-14", "New <post>", ""), HTML: `<p>See <a href="/people.html">people</a>.</p>`},
|
||||
{Post: testPost("new", "2026-11-14", "New <post>", "A summary & more.", "FLUG", "Linux Day"), HTML: `<p>See <a href="/people.html">people</a>.</p>`},
|
||||
{Post: testPost("old", "2026-11-12", "Old", ""), HTML: "<p>Old text.</p>"},
|
||||
{Post: testPost("older", "2026-11-10", "Older", ""), HTML: "<p>Older text.</p>"},
|
||||
}
|
||||
|
|
@ -35,7 +35,11 @@ func TestFeedItems(t *testing.T) {
|
|||
`<guid isPermaLink="true">https://kmalloc.org/news/2026/11/new.html</guid>`,
|
||||
"<pubDate>Sat, 14 Nov 2026 12:00:00 +0100</pubDate>",
|
||||
"<lastBuildDate>Sat, 14 Nov 2026 12:00:00 +0100</lastBuildDate>",
|
||||
`<a href="https://kmalloc.org/people.html">`,
|
||||
`xmlns:content="http://purl.org/rss/1.0/modules/content/"`,
|
||||
"<description>A summary & more.</description>",
|
||||
`<content:encoded><![CDATA[<p>See <a href="https://kmalloc.org/people.html">people</a>.</p>]]></content:encoded>`,
|
||||
"<category>FLUG</category>",
|
||||
"<category>Linux Day</category>",
|
||||
} {
|
||||
if !strings.Contains(got, want) {
|
||||
t.Errorf("feed does not contain %q\n%s", want, got)
|
||||
|
|
@ -49,6 +53,34 @@ func TestFeedItems(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
// TestFeedCarriesTheFullTextAsContent checks that the text is in content:encoded and the
|
||||
// description stays a plain summary, and that the end marker of a CDATA section in a text
|
||||
// does not close it.
|
||||
func TestFeedCarriesTheFullTextAsContent(t *testing.T) {
|
||||
post := testPost("a", "2026-11-14", "A", "Short.")
|
||||
post.Author = "Matteo Bini"
|
||||
items := []renderedPost{{Post: post, HTML: "<pre>a ]]> b</pre>\n<p>Text.</p>"}}
|
||||
got := feed("https://kmalloc.org", feedLang(), "/news/", items, 5)
|
||||
mustContain(t, "feed", got, "<description>Short.</description>", "<dc:creator>Matteo Bini</dc:creator>",
|
||||
`xmlns:dc="http://purl.org/dc/elements/1.1/"`, "<pre>a ]]]]><![CDATA[> b</pre>")
|
||||
if strings.Contains(got, "<description><") || strings.Contains(got, "<pre>") {
|
||||
t.Errorf("the description holds markup:\n%s", got)
|
||||
}
|
||||
var parsed struct {
|
||||
Channel struct {
|
||||
Items []struct {
|
||||
Content string `xml:"http://purl.org/rss/1.0/modules/content/ encoded"`
|
||||
} `xml:"item"`
|
||||
} `xml:"channel"`
|
||||
}
|
||||
if err := xml.Unmarshal([]byte(got), &parsed); err != nil {
|
||||
t.Fatalf("feed is not well-formed XML: %v", err)
|
||||
}
|
||||
if len(parsed.Channel.Items) != 1 || parsed.Channel.Items[0].Content != "<pre>a ]]> b</pre>\n<p>Text.</p>" {
|
||||
t.Errorf("content:encoded = %+v, want the text back as written", parsed.Channel.Items)
|
||||
}
|
||||
}
|
||||
|
||||
// TestFeedLeavesProtocolRelativeLinks checks that "//host/x" is not given the site address.
|
||||
func TestFeedLeavesProtocolRelativeLinks(t *testing.T) {
|
||||
items := []renderedPost{{Post: testPost("a", "2026-11-14", "A", ""), HTML: `<img src="//cdn.example/x.png"> <a href="/p.html">p</a>`}}
|
||||
|
|
|
|||
|
|
@ -46,6 +46,12 @@ func readOut(t *testing.T, out, rel string) string {
|
|||
return string(data)
|
||||
}
|
||||
|
||||
// readOutMaybe returns the content of a file of the output, or the error when it is missing.
|
||||
func readOutMaybe(out, rel string) (string, error) {
|
||||
data, err := os.ReadFile(filepath.Join(out, filepath.FromSlash(rel)))
|
||||
return string(data), err
|
||||
}
|
||||
|
||||
// mustContain fails the test for each want that is not in got.
|
||||
func mustContain(t *testing.T, name, got string, wants ...string) {
|
||||
t.Helper()
|
||||
|
|
|
|||
|
|
@ -24,12 +24,13 @@ type renderedPost struct {
|
|||
}
|
||||
|
||||
// newsItem returns the <li> of a post for a list: the date, the title as a
|
||||
// link and, when withDescription is set and there is one, the description. News
|
||||
// are written in English, so on any other language the link says so.
|
||||
// link and, when withDescription is set and there is one, the description. A
|
||||
// post is written in its own language, so on a page in another language the
|
||||
// link says which one.
|
||||
func newsItem(p content.Post, lang string, withDescription bool) string {
|
||||
mark := ""
|
||||
if lang != "en" {
|
||||
mark = ` hreflang="en" lang="en"`
|
||||
if p.Language != "" && p.Language != lang {
|
||||
mark = fmt.Sprintf(` hreflang="%s" lang="%s"`, p.Language, p.Language)
|
||||
}
|
||||
day := p.Date.Format(dateOnly)
|
||||
item := fmt.Sprintf(`<li><time datetime="%s">%s</time> <a href="%s"%s>%s</a>`,
|
||||
|
|
@ -40,6 +41,64 @@ func newsItem(p content.Post, lang string, withDescription bool) string {
|
|||
return item + "</li>"
|
||||
}
|
||||
|
||||
// newsPanel returns a post for a list of the news as a note panel: first a small
|
||||
// line with the date and the categories, then the title in bold with a full stop
|
||||
// (unless it ends with one, a question mark or an exclamation mark), then the
|
||||
// description, then the link to read more, which names the post for a reader that
|
||||
// hears the links out of context. lang is the language of the page; the link of a
|
||||
// post in another language says so. Without the string read_more the title is the
|
||||
// link and there is no link to read more, unless needMore is set: the blog list has
|
||||
// no other link to the post, so there it is an error.
|
||||
func (b *builder) newsPanel(p content.Post, lang string, needMore bool) (string, error) {
|
||||
l := b.langs[lang]
|
||||
more := l.Strings["read_more"]
|
||||
if more == "" && needMore {
|
||||
return "", fmt.Errorf("lang/%s.json: the language has no read_more string, which the blog list needs", lang)
|
||||
}
|
||||
mark := ""
|
||||
if p.Language != "" && p.Language != lang {
|
||||
mark = fmt.Sprintf(` hreflang="%s" lang="%s"`, p.Language, p.Language)
|
||||
}
|
||||
meta := fmt.Sprintf(`<time datetime="%s">%s</time>`, p.Date.Format(dateOnly), render.Escape(longDate(p.Date, l)))
|
||||
if links := categoryLinks(p); links != "" {
|
||||
meta += " · " + links
|
||||
}
|
||||
title := p.Title
|
||||
if !strings.HasSuffix(title, ".") && !strings.HasSuffix(title, "?") && !strings.HasSuffix(title, "!") {
|
||||
title += "."
|
||||
}
|
||||
var out strings.Builder
|
||||
out.WriteString("<p class=\"note\" role=\"note\">\n")
|
||||
fmt.Fprintf(&out, "<span class=\"meta\">%s</span><br>\n", meta)
|
||||
if more == "" {
|
||||
fmt.Fprintf(&out, "<strong><a href=\"%s\"%s>%s</a></strong>\n", p.Path, mark, render.Escape(title))
|
||||
} else {
|
||||
fmt.Fprintf(&out, "<strong>%s</strong>\n", render.Escape(title))
|
||||
}
|
||||
if p.Description != "" {
|
||||
fmt.Fprintf(&out, "%s\n", render.Escape(p.Description))
|
||||
}
|
||||
if more != "" {
|
||||
fmt.Fprintf(&out, "<a href=\"%s\" aria-label=\"%s: %s\"%s>%s</a>.\n", p.Path, render.EscapeAttr(more), render.EscapeAttr(p.Title), mark, render.Escape(more))
|
||||
}
|
||||
out.WriteString("</p>")
|
||||
return out.String(), nil
|
||||
}
|
||||
|
||||
// newsPanels returns the panels of the posts of a category or of an archive,
|
||||
// one after the other, or an empty string when there are none.
|
||||
func (b *builder) newsPanels(posts []content.Post, lang string) (string, error) {
|
||||
panels := make([]string, len(posts))
|
||||
for i, p := range posts {
|
||||
panel, err := b.newsPanel(p, lang, false)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
panels[i] = panel
|
||||
}
|
||||
return strings.Join(panels, "\n"), nil
|
||||
}
|
||||
|
||||
// newsList returns the full list of the news as a <ul>, or an empty string
|
||||
// when there are no posts.
|
||||
func newsList(posts []content.Post, lang string) string {
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ func testPost(slug, day, title, description string, cats ...string) content.Post
|
|||
}
|
||||
return content.Post{
|
||||
Slug: slug, Path: content.PostPath(date, slug), Title: title, Description: description,
|
||||
Date: date, Categories: categories, Source: "news/" + slug + ".md",
|
||||
Language: "en", Date: date, Categories: categories, Source: "news/" + slug + ".md",
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
105
internal/build/output.go
Normal file
105
internal/build/output.go
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
package build
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// motorinoMarker is the file motorino leaves in a folder it emptied with the
|
||||
// clean option. A folder that has it, or has nothing in it, may be emptied again;
|
||||
// any other folder never is. It is only written when the option is used, so the
|
||||
// folders of a build without it hold the site and nothing else.
|
||||
const motorinoMarker = ".motorino-out"
|
||||
|
||||
// writeOutput writes the files (path with slashes, relative to out) into out and
|
||||
// returns the files that were already in out and are not among them: the pages
|
||||
// of an earlier build that this one no longer makes. With clean set it first
|
||||
// empties out, but only a folder that is new, empty or marked by an earlier clean
|
||||
// build, and never the folder of the site or one that holds it. It does not
|
||||
// touch the folder before every file is known, so a content error leaves it as
|
||||
// it was.
|
||||
func writeOutput(out, siteDir string, clean bool, files map[string][]byte) ([]string, error) {
|
||||
if clean {
|
||||
if err := emptyOutput(out, siteDir); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
files = withMarker(files)
|
||||
}
|
||||
for rel, data := range files {
|
||||
if err := writeFile(out, rel, data); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return staleFiles(out, files)
|
||||
}
|
||||
|
||||
// withMarker returns the files and the marker.
|
||||
func withMarker(files map[string][]byte) map[string][]byte {
|
||||
marked := make(map[string][]byte, len(files)+1)
|
||||
for rel, data := range files {
|
||||
marked[rel] = data
|
||||
}
|
||||
marked[motorinoMarker] = []byte("This folder is written by motorino and emptied by motorino build -clean and motorino gemini -clean.\n")
|
||||
return marked
|
||||
}
|
||||
|
||||
// emptyOutput removes what is in out, after checking that it may be removed.
|
||||
func emptyOutput(out, siteDir string) error {
|
||||
absOut, err := filepath.Abs(out)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
absSite, err := filepath.Abs(siteDir)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if rel, err := filepath.Rel(absOut, absSite); err == nil && rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
|
||||
return fmt.Errorf("refusing to empty %s: it is the folder of the site or holds it", out)
|
||||
}
|
||||
entries, err := os.ReadDir(out)
|
||||
if os.IsNotExist(err) || (err == nil && len(entries) == 0) {
|
||||
return nil
|
||||
}
|
||||
if err != nil {
|
||||
return fmt.Errorf("read %s: %w", out, err)
|
||||
}
|
||||
if info, err := os.Lstat(filepath.Join(out, motorinoMarker)); err != nil || !info.Mode().IsRegular() {
|
||||
return fmt.Errorf("refusing to empty %s: it has files and no %s, which motorino leaves in a folder it emptied; empty it yourself this first time", out, motorinoMarker)
|
||||
}
|
||||
for _, entry := range entries {
|
||||
if err := os.RemoveAll(filepath.Join(out, entry.Name())); err != nil {
|
||||
return fmt.Errorf("empty %s: %w", out, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// staleFiles lists the files under out that are not among the written ones, with
|
||||
// slashes, sorted. The marker is never one of them.
|
||||
func staleFiles(out string, written map[string][]byte) ([]string, error) {
|
||||
var stale []string
|
||||
err := filepath.WalkDir(out, func(path string, entry os.DirEntry, err error) error {
|
||||
if err != nil || entry.IsDir() {
|
||||
return err
|
||||
}
|
||||
rel, err := filepath.Rel(out, path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rel = filepath.ToSlash(rel)
|
||||
if _, ok := written[rel]; !ok && rel != motorinoMarker {
|
||||
stale = append(stale, rel)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("read %s: %w", out, err)
|
||||
}
|
||||
sort.Strings(stale)
|
||||
return stale, nil
|
||||
}
|
||||
162
internal/build/output_test.go
Normal file
162
internal/build/output_test.go
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
package build
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// put writes a file of a test folder.
|
||||
func put(t *testing.T, dir, rel, text string) {
|
||||
t.Helper()
|
||||
path := filepath.Join(dir, filepath.FromSlash(rel))
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(path, []byte(text), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
// extraBuilders are the other outputs the tests of the output folder run against, by name: each takes the
|
||||
// folder of a site and returns a function that builds it into a folder.
|
||||
var extraBuilders = map[string]func(site string) func(out string, clean bool) ([]string, error){}
|
||||
|
||||
// builders are the outputs, each as a function that builds the site made of files into a folder and returns
|
||||
// the files of the folder that the build did not write.
|
||||
func builders(t *testing.T, files map[string]string) map[string]func(out string, clean bool) ([]string, error) {
|
||||
t.Helper()
|
||||
site := writeFiles(t, files)
|
||||
all := map[string]func(string, bool) ([]string, error){
|
||||
"html": func(out string, clean bool) ([]string, error) {
|
||||
r, err := Build(Options{SiteDir: site, OutDir: out, Version: "1.2.3", Now: fixedNow, Clean: clean})
|
||||
return r.Stale, err
|
||||
},
|
||||
}
|
||||
for name, newBuilder := range extraBuilders {
|
||||
all[name] = newBuilder(site)
|
||||
}
|
||||
return all
|
||||
}
|
||||
|
||||
// TestStaleFilesAreReported checks that a build into a folder with files it did not write reports them and leaves them.
|
||||
func TestStaleFilesAreReported(t *testing.T) {
|
||||
for name, run := range builders(t, withFiles(nil)) {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
out := t.TempDir()
|
||||
put(t, out, "news/page/2/index.html", "old")
|
||||
put(t, out, "old.txt", "old")
|
||||
stale, err := run(out, false)
|
||||
if err != nil {
|
||||
t.Fatalf("build error = %v", err)
|
||||
}
|
||||
if strings.Join(stale, ",") != "news/page/2/index.html,old.txt" {
|
||||
t.Errorf("stale = %v, want the two old files", stale)
|
||||
}
|
||||
if !exists(t, out, "old.txt") {
|
||||
t.Error("a build without -clean removed a file")
|
||||
}
|
||||
if exists(t, out, motorinoMarker) {
|
||||
t.Error("a build without -clean wrote the marker into the folder")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestFreshFolderHasNothingStale checks that a build into a new folder reports nothing and writes only the site.
|
||||
func TestFreshFolderHasNothingStale(t *testing.T) {
|
||||
for name, run := range builders(t, withFiles(nil)) {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
stale, err := run(filepath.Join(t.TempDir(), "new"), false)
|
||||
if err != nil || len(stale) != 0 {
|
||||
t.Errorf("stale = %v, error = %v", stale, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestCleanEmptiesAFolderItMarked checks that -clean removes the old files of a folder that has the marker,
|
||||
// the pages of a list that got shorter included, and writes the marker again.
|
||||
func TestCleanEmptiesAFolderItMarked(t *testing.T) {
|
||||
for name, run := range builders(t, withFiles(nil)) {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
out := t.TempDir()
|
||||
put(t, out, motorinoMarker, "x")
|
||||
put(t, out, "news/page/2/index.html", "old")
|
||||
put(t, out, "old/deep/file.txt", "old")
|
||||
stale, err := run(out, true)
|
||||
if err != nil {
|
||||
t.Fatalf("build error = %v", err)
|
||||
}
|
||||
if len(stale) != 0 {
|
||||
t.Errorf("stale = %v after a clean build", stale)
|
||||
}
|
||||
for _, gone := range []string{"news/page/2/index.html", "old/deep/file.txt"} {
|
||||
if exists(t, out, gone) {
|
||||
t.Errorf("%s is still there after -clean", gone)
|
||||
}
|
||||
}
|
||||
if !exists(t, out, motorinoMarker) {
|
||||
t.Error("the marker is gone after -clean")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestCleanTakesAnEmptyOrNewFolder checks that -clean needs no marker for a folder with nothing in it, and marks it.
|
||||
func TestCleanTakesAnEmptyOrNewFolder(t *testing.T) {
|
||||
for name, run := range builders(t, withFiles(nil)) {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
for _, out := range []string{t.TempDir(), filepath.Join(t.TempDir(), "new", "deeper")} {
|
||||
if _, err := run(out, true); err != nil {
|
||||
t.Fatalf("build into %s error = %v", out, err)
|
||||
}
|
||||
if !exists(t, out, motorinoMarker) {
|
||||
t.Errorf("no marker in %s", out)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestCleanRefusesAFolderThatIsNotMotorinos checks that -clean leaves a folder with files and no marker alone.
|
||||
func TestCleanRefusesAFolderThatIsNotMotorinos(t *testing.T) {
|
||||
for name, run := range builders(t, withFiles(nil)) {
|
||||
t.Run(name, func(t *testing.T) {
|
||||
out := t.TempDir()
|
||||
put(t, out, "precious.txt", "keep me")
|
||||
_, err := run(out, true)
|
||||
if err == nil || !strings.Contains(err.Error(), motorinoMarker) {
|
||||
t.Fatalf("error = %v, want one that names %s", err, motorinoMarker)
|
||||
}
|
||||
if got := readOut(t, out, "precious.txt"); got != "keep me" {
|
||||
t.Errorf("precious.txt = %q", got)
|
||||
}
|
||||
if exists(t, out, "index.html") || exists(t, out, "index.gmi") || exists(t, out, "en/index.gmi") {
|
||||
t.Error("the build wrote into a folder it refused to empty")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestCleanRefusesAFolderThatHoldsTheSite checks that -clean never empties the folder of the site or one above it,
|
||||
// even when it has the marker.
|
||||
func TestCleanRefusesAFolderThatHoldsTheSite(t *testing.T) {
|
||||
parent := t.TempDir()
|
||||
site := filepath.Join(parent, "site")
|
||||
for rel, text := range withFiles(nil) {
|
||||
put(t, site, rel, text)
|
||||
}
|
||||
put(t, parent, motorinoMarker, "x")
|
||||
for _, out := range []string{site, parent} {
|
||||
if _, err := Build(Options{SiteDir: site, OutDir: out, Now: fixedNow, Clean: true}); err == nil || !strings.Contains(err.Error(), "site") {
|
||||
t.Errorf("Build into %s: error = %v, want one about the site", out, err)
|
||||
}
|
||||
}
|
||||
if !exists(t, site, "site.json") {
|
||||
t.Error("the site is gone")
|
||||
}
|
||||
}
|
||||
|
|
@ -5,6 +5,7 @@ package build
|
|||
import (
|
||||
"fmt"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"git.kmalloc.org/squid/motorino/internal/content"
|
||||
|
|
@ -22,18 +23,51 @@ func (b *builder) renderPages() error {
|
|||
return nil
|
||||
}
|
||||
|
||||
// renderPage converts the body of a page to HTML, expands the generated lists,
|
||||
// puts it in its layout and in the shared frame.
|
||||
// blogBlock matches a paragraph that holds the blog list placeholder.
|
||||
var blogBlock = regexp.MustCompile(`(?m)^\{\{news_blog\}\}\s*$`)
|
||||
|
||||
// renderPage renders a page. A page with the blog list is rendered once for
|
||||
// every page of the list: the first at its own address, the others under it, at
|
||||
// page/2/, page/3/ and so on.
|
||||
func (b *builder) renderPage(p content.Page) error {
|
||||
total := 1
|
||||
if blogBlock.MatchString(p.Body) {
|
||||
if !strings.HasSuffix(p.Path, "/") {
|
||||
return fmt.Errorf("%s: {{news_blog}} must be on an index page (an index.md), so that its pages have addresses under it", p.Source)
|
||||
}
|
||||
total = pageCount(len(b.posts))
|
||||
}
|
||||
for n := 1; n <= total; n++ {
|
||||
if err := b.renderPageNumber(p, n, total); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// renderPageNumber converts the body of a page to HTML, expands the generated
|
||||
// lists, puts it in its layout and in the shared frame. n is the number of the
|
||||
// page of the blog list, out of total; both are 1 for any other page.
|
||||
func (b *builder) renderPageNumber(p content.Page, n, total int) error {
|
||||
d := document{
|
||||
lang: p.Lang, id: p.ID, lead: "back", path: p.Path, title: p.Title,
|
||||
lang: p.Lang, id: p.ID, lead: "back", path: pagePath(p.Path, n), title: p.Title,
|
||||
description: p.Description, switches: p.Switch, source: p.Source,
|
||||
}
|
||||
d.nav = p.ID
|
||||
if p.ID == "home" {
|
||||
d.lead = "home"
|
||||
}
|
||||
if n > 1 {
|
||||
label, err := b.pageLabel(p.Lang, n, total)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
d.id, d.switches = "", nil
|
||||
d.title = p.Title + ", " + label
|
||||
d.source = fmt.Sprintf("%s (page %d of the list)", p.Source, n)
|
||||
}
|
||||
ctx := b.documentContext(d)
|
||||
ctx["news_page_n"] = strconv.Itoa(n)
|
||||
if p.ManifestoVersion != "" {
|
||||
ctx["manifesto_version"] = render.Escape(p.ManifestoVersion)
|
||||
}
|
||||
|
|
@ -100,7 +134,8 @@ func (b *builder) markdown(name, source, lang string, ctx map[string]string) (st
|
|||
var codeElement = regexp.MustCompile(`(?s)<code[^>]*>.*?</code>`)
|
||||
|
||||
// expandBlocks replaces each paragraph that holds only a block placeholder by
|
||||
// the generated HTML. A block placeholder inside other text is an error. All
|
||||
// the generated HTML. An empty list of categories or of the archive goes with the
|
||||
// heading right before it. A block placeholder inside other text is an error. All
|
||||
// blocks are checked before any is expanded, so the text of a generated list
|
||||
// (a news title may say {{latest_news}}) is never taken for a placeholder.
|
||||
func (b *builder) expandBlocks(name, html, lang string, ctx map[string]string) (string, error) {
|
||||
|
|
@ -120,11 +155,41 @@ func (b *builder) expandBlocks(name, html, lang string, ctx map[string]string) (
|
|||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if generated == "" && headedBlocks[block] {
|
||||
html = removeWithHeading(html, marker)
|
||||
continue
|
||||
}
|
||||
html = strings.ReplaceAll(html, marker, generated)
|
||||
}
|
||||
return html, nil
|
||||
}
|
||||
|
||||
// headedBlocks are the lists a page puts under a heading of its own, which goes
|
||||
// when the list is empty. The latest news bring their heading with them, and a
|
||||
// heading before them is the page's.
|
||||
var headedBlocks = map[string]bool{"categories_list": true, "news_archive": true}
|
||||
|
||||
// headingEnd matches the end of a heading element at the end of a text.
|
||||
var headingEnd = regexp.MustCompile(`</h([1-6])>$`)
|
||||
|
||||
// removeWithHeading removes every marker of an empty block and the heading right
|
||||
// before it, which would be left with nothing under it.
|
||||
func removeWithHeading(html, marker string) string {
|
||||
for {
|
||||
at := strings.Index(html, marker)
|
||||
if at < 0 {
|
||||
return html
|
||||
}
|
||||
before := strings.TrimRight(html[:at], " \t\r\n")
|
||||
if m := headingEnd.FindStringSubmatchIndex(before); m != nil {
|
||||
if open := strings.LastIndex(before[:m[0]], "<h"+before[m[2]:m[3]]); open >= 0 {
|
||||
before = before[:open]
|
||||
}
|
||||
}
|
||||
html = before + "\n" + strings.TrimLeft(html[at+len(marker):], "\n")
|
||||
}
|
||||
}
|
||||
|
||||
// block returns the HTML of a generated list.
|
||||
func (b *builder) block(name, lang string, ctx map[string]string) (string, error) {
|
||||
switch name {
|
||||
|
|
@ -133,6 +198,11 @@ func (b *builder) block(name, lang string, ctx map[string]string) (string, error
|
|||
return list, nil
|
||||
}
|
||||
return "<p>\n" + ctx["news_empty"] + "\n</p>", nil
|
||||
case "news_blog":
|
||||
n, _ := strconv.Atoi(ctx["news_page_n"])
|
||||
return b.newsBlog(lang, n, ctx)
|
||||
case "news_archive":
|
||||
return b.newsArchive(lang, ctx)
|
||||
case "latest_news":
|
||||
if len(b.posts) == 0 {
|
||||
return "", nil
|
||||
|
|
@ -156,13 +226,13 @@ func (b *builder) renderPosts() error {
|
|||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, p := range b.posts {
|
||||
for i, p := range b.posts {
|
||||
d := document{
|
||||
lang: b.defaultLang, nav: "news", lead: "news", path: p.Path, title: p.Title,
|
||||
lang: p.Language, nav: "news", lead: "news", path: p.Path, title: p.Title,
|
||||
prefixed: true, description: p.Description, source: p.Source,
|
||||
}
|
||||
ctx := b.documentContext(d)
|
||||
html, _, err := b.markdown(p.Source, p.Body, b.defaultLang, ctx)
|
||||
html, _, err := b.markdown(p.Source, p.Body, p.Language, ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -171,6 +241,9 @@ func (b *builder) renderPosts() error {
|
|||
ctx["date"] = day
|
||||
ctx["post_body"] = html
|
||||
ctx["post_byline"] = byline(p)
|
||||
if err := b.postFields(i, ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
body, err := render.Substitute("templates/post.html", tmpl, ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -190,12 +263,8 @@ func byline(p content.Post) string {
|
|||
if p.Author != "" {
|
||||
out.WriteString(" · " + render.Escape(p.Author))
|
||||
}
|
||||
if len(p.Categories) > 0 {
|
||||
links := make([]string, len(p.Categories))
|
||||
for i, c := range p.Categories {
|
||||
links[i] = fmt.Sprintf(`<a href="%s">%s</a>`, categoryPath(c.Slug), render.Escape(c.Name))
|
||||
}
|
||||
out.WriteString(" · " + strings.Join(links, ", "))
|
||||
if links := categoryLinks(p); links != "" {
|
||||
out.WriteString(" · " + links)
|
||||
}
|
||||
return out.String()
|
||||
}
|
||||
|
|
@ -211,13 +280,17 @@ func (b *builder) renderCategories() error {
|
|||
}
|
||||
for _, c := range b.categories {
|
||||
d := document{
|
||||
lang: b.defaultLang, nav: "news", lead: "news", path: categoryPath(c.Slug), title: c.Name, prefixed: true,
|
||||
description: b.langs[b.defaultLang].Strings["category_h"] + ": " + c.Name,
|
||||
lang: b.newsLang, nav: "news", lead: "news", path: categoryPath(c.Slug), title: c.Name, prefixed: true,
|
||||
description: b.langs[b.newsLang].Strings["category_h"] + ": " + c.Name,
|
||||
source: fmt.Sprintf("the page of the category %q", c.Name),
|
||||
}
|
||||
ctx := b.documentContext(d)
|
||||
ctx["category_name"] = render.Escape(c.Name)
|
||||
ctx["category_posts"] = newsList(c.posts, b.defaultLang)
|
||||
panels, err := b.newsPanels(c.posts, b.newsLang)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
ctx["category_posts"] = panels
|
||||
body, err := render.Substitute("templates/category.html", tmpl, ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
|
|
@ -231,7 +304,6 @@ func (b *builder) renderCategories() error {
|
|||
|
||||
// renderFeed writes the feed next to the news page.
|
||||
func (b *builder) renderFeed() error {
|
||||
newsPath := b.byKey[pageKey{"news", b.defaultLang}].Path
|
||||
text := feed(b.cfg.Strings["base_url"], b.langs[b.defaultLang], newsPath, b.rendered, feedLimit)
|
||||
return b.publish(outputPath(newsPath+"feed.xml"), "the feed", text)
|
||||
text := feed(b.cfg.Strings["base_url"], b.langs[b.newsLang], b.newsPath, b.rendered, feedLimit)
|
||||
return b.publish(outputPath(b.newsPath+"feed.xml"), "the feed", text)
|
||||
}
|
||||
|
|
|
|||
113
internal/build/post.go
Normal file
113
internal/build/post.go
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
package build
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.kmalloc.org/squid/motorino/internal/content"
|
||||
"git.kmalloc.org/squid/motorino/internal/render"
|
||||
"git.kmalloc.org/squid/motorino/internal/site"
|
||||
)
|
||||
|
||||
// categoryLinks returns the links to the categories of a post, separated by a
|
||||
// comma, or an empty string when the post has none.
|
||||
func categoryLinks(p content.Post) string {
|
||||
links := make([]string, len(p.Categories))
|
||||
for i, c := range p.Categories {
|
||||
links[i] = fmt.Sprintf(`<a href="%s">%s</a>`, categoryPath(c.Slug), render.Escape(c.Name))
|
||||
}
|
||||
return strings.Join(links, ", ")
|
||||
}
|
||||
|
||||
// postFields adds to ctx the placeholders of the page of the post b.posts[i],
|
||||
// written in the language of the post:
|
||||
//
|
||||
// date_long the date for a reader, such as "14 November 2026"
|
||||
// post_summary the written description as a lead paragraph, or nothing
|
||||
// post_meta a line with the date, the author, the categories, the reading time
|
||||
// post_reading the reading time sentence, or nothing
|
||||
// post_mastodon the link to reply on Mastodon, or nothing
|
||||
// post_nav the links to the older and the newer post and to all the news
|
||||
// og_type article
|
||||
// article_meta the published time and a tag for each category
|
||||
//
|
||||
// Whatever needs a string that the language file lacks is left out, except the
|
||||
// Mastodon link: an address that was written and cannot be labelled is an error.
|
||||
func (b *builder) postFields(i int, ctx map[string]string) error {
|
||||
p := b.posts[i]
|
||||
l := b.langs[p.Language]
|
||||
long := render.Escape(longDate(p.Date, l))
|
||||
ctx["date_long"] = long
|
||||
|
||||
ctx["post_summary"] = ""
|
||||
if p.HasDescription {
|
||||
ctx["post_summary"] = `<p class="lede">` + render.Escape(p.Description) + "</p>"
|
||||
}
|
||||
|
||||
parts := []string{fmt.Sprintf(`<time datetime="%s">%s</time>`, p.Date.Format(dateOnly), long)}
|
||||
if p.Author != "" {
|
||||
parts = append(parts, render.Escape(p.Author))
|
||||
}
|
||||
if links := categoryLinks(p); links != "" {
|
||||
parts = append(parts, links)
|
||||
}
|
||||
reading := render.Escape(readingText(p.ReadingMinutes(), l))
|
||||
ctx["post_reading"] = reading
|
||||
if reading != "" {
|
||||
parts = append(parts, reading)
|
||||
}
|
||||
ctx["post_meta"] = `<p class="meta">` + strings.Join(parts, " · ") + "</p>"
|
||||
|
||||
ctx["post_mastodon"] = ""
|
||||
if p.Mastodon != "" {
|
||||
label := l.Strings["reply_mastodon"]
|
||||
if label == "" {
|
||||
return fmt.Errorf("%s: the post has a Mastodon address, but lang/%s.json has no reply_mastodon to label the link", p.Source, p.Language)
|
||||
}
|
||||
ctx["post_mastodon"] = fmt.Sprintf(`<p><a href="%s" rel="noopener">%s</a></p>`, render.EscapeAttr(p.Mastodon), render.Escape(label))
|
||||
}
|
||||
|
||||
ctx["post_nav"] = b.postNav(i, l)
|
||||
|
||||
ctx["og_type"] = "article"
|
||||
meta := []string{fmt.Sprintf(`<meta property="article:published_time" content="%s">`, p.Date.Format(time.RFC3339))}
|
||||
for _, c := range p.Categories {
|
||||
meta = append(meta, fmt.Sprintf(`<meta property="article:tag" content="%s">`, render.EscapeAttr(c.Name)))
|
||||
}
|
||||
ctx["article_meta"] = strings.Join(meta, "\n")
|
||||
return nil
|
||||
}
|
||||
|
||||
// postNav returns the navigation of a post page: the newer post, the older
|
||||
// post and the link to all the news. It is empty when the language lacks the
|
||||
// strings post_older, post_newer and post_nav, or when there is nothing to link.
|
||||
func (b *builder) postNav(i int, l site.Lang) string {
|
||||
older, newer, label := l.Strings["post_older"], l.Strings["post_newer"], l.Strings["post_nav"]
|
||||
if older == "" || newer == "" || label == "" {
|
||||
return ""
|
||||
}
|
||||
link := func(p content.Post, rel, text string) string {
|
||||
title := render.Escape(p.Title)
|
||||
if p.Language != "" && p.Language != l.Code {
|
||||
title = fmt.Sprintf(`<span lang="%s">%s</span>`, p.Language, title)
|
||||
}
|
||||
return fmt.Sprintf(`<li><a href="%s" rel="%s">%s: %s</a></li>`, p.Path, rel, render.Escape(text), title)
|
||||
}
|
||||
var items []string
|
||||
if i > 0 {
|
||||
items = append(items, link(b.posts[i-1], "next", newer))
|
||||
}
|
||||
if i+1 < len(b.posts) {
|
||||
items = append(items, link(b.posts[i+1], "prev", older))
|
||||
}
|
||||
if all := l.Strings["news_all"]; all != "" {
|
||||
items = append(items, fmt.Sprintf(`<li><a href="%s">%s</a></li>`, b.newsPath, render.Escape(all)))
|
||||
}
|
||||
if len(items) == 0 {
|
||||
return ""
|
||||
}
|
||||
return fmt.Sprintf("<nav aria-label=\"%s\">\n<ul>\n%s\n</ul>\n</nav>", render.EscapeAttr(label), strings.Join(items, "\n"))
|
||||
}
|
||||
58
internal/content/new.go
Normal file
58
internal/content/new.go
Normal file
|
|
@ -0,0 +1,58 @@
|
|||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
package content
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.kmalloc.org/squid/motorino/internal/mdx"
|
||||
)
|
||||
|
||||
// NewPost writes the file of a new post in dir/news and returns its path
|
||||
// relative to dir. The name comes from the title, the date is now with its own
|
||||
// offset, the category is News and the post is a draft, so that it is not
|
||||
// published until Draft is taken out. The author line is written only when
|
||||
// author is not empty. An existing file is never written over.
|
||||
func NewPost(dir, title, author string, now time.Time) (string, error) {
|
||||
title = strings.TrimSpace(title)
|
||||
if title == "" || strings.ContainsAny(title, "\r\n") {
|
||||
return "", fmt.Errorf("the title must be a single line of text")
|
||||
}
|
||||
if err := mdx.RejectEmDash("the title", title); err != nil {
|
||||
return "", err
|
||||
}
|
||||
slug, err := CategorySlug(title)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("the title %q has no letters or digits to make a file name from", title)
|
||||
}
|
||||
rel := "news/" + slug + ".md"
|
||||
path := filepath.Join(dir, filepath.FromSlash(rel))
|
||||
if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
|
||||
return "", fmt.Errorf("create %s: %w", filepath.Dir(path), err)
|
||||
}
|
||||
var b strings.Builder
|
||||
b.WriteString("Title: " + title + "\n")
|
||||
if author != "" {
|
||||
b.WriteString("Author: " + author + "\n")
|
||||
}
|
||||
b.WriteString("Date: " + now.Format("2006-01-02T15:04:05-0700") + "\n")
|
||||
b.WriteString("Categories: News\n")
|
||||
b.WriteString("Description:\n")
|
||||
b.WriteString("Draft: true\n-\n\n")
|
||||
file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o644)
|
||||
if err != nil {
|
||||
if os.IsExist(err) {
|
||||
return "", fmt.Errorf("%s already exists", rel)
|
||||
}
|
||||
return "", fmt.Errorf("create %s: %w", rel, err)
|
||||
}
|
||||
defer file.Close()
|
||||
if _, err := file.WriteString(b.String()); err != nil {
|
||||
return "", fmt.Errorf("write %s: %w", rel, err)
|
||||
}
|
||||
return rel, nil
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue