Merge branch 'feat/blog-news' into feat/gemini-output
All checks were successful
check / check (pull_request) Successful in 30s

This commit is contained in:
tgiachi 2026-11-16 12:50:17 +01:00
commit faff6476ab
8 changed files with 688 additions and 48 deletions

View file

@ -4,6 +4,7 @@ package build
import (
"fmt"
"sort"
"strconv"
"strings"
@ -109,24 +110,43 @@ type (
}
)
// groupArchive groups posts, newest first, by year and by month, as written in
// their dates. The years and the months are newest first too.
// 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 {
var years []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())
if len(years) == 0 || years[len(years)-1].year != y {
years = append(years, archiveYear{year: y})
year := years[y]
if year == nil {
year = &archiveYear{year: y}
years[y] = year
}
year := &years[len(years)-1]
year.posts = append(year.posts, p)
if len(year.months) == 0 || year.months[len(year.months)-1].month != m {
year.months = append(year.months, archiveMonth{year: y, month: m})
month := months[key{y, m}]
if month == nil {
month = &archiveMonth{year: y, month: m}
months[key{y, m}] = month
}
month := &year.months[len(year.months)-1]
month.posts = append(month.posts, p)
}
return years
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.
@ -151,14 +171,15 @@ func (b *builder) monthList(y archiveYear, lang string) string {
}
// newsArchive returns the nested list of the years and the months that have
// posts, or the news_empty text when there are none. It needs the archive pages.
// 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 "<p>\n" + ctx["news_empty"] + "\n</p>", nil
return "", nil
}
items := make([]string, len(years))
for i, y := range years {

View file

@ -3,6 +3,7 @@
package build
import (
"encoding/xml"
"path/filepath"
"strings"
"testing"
@ -526,3 +527,180 @@ func TestPanelOfAPostInAnotherLanguage(t *testing.T) {
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" &amp; &lt;b&gt;go&lt;/b&gt; ünï 日本語`
attr := `Say &quot;hi&quot; &amp; &lt;b&gt;go&lt;/b&gt; ü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>`)
}

View file

@ -31,6 +31,10 @@ type Options struct {
// 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, because motorino builds the
@ -93,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 {
@ -127,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.
@ -331,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))

View file

@ -31,6 +31,8 @@ type GeminiOptions struct {
Now time.Time
// Drafts publishes the drafts and the posts dated in the future too.
Drafts bool
// Clean empties OutDir before the capsule is written, as Options.Clean does.
Clean bool
// Language is the language served at the root of the capsule, the others
// living under /<code>/. It is the language the server serves by default
// (Agate's --lang). Empty means gemini_language of site.json, then the
@ -42,6 +44,9 @@ type GeminiOptions struct {
type GeminiResult struct {
// Pages is the number of gemtext files written.
Pages int
// Stale lists the files that were already in the output folder and that this
// build did not write; see Result.Stale.
Stale []string
}
// gemNews is the address of the news in the capsule. They exist once, whatever
@ -104,17 +109,18 @@ func BuildGemini(opts GeminiOptions) (GeminiResult, error) {
if err != nil {
return GeminiResult{}, err
}
files := make(map[string][]byte, len(g.gemFiles)+len(assets))
for rel, text := range g.gemFiles {
if err := writeFile(opts.OutDir, rel, []byte(text)); err != nil {
return GeminiResult{}, err
}
files[rel] = []byte(text)
}
for rel, data := range assets {
if err := writeFile(opts.OutDir, rel, data); err != nil {
return GeminiResult{}, err
}
files[rel] = data
}
return GeminiResult{Pages: pages}, nil
stale, err := writeOutput(opts.OutDir, opts.SiteDir, opts.Clean, files)
if err != nil {
return GeminiResult{}, err
}
return GeminiResult{Pages: pages, Stale: stale}, nil
}
// rootLanguage returns the language at the root of the capsule: the option,

105
internal/build/output.go Normal file
View 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
}

View file

@ -0,0 +1,37 @@
// SPDX-License-Identifier: GPL-3.0-or-later
package build
import (
"path/filepath"
"strings"
"testing"
)
// init adds the Gemini output to the tests of the output folder in output_test.go.
func init() {
extraBuilders["gemini"] = func(site string) func(string, bool) ([]string, error) {
return func(out string, clean bool) ([]string, error) {
r, err := BuildGemini(GeminiOptions{SiteDir: site, OutDir: out, Version: "1.2.3", Now: fixedNow, Clean: clean, Language: "en"})
return r.Stale, err
}
}
}
// TestGeminiCleanRefusesAFolderThatHoldsTheSite checks that -clean never empties the folder of the site, or one above it.
func TestGeminiCleanRefusesAFolderThatHoldsTheSite(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 := BuildGemini(GeminiOptions{SiteDir: site, OutDir: out, Now: fixedNow, Clean: true}); err == nil || !strings.Contains(err.Error(), "site") {
t.Errorf("BuildGemini into %s: error = %v, want one about the site", out, err)
}
}
if !exists(t, site, "site.json") {
t.Error("the site is gone")
}
}

View 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")
}
}

View file

@ -134,9 +134,10 @@ func (b *builder) markdown(name, source, lang string, ctx map[string]string) (st
var codeElement = regexp.MustCompile(`(?s)<code[^>]*>.*?</code>`)
// replaceBlocks replaces each paragraph that holds only a block placeholder by
// what replace returns for the name of the block. A block placeholder inside
// other text is an error. All blocks are checked before any is replaced, so the
// text of a generated list (a news title may say {{latest_news}}) is never
// what replace returns for the name of the block. 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 replaced,
// so the text of a generated list (a news title may say {{latest_news}}) is never
// taken for a placeholder.
func replaceBlocks(name, html string, replace func(block string) (string, error)) (string, error) {
outside := codeElement.ReplaceAllString(html, "")
@ -155,6 +156,10 @@ func replaceBlocks(name, html string, replace func(block string) (string, error)
if err != nil {
return "", err
}
if generated == "" && headedBlocks[block] {
html = removeWithHeading(html, marker)
continue
}
html = strings.ReplaceAll(html, marker, generated)
}
return html, nil
@ -165,6 +170,32 @@ func (b *builder) expandBlocks(name, html, lang string, ctx map[string]string) (
return replaceBlocks(name, html, func(block string) (string, error) { return b.block(block, lang, ctx) })
}
// 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 {