diff --git a/CHANGELOG.md b/CHANGELOG.md
index dcd4106..2e89b5e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,29 +1,3 @@
-## [1.3.0](https://git.kmalloc.org/squid/motorino/compare/v1.2.0...v1.3.0) (2026-11-16)
-
-### Features
-
-* **build:** report the old files of the output folder, add -clean ([52edb15](https://git.kmalloc.org/squid/motorino/commit/52edb15b64d95959e6acdec9bc194cd2cc6aba7e)), closes [#9](https://git.kmalloc.org/squid/motorino/issues/9)
-* **feed:** carry the full text in content:encoded ([3f62c79](https://git.kmalloc.org/squid/motorino/commit/3f62c7960373c044dc014c8355496038ede94e22)), closes [#9](https://git.kmalloc.org/squid/motorino/issues/9)
-* **gemini:** write the site as a Gemini capsule ([2f169b8](https://git.kmalloc.org/squid/motorino/commit/2f169b8d9f79a49dcefd3ddc48e5db1404dd7e17)), closes [#10](https://git.kmalloc.org/squid/motorino/issues/10)
-* **gemtext:** convert the HTML of a page to gemtext ([28745d4](https://git.kmalloc.org/squid/motorino/commit/28745d452f923081f68983679a92772fe948d53e)), closes [#10](https://git.kmalloc.org/squid/motorino/issues/10)
-* **gemtext:** write a table wider than 80 columns as records ([889edbf](https://git.kmalloc.org/squid/motorino/commit/889edbfd63e9693d12957c63eda5fff1aa453229)), closes [#10](https://git.kmalloc.org/squid/motorino/issues/10)
-* motorino new writes a draft, motorino build -drafts previews it ([633da1c](https://git.kmalloc.org/squid/motorino/commit/633da1c46bf9bccd5b1ee9279a4c711ff441879d)), closes [#9](https://git.kmalloc.org/squid/motorino/issues/9)
-* **news:** a post page with date, author, categories, summary and links ([bf50b2e](https://git.kmalloc.org/squid/motorino/commit/bf50b2e1c2d835340415c776886e1c533f047765)), closes [#9](https://git.kmalloc.org/squid/motorino/issues/9)
-* **news:** blog list with pages, and an archive by year and month ([4a501d7](https://git.kmalloc.org/squid/motorino/commit/4a501d77b3c2ecd737db39620e226efcba78d873)), closes [#9](https://git.kmalloc.org/squid/motorino/issues/9)
-* **news:** hide drafts and future posts, give the news one language ([26edf78](https://git.kmalloc.org/squid/motorino/commit/26edf78449dfd66da49b0e05b5bd79869c2701ca)), closes [#9](https://git.kmalloc.org/squid/motorino/issues/9)
-* **news:** show the posts of the lists as note panels ([71cf140](https://git.kmalloc.org/squid/motorino/commit/71cf14006d48084281779b83ee3d0b07fbe91024)), closes [#9](https://git.kmalloc.org/squid/motorino/issues/9)
-
-### Bug Fixes
-
-* **gemini:** list items, spaces in addresses, wide tables, per post language, empty lists, layout images ([3764470](https://git.kmalloc.org/squid/motorino/commit/3764470e9b3ef294de63f069efce54bc2ef773fe)), closes [#10](https://git.kmalloc.org/squid/motorino/issues/10)
-* **news:** group the archive by the month as written, drop the empty lists ([6987541](https://git.kmalloc.org/squid/motorino/commit/6987541f88246f092b4325654f4c6789773afa53)), closes [#9](https://git.kmalloc.org/squid/motorino/issues/9)
-
-## [1.2.0](https://git.kmalloc.org/squid/motorino/compare/v1.1.0...v1.2.0) (2026-11-15)
-
-### Features
-
-* take the menu from the site, not from the code ([eb2a8dc](https://git.kmalloc.org/squid/motorino/commit/eb2a8dc))
-
## [1.1.0](https://git.kmalloc.org/squid/motorino/compare/v1.0.1...v1.1.0) (2026-11-15)
### Features
diff --git a/README.md b/README.md
index 5692809..06b5921 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
# motorino
-The static site generator of [kmalloc.org](https://kmalloc.org/). It turns Markdown pages, news, templates and language files into plain HTML with no JavaScript, and into a Gemini capsule. It is made for that one site and is not a general-purpose generator.
+The static site generator of [kmalloc.org](https://kmalloc.org/). It turns Markdown pages, news, templates and language files into plain HTML with no JavaScript. It is made for that one site and is not a general-purpose generator.
Licence: GPL-3.0-or-later, see `LICENSE`.
@@ -8,18 +8,11 @@ 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 gemini -site DIR -out DIR write the same site as gemtext, for a Gemini server (defaults: . and capsule)
-motorino gemini -lang CODE ... the language at the root of the capsule; -drafts and -clean work as for build
-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
```
@@ -45,36 +38,11 @@ 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/.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//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 (`
`: 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.
+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/.html`.
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).
@@ -82,16 +50,6 @@ Pages: `Title`, `ID` (the same in every language, it links the translations), `D
`{{name}}`, with lowercase letters, digits and underscores, is replaced by a string from `site.json` or the language file. An unknown placeholder stops the build and names the file. Fenced code blocks (found the way CommonMark finds them, in lists and quotes too) are left as written, so an article can show a placeholder there. Anywhere else a backslash before the placeholder (`\{{name}}`) keeps it as written, in a code span too; two backslashes are one literal backslash followed by the value. Code spans are otherwise substituted, which is how a page shows a value in monospace. The id of a heading is not checked against ids that a template writes itself, such as the `news` of the latest news block. `{{news_list}}`, `{{latest_news}}` and `{{categories_list}}` stand alone in a paragraph and expand to generated lists.
-## Gemini
-
-`motorino gemini` reads the same site and writes gemtext: the pages of each language, the news once and a `.meta` file for the server. It does not read the templates, the style or the layouts: a page is its title, its text and a few navigation links.
-
-- **Language at the root.** The language served by default sits at the root and the others under `//`, the default language of the site included. It is set with `-lang`, else `gemini_language` in `site.json`, else the default language of the site. The server must be started with the same default (Agate: `--lang`). It must be a language that has a home page.
-- **`.meta`.** The server reads the language of each document from `/.meta`, which it never serves and no page links to. For every language other than the root one there are two lines, `en/*:;lang=en` and `en/**/*:;lang=en`, because a `*` does not cross folders, and the same two lines for `news/` when the news are not in the root language. It is for Agate run with `--central-conf`. A post that names another `Language` than the news has a line of its own, with the path of its file (`news/2026/11/slug.gmi:;lang=it`). The server uses the first line that matches a document, so these come first, then the folders.
-- **News.** They exist once, under `/news/`, as in the website: the index, the posts, the categories, the archives and `news/feed.gmi`, a list of `=> /news/2026/11/post.gmi 2026-11-14 Title` lines, newest first, which feed readers subscribe to. Every page ends with the navigation of its language, which has the news. `{{news_blog}}` lists all the posts, without pages of ten.
-- **Conversion.** A heading is a heading (three levels), a paragraph is a line, the links of a paragraph, list, quote or table follow it on lines of their own, a list is bullets (a list of only links is link lines), a quote or a note is a quote, code is a preformatted block, a table is a preformatted block of aligned columns, or, when it is wider than 80 columns, a heading for each row (its first cell) with a bullet for each other cell named by its column, a bullet for each row when there is no header or only one column, an image with an alt text is a link line, unless it belongs to the layout (it has the class `logo`, `mark` or `decorative`, or the role `presentation` or `none`: then nothing is written and the file is not copied), and emphasis is dropped. A list item with no text, only an image or a link, has no bullet; a preformatted block in an item follows its bullet. A page has one first level heading: its title; a first heading that says the title is dropped and the others go one level down. The blocks (`{{news_list}}`, `{{latest_news}}` and the others) become generated lines, with the texts of the language file.
-- **Addresses.** An address of the site becomes the address of its page in the capsule (`/people.html` is `/en/people.gmi`), and a fragment is dropped. A file listed in `assets` is copied when a page points to it, and only then. `http`, `https`, `mailto`, `gemini`, `xmpp`, `irc`, `ircs`, `matrix`, `bitcoin`, `magnet`, `tel` and `sms` links stay as they are. A path the website serves by other means (`/~squid/`) becomes a link to the website when it starts with one of the comma separated prefixes of `gemini_web_paths` in `site.json`. Any other address that leads nowhere stops the build and names the page.
-
## Development
```
diff --git a/cmd/motorino/main.go b/cmd/motorino/main.go
index 247c26b..a1997f1 100644
--- a/cmd/motorino/main.go
+++ b/cmd/motorino/main.go
@@ -5,9 +5,7 @@
//
// Usage:
//
-// motorino build [-site DIR] [-out DIR] [-drafts] [-clean]
-// motorino gemini [-site DIR] [-out DIR] [-lang CODE] [-drafts] [-clean]
-// motorino new [-site DIR] "title"
+// motorino build [-site DIR] [-out DIR]
// motorino version
package main
@@ -18,16 +16,13 @@ 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] [-drafts] [-clean] | motorino gemini [-site DIR] [-out DIR] [-lang CODE] [-drafts] [-clean] | motorino new [-site DIR] \"title\" | motorino version"
+const usage = "usage: motorino build [-site DIR] [-out DIR] | motorino version"
// main runs the command line and exits with its status code.
func main() {
@@ -47,10 +42,6 @@ func run(args []string, stdout, stderr io.Writer) int {
return 0
case "build":
return runBuild(args[1:], stdout, stderr)
- case "gemini":
- return runGemini(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
@@ -63,8 +54,6 @@ 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
@@ -75,84 +64,11 @@ 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(), Drafts: *drafts, Clean: *clean})
+ result, err := build.Build(build.Options{SiteDir: *site, OutDir: *out, Version: version.String()})
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])
-}
-
-// runGemini parses the flags of the gemini command and writes the site as a
-// Gemini capsule.
-func runGemini(args []string, stdout, stderr io.Writer) int {
- flags := flag.NewFlagSet("gemini", flag.ContinueOnError)
- flags.SetOutput(stderr)
- site := flags.String("site", ".", "the folder of the site")
- out := flags.String("out", "capsule", "the folder the gemtext is written to")
- lang := flags.String("lang", "", "the language at the root of the capsule (default: gemini_language of site.json, then the default language)")
- 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
- }
- return 2
- }
- if flags.NArg() > 0 {
- fmt.Fprintf(stderr, "motorino: unexpected arguments: %s\n%s\n", strings.Join(flags.Args(), " "), usage)
- return 2
- }
- result, err := build.BuildGemini(build.GeminiOptions{SiteDir: *site, OutDir: *out, Version: version.String(), Drafts: *drafts, Language: *lang, Clean: *clean})
- if err != nil {
- fmt.Fprintf(stderr, "motorino: %v\n", err)
- return 1
- }
- fmt.Fprintf(stdout, "wrote %d gemtext files into %s\n", result.Pages, *out)
- warnStale(stderr, *out, result.Stale)
- return 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
}
diff --git a/cmd/motorino/main_test.go b/cmd/motorino/main_test.go
index bf82569..cd8f08a 100644
--- a/cmd/motorino/main_test.go
+++ b/cmd/motorino/main_test.go
@@ -122,192 +122,3 @@ 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)
- }
-}
-
-// TestRunGemini checks the gemini command: the capsule, the language flag and the drafts flag.
-func TestRunGemini(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
- capsule := filepath.Join(t.TempDir(), "capsule")
- if code := run([]string{"gemini", "-site", dir, "-out", capsule, "-lang", "en"}, &out, &errOut); code != 0 {
- t.Fatalf("run(gemini) = %d, stderr %q", code, errOut.String())
- }
- if want := "gemtext files into " + capsule; !strings.Contains(out.String(), want) {
- t.Errorf("output %q does not contain %q", out.String(), want)
- }
- for _, rel := range []string{"index.gmi", "manifesto.gmi", "people.gmi", "services.gmi", "news/index.gmi", "news/feed.gmi", ".meta"} {
- if _, err := os.Stat(filepath.Join(capsule, filepath.FromSlash(rel))); err != nil {
- t.Errorf("no %s in the capsule: %v", rel, err)
- }
- }
- if _, err := os.Stat(filepath.Join(capsule, "news", "2026", "01", "wip.gmi")); err == nil {
- t.Error("a draft is published without -drafts")
- }
- preview := filepath.Join(t.TempDir(), "preview")
- if code := run([]string{"gemini", "-drafts", "-site", dir, "-out", preview}, &out, &errOut); code != 0 {
- t.Fatalf("run(gemini -drafts) = %d, stderr %q", code, errOut.String())
- }
- if _, err := os.Stat(filepath.Join(preview, "news", "2026", "01", "wip.gmi")); err != nil {
- t.Errorf("a draft is missing from the capsule with -drafts: %v", err)
- }
-}
-
-// TestRunGeminiErrors checks the exit codes: 1 for a failed build, 2 for a mistake in the command line.
-func TestRunGeminiErrors(t *testing.T) {
- var out, errOut bytes.Buffer
- if code := run([]string{"gemini", "-site", miniSite(t), "-out", filepath.Join(t.TempDir(), "c"), "-lang", "xx"}, &out, &errOut); code != 1 || !strings.Contains(errOut.String(), `"xx"`) {
- t.Errorf("an unknown language: code %d, stderr %q, want 1 and a message that names it", code, errOut.String())
- }
- errOut.Reset()
- if code := run([]string{"gemini", "extra"}, &out, &errOut); code != 2 || !strings.Contains(errOut.String(), "unexpected arguments") {
- t.Errorf("an extra argument: code %d, stderr %q, want 2", code, errOut.String())
- }
-}
-
-// 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")
- }
-}
-
-// TestRunGeminiOldFilesAndClean checks the warning about old files and -clean for the gemini command.
-func TestRunGeminiOldFilesAndClean(t *testing.T) {
- site := miniSite(t)
- var out, errOut bytes.Buffer
- capsule := t.TempDir()
- if err := os.WriteFile(filepath.Join(capsule, "old.gmi"), []byte("old"), 0o644); err != nil {
- t.Fatal(err)
- }
- if code := run([]string{"gemini", "-site", site, "-out", capsule}, &out, &errOut); code != 0 || !strings.Contains(errOut.String(), "old.gmi") {
- t.Fatalf("run(gemini) = %d, stderr %q, want 0 and a warning that names old.gmi", code, errOut.String())
- }
- errOut.Reset()
- if code := run([]string{"gemini", "-clean", "-site", site, "-out", capsule}, &out, &errOut); code != 1 || !strings.Contains(errOut.String(), ".motorino-out") {
- t.Fatalf("run(gemini -clean) into a folder that is not motorino's = %d, stderr %q", code, errOut.String())
- }
- fresh := filepath.Join(t.TempDir(), "capsule")
- for i := 0; i < 2; i++ {
- errOut.Reset()
- if code := run([]string{"gemini", "-clean", "-site", site, "-out", fresh}, &out, &errOut); code != 0 || errOut.Len() != 0 {
- t.Fatalf("run(gemini -clean) %d = %d, stderr %q", i+1, code, errOut.String())
- }
- }
-}
diff --git a/internal/build/blog.go b/internal/build/blog.go
deleted file mode 100644
index 0a8a7a5..0000000
--- a/internal/build/blog.go
+++ /dev/null
@@ -1,239 +0,0 @@
-// 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 "
\n" + ctx["news_empty"] + "\n
", 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(`%s`, pagePath(b.newsPath, n-1), render.Escape(newer)))
- }
- parts = append(parts, render.Escape(page))
- if n < total {
- parts = append(parts, fmt.Sprintf(`%s`, pagePath(b.newsPath, n+1), render.Escape(older)))
- }
- return fmt.Sprintf("", 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(`
"
-}
-
-// 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("
", 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
-}
diff --git a/internal/build/blog_test.go b/internal/build/blog_test.go
deleted file mode 100644
index fe21863..0000000
--- a/internal/build/blog_test.go
+++ /dev/null
@@ -1,706 +0,0 @@
-// 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 = `
{{post_title}}
-
-{{post_summary}}
-{{post_meta}}
-{{post_body}}
-{{post_mastodon}}
-{{post_nav}}
-`
-
-// blogBaseTemplate is the base template with the Open Graph placeholders.
-const blogBaseTemplate = `
-
-
-
-{{title_html}}
-
-
-{{article_meta}}
-
-{{alt_links}}
-
-
-
-{{header}}
-
-{{content}}
-{{footer}}
-
-
-`
-
-// 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,
- `
")
- 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, `Read more.`)
- 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, `2026 (6)`)
- dec, nov, sep := strings.Index(index, ">December 2026 (1)"), strings.Index(index, ">November 2026 (4)"), strings.Index(index, ">September 2026 (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") != 1 {
- t.Error("November is listed more than once")
- }
- month := readOut(t, out, "news/2026/11/index.html")
- late, mid, shop := strings.Index(month, "Late."), strings.Index(month, "Mid."), strings.Index(month, "A shop.")
- if late < 0 || mid < late || shop < mid || strings.Contains(month, "Early.") {
- t.Errorf("the month of November is wrong:\n%s", month)
- }
- mustContain(t, "month of December", readOut(t, out, "news/2026/12/index.html"), "Early.")
-}
-
-// 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", ">Archive"} {
- if strings.Contains(got, heading) {
- t.Errorf("the index keeps the heading %q of an empty list", heading)
- }
- }
- mustContain(t, "news index", got, "
News
")
-}
-
-// 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"), `
Technology.
`)
-}
-
-// 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", ">Archive")
-}
-
-// 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", `Older news`)
- 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", `Newer news`, "GNU/Linux Day 2026.")
- 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"), `
`)
-}
-
-// 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" & go ü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), ""+escaped+".", `aria-label="Read more: `+attr+`"`)
- }
- mustContain(t, "the post", readOut(t, out, "news/2026/11/odd.html"), "
"+escaped+"
")
- 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), "go") {
- 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: Ciao`)
- mustContain(t, "italian post", readOut(t, out, "news/2026/11/ciao.html"), `rel="next">Piu recente: Status page`)
-}
diff --git a/internal/build/build.go b/internal/build/build.go
index f38ea46..d43a902 100644
--- a/internal/build/build.go
+++ b/internal/build/build.go
@@ -9,7 +9,6 @@ import (
"path/filepath"
"sort"
"strings"
- "time"
"git.kmalloc.org/squid/motorino/internal/content"
"git.kmalloc.org/squid/motorino/internal/site"
@@ -25,24 +24,11 @@ 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, 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_ and mark it with cur_.
-var requiredPages = []string{"home", "news"}
+// requiredPages are the IDs every site must have in its default language,
+// because the menu and the footer link to them.
+var requiredPages = []string{"home", "manifesto", "people", "projects", "services", "news", "history"}
// newsOnHome is how many news the home page lists; feedLimit is how many the feed has.
const (
@@ -59,22 +45,12 @@ type builder struct {
cfg site.Config
langs map[string]site.Lang
defaultLang string
- // 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
+ pages []content.Page
+ posts []content.Post
+ categories []categoryEntry
+ templates map[string]string
+ css string
+ byKey map[pageKey]content.Page
// files holds the rendered output: relative path to content.
files map[string]string
// owners names, for each output file, what produces it.
@@ -97,18 +73,13 @@ 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, 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.
+// build that are no longer produced are not removed: build into a fresh folder
+// when that matters, as the deploy does.
func Build(opts Options) (Result, error) {
b, err := load(opts)
if err != nil {
@@ -123,9 +94,6 @@ 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
}
@@ -136,18 +104,10 @@ func Build(opts Options) (Result, error) {
if err != nil {
return Result{}, err
}
- 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 {
+ if err := b.write(assets); err != nil {
return Result{}, err
}
- return Result{Pages: len(b.indexable), Stale: stale}, nil
+ return Result{Pages: len(b.indexable)}, nil
}
// load reads the configuration, the content, the templates and the style.
@@ -157,33 +117,18 @@ func load(opts Options) (*builder, error) {
return nil, err
}
b := &builder{
- opts: opts, cfg: cfg, langs: langs, defaultLang: cfg.Languages[0], now: opts.Now,
+ opts: opts, cfg: cfg, langs: langs, defaultLang: cfg.Languages[0],
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
}
- all, err := content.LoadPosts(opts.SiteDir)
- if err != nil {
+ if b.posts, err = content.LoadPosts(opts.SiteDir); err != nil {
return nil, err
}
- if b.posts, err = b.publishedPosts(all); err != nil {
- return nil, err
- }
- seenID := map[string]bool{}
for _, p := range b.pages {
b.byKey[pageKey{p.ID, p.Lang}] = p
- if !seenID[p.ID] {
- seenID[p.ID] = true
- b.pageIDs = append(b.pageIDs, p.ID)
- }
for lang := range p.Switch {
if _, known := langs[lang]; !known {
return nil, fmt.Errorf("%s: Switch names the language %q, which is not in site.json", p.Source, lang)
@@ -191,19 +136,13 @@ func load(opts Options) (*builder, error) {
}
}
for _, id := range requiredPages {
- 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 _, ok := b.byKey[pageKey{id, b.defaultLang}]; !ok {
+ return nil, fmt.Errorf("content/%s: there is no page with ID %q", b.defaultLang, id)
}
}
- news := b.byKey[pageKey{"news", b.newsLang}]
- if !strings.HasSuffix(news.Path, "/") {
+ if news := b.byKey[pageKey{"news", b.defaultLang}]; !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
}
@@ -216,49 +155,6 @@ 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 {
@@ -348,6 +244,21 @@ 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))
diff --git a/internal/build/build_test.go b/internal/build/build_test.go
index a0b48f8..1d6623d 100644
--- a/internal/build/build_test.go
+++ b/internal/build/build_test.go
@@ -454,7 +454,7 @@ func TestBuildFeed(t *testing.T) {
feed := readOut(t, out, "news/feed.xml")
mustContain(t, "feed", feed,
"https://kmalloc.org/news/2026/11/shop.html",
- `The programme is out. See people.
`)
+ `<a href="https://kmalloc.org/people.html">people</a>`)
}
// TestBuildErrorsOnMissingTemplate checks that a missing layout template is named.
@@ -466,33 +466,3 @@ func TestBuildErrorsOnMissingTemplate(t *testing.T) {
t.Errorf("Build() error = %v, want it to name pages/manifesto", err)
}
}
-
-// TestBuildMenuComesFromTheSite checks that a page with an ID motorino has never
-// heard of can be linked and marked from a template, with no change to the code.
-func TestBuildMenuComesFromTheSite(t *testing.T) {
- files := baseFiles()
- files["content/en/labs.md"] = page("labs", "Labs", "", "Experiments.\n")
- files["templates/header.html"] = `
-Labs
-News
-
-`
- out, err := runBuild(t, files)
- if err != nil {
- t.Fatal(err)
- }
- mustContain(t, "labs.html", readOut(t, out, "labs.html"),
- `Labs`, `News`)
- mustContain(t, "index.html", readOut(t, out, "index.html"), `Labs`)
-}
-
-// TestBuildPagesBesidesHomeAndNewsAreOptional checks that only the home page and
-// the news section are required: the rest of the menu is the site's choice.
-func TestBuildPagesBesidesHomeAndNewsAreOptional(t *testing.T) {
- files := baseFiles()
- delete(files, "content/en/people.md")
- delete(files, "content/it/persone.md")
- if _, err := runBuild(t, files); err != nil {
- t.Errorf("Build() without a people page: %v", err)
- }
-}
diff --git a/internal/build/context.go b/internal/build/context.go
index d21f894..a46a049 100644
--- a/internal/build/context.go
+++ b/internal/build/context.go
@@ -9,13 +9,15 @@ import (
"git.kmalloc.org/squid/motorino/internal/render"
)
+// menuPages are the IDs of the pages in the menu; the current one is marked.
+var menuPages = []string{"home", "manifesto", "people", "projects", "services", "news"}
+
+// linkedPages are the IDs the templates link to with url_.
+var linkedPages = []string{"manifesto", "people", "projects", "services", "news", "history"}
+
// blockNames are the placeholders that expand to generated HTML. Until they
// are expanded they stand for themselves, so a page can hold them.
-var blockNames = []string{"news_list", "latest_news", "categories_list", "news_blog", "news_archive"}
-
-// sitePrefix goes before the title of a page that has no title of its own in the
-// browser, such as a post.
-const sitePrefix = "kmalloc.org: "
+var blockNames = []string{"news_list", "latest_news", "categories_list"}
// document describes one output page for the shared page frame.
type document struct {
@@ -76,10 +78,8 @@ func (b *builder) languageContext(lang string) map[string]string {
for k, label := range l.Nav {
ctx["nav_"+k] = render.Escape(label)
}
- for _, id := range b.pageIDs {
- if _, ok := b.byKey[pageKey{id, b.defaultLang}]; ok {
- ctx["url_"+id] = b.pageAddress(lang, id)
- }
+ for _, id := range linkedPages {
+ ctx["url_"+id] = b.pageAddress(lang, id)
}
ctx["history_attr"] = ""
if _, ok := b.byKey[pageKey{"history", lang}]; !ok {
@@ -105,62 +105,49 @@ func (b *builder) documentContext(d document) map[string]string {
ctx["doc_q"] = strings.NewReplacer(":", "%3A", "/", "%2F").Replace(docURL)
title := d.title
if d.prefixed {
- title = sitePrefix + title
+ title = "kmalloc.org: " + title
}
ctx["title_html"] = render.EscapeAttr(title)
ctx["page_title"] = render.Escape(d.title)
ctx["description_attr"] = render.EscapeAttr(d.description)
- ctx["og_type"] = "website"
- ctx["article_meta"] = ""
- for _, id := range b.pageIDs {
- ctx["cur_"+id] = ""
- if d.nav == id {
- ctx["cur_"+id] = ` aria-current="page"`
+ for _, k := range menuPages {
+ ctx["cur_"+k] = ""
+ if d.nav == k {
+ ctx["cur_"+k] = ` aria-current="page"`
}
}
ctx["lang_links"], ctx["alt_links"] = b.languageLinks(d)
return ctx
}
-// langTarget is a page in another language that a page links to.
-type langTarget struct{ lang, path string }
-
-// languageTargets returns the pages in the other languages that a page links
-// to: its translations, with the address a Switch key gives instead of the
-// translation, or, when it has none, the home of the first other language that
-// has one.
-func (b *builder) languageTargets(d document) []langTarget {
- var twins []langTarget
+// languageLinks returns the links to the other languages for the menu and the
+// alternate links for the head. A page without translations links to the home
+// of the first other language that has one.
+func (b *builder) languageLinks(d document) (links, alternates string) {
+ type target struct{ lang, path string }
+ var twins []target
if d.id != "" {
for _, l := range b.cfg.Languages {
if p, ok := b.byKey[pageKey{d.id, l}]; ok && l != d.lang {
- twins = append(twins, langTarget{l, p.Path})
+ twins = append(twins, target{l, p.Path})
}
}
}
if len(twins) == 0 {
for _, l := range b.cfg.Languages {
if p, ok := b.byKey[pageKey{"home", l}]; ok && l != d.lang {
- twins = append(twins, langTarget{l, p.Path})
+ twins = append(twins, target{l, p.Path})
break
}
}
}
- for i, t := range twins {
- if override, ok := d.switches[t.lang]; ok {
- twins[i].path = override
- }
- }
- return twins
-}
-
-// languageLinks returns the links to the other languages for the menu and the
-// alternate links for the head.
-func (b *builder) languageLinks(d document) (links, alternates string) {
- twins := b.languageTargets(d)
anchors := make([]string, len(twins))
for i, t := range twins {
- anchors[i] = fmt.Sprintf(`%s`, render.EscapeAttr(t.path), t.lang, t.lang, render.Escape(b.langs[t.lang].Strings["lang_name"]))
+ href := t.path
+ if override, ok := d.switches[t.lang]; ok {
+ href = override
+ }
+ anchors[i] = fmt.Sprintf(`%s`, render.EscapeAttr(href), t.lang, t.lang, render.Escape(b.langs[t.lang].Strings["lang_name"]))
}
links = strings.Join(anchors, "\n·\n")
diff --git a/internal/build/date.go b/internal/build/date.go
deleted file mode 100644
index cdf9173..0000000
--- a/internal/build/date.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// 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))
-}
diff --git a/internal/build/date_test.go b/internal/build/date_test.go
deleted file mode 100644
index 5aa09d9..0000000
--- a/internal/build/date_test.go
+++ /dev/null
@@ -1,73 +0,0 @@
-// 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)
- }
-}
diff --git a/internal/build/feed.go b/internal/build/feed.go
index b9a1aeb..d9adb7c 100644
--- a/internal/build/feed.go
+++ b/internal/build/feed.go
@@ -15,16 +15,10 @@ 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 "", "]]]]>") + "]]>"
-}
-
// feed returns the RSS 2.0 feed of the latest limit posts, which must be sorted
-// 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/".
+// 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/".
func feed(base string, l site.Lang, newsURL string, posts []renderedPost, limit int) string {
if limit < len(posts) {
posts = posts[:limit]
@@ -38,16 +32,7 @@ func feed(base string, l site.Lang, newsURL string, posts []renderedPost, limit
items.WriteString("" + link + "\n")
items.WriteString(`` + link + "\n")
items.WriteString("" + p.Date.Format(time.RFC1123Z) + "\n")
- if p.Description != "" {
- items.WriteString("" + render.Escape(p.Description) + "\n")
- }
- if p.Author != "" {
- items.WriteString("" + render.Escape(p.Author) + "\n")
- }
- for _, c := range p.Categories {
- items.WriteString("" + render.Escape(c.Name) + "\n")
- }
- items.WriteString("" + cdata(text) + "\n")
+ items.WriteString("" + render.Escape(text) + "\n")
items.WriteString("\n")
}
built := ""
@@ -56,7 +41,7 @@ func feed(base string, l site.Lang, newsURL string, posts []renderedPost, limit
}
url := base + newsURL
return `
-
+kmalloc.org: ` + render.Escape(l.Nav["news"]) + `
` + url + `
diff --git a/internal/build/feed_test.go b/internal/build/feed_test.go
index 78c27a1..bf3b932 100644
--- a/internal/build/feed_test.go
+++ b/internal/build/feed_test.go
@@ -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 ", "A summary & more.", "FLUG", "Linux Day"), HTML: `
"},
}
@@ -35,11 +35,7 @@ func TestFeedItems(t *testing.T) {
`https://kmalloc.org/news/2026/11/new.html`,
"Sat, 14 Nov 2026 12:00:00 +0100",
"Sat, 14 Nov 2026 12:00:00 +0100",
- `xmlns:content="http://purl.org/rss/1.0/modules/content/"`,
- "A summary & more.",
- `See people.]]>`,
- "FLUG",
- "Linux Day",
+ `<a href="https://kmalloc.org/people.html">`,
} {
if !strings.Contains(got, want) {
t.Errorf("feed does not contain %q\n%s", want, got)
@@ -53,34 +49,6 @@ 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: "
" {
- 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: `p`}}
diff --git a/internal/build/fixture_test.go b/internal/build/fixture_test.go
index cf5d456..e02e0ac 100644
--- a/internal/build/fixture_test.go
+++ b/internal/build/fixture_test.go
@@ -46,12 +46,6 @@ 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()
diff --git a/internal/build/gemini.go b/internal/build/gemini.go
deleted file mode 100644
index f536d27..0000000
--- a/internal/build/gemini.go
+++ /dev/null
@@ -1,501 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package build
-
-import (
- "errors"
- "fmt"
- "os"
- "path"
- "path/filepath"
- "regexp"
- "sort"
- "strings"
- "time"
-
- "git.kmalloc.org/squid/motorino/internal/content"
- "git.kmalloc.org/squid/motorino/internal/gemtext"
- "git.kmalloc.org/squid/motorino/internal/mdx"
- "git.kmalloc.org/squid/motorino/internal/render"
-)
-
-// GeminiOptions tell BuildGemini where the site is and where to write the capsule.
-type GeminiOptions struct {
- // SiteDir is the folder of the site, the same one Build reads.
- SiteDir string
- // OutDir is the folder the gemtext is written to; it is created when missing.
- OutDir string
- // Version is the version of motorino.
- Version string
- // Now is the moment the capsule is built at, as in Options.
- 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 //. It is the language the server serves by default
- // (Agate's --lang). Empty means gemini_language of site.json, then the
- // default language of the site.
- Language string
-}
-
-// GeminiResult summarises a Gemini build.
-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
-// the language of the root, so it is always /news/.
-const gemNews = "/news/"
-
-// metaName is the file that tells the server the language of each folder; the
-// server reads it and never serves it.
-const metaName = ".meta"
-
-// gemini holds one Gemini build, on top of the loaded site.
-type gemini struct {
- *builder
- // root is the language served at the root.
- root string
- // pageAddr is the address of every page in the capsule, by ID and language.
- pageAddr map[pageKey]string
- // addr maps an address of the website to the address in the capsule.
- addr map[string]string
- // usedAssets lists the assets some page points to: only those are copied.
- usedAssets map[string]bool
- // gemFiles holds the output, and gemOwners what produces each file.
- gemFiles map[string]string
- gemOwners map[string]string
-}
-
-// BuildGemini reads the site in opts.SiteDir and writes it as a Gemini capsule
-// to opts.OutDir: the pages of each language, the news once under /news/ and a
-// .meta file for the server. Everything is rendered in memory first, so a
-// failure in the content leaves the folder untouched.
-func BuildGemini(opts GeminiOptions) (GeminiResult, error) {
- b, err := load(Options{SiteDir: opts.SiteDir, OutDir: opts.OutDir, Version: opts.Version, Now: opts.Now, Drafts: opts.Drafts})
- if err != nil {
- return GeminiResult{}, err
- }
- g := &gemini{
- builder: b, pageAddr: map[pageKey]string{}, addr: map[string]string{}, usedAssets: map[string]bool{},
- gemFiles: map[string]string{}, gemOwners: map[string]string{},
- }
- if g.root, err = g.rootLanguage(opts.Language); err != nil {
- return GeminiResult{}, err
- }
- g.mapAddresses()
- for _, p := range b.pages {
- if err := g.renderPage(p); err != nil {
- return GeminiResult{}, err
- }
- }
- steps := []func() error{g.renderPosts, g.renderCategories, g.renderArchives, g.renderFeed}
- for _, step := range steps {
- if err := step(); err != nil {
- return GeminiResult{}, err
- }
- }
- pages := len(g.gemFiles)
- if err := g.publish(metaName, "the language file of the server", g.meta()); err != nil {
- return GeminiResult{}, err
- }
- assets, err := g.assets()
- if err != nil {
- return GeminiResult{}, err
- }
- files := make(map[string][]byte, len(g.gemFiles)+len(assets))
- for rel, text := range g.gemFiles {
- 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 GeminiResult{}, err
- }
- return GeminiResult{Pages: pages, Stale: stale}, nil
-}
-
-// rootLanguage returns the language at the root of the capsule: the option,
-// else gemini_language of site.json, else the default language. It must be a
-// language of the site that has a home page.
-func (g *gemini) rootLanguage(option string) (string, error) {
- code, from := option, "the language option"
- if code == "" {
- code, from = g.cfg.Strings["gemini_language"], "gemini_language in site.json"
- }
- if code == "" {
- return g.defaultLang, nil
- }
- if _, ok := g.langs[code]; !ok {
- return "", fmt.Errorf("%s: %q is not one of the languages of the site", from, code)
- }
- if _, ok := g.byKey[pageKey{"home", code}]; !ok {
- return "", fmt.Errorf("%s: the language %q has no home page, so it cannot be the root of the capsule", from, code)
- }
- return code, nil
-}
-
-// meta returns the content of the .meta file. The server gives a document the
-// language of the first line that matches it, so the lines come from the most
-// specific to the most general:
-//
-// - a line for the file of every post written in another language than the news;
-// - for every language other than the one at the root, and for the news when they
-// are in another language, two lines for the folder. A glob does not cross
-// folders, so each folder has a line for itself and one for what is below it.
-func (g *gemini) meta() string {
- var out strings.Builder
- for _, p := range g.posts {
- if p.Language != g.newsLang {
- fmt.Fprintf(&out, "%s:;lang=%s\n", gemFile(gemPostAddress(p)), p.Language)
- }
- }
- line := func(folder, lang string) {
- fmt.Fprintf(&out, "%s/*:;lang=%s\n%s/**/*:;lang=%s\n", folder, lang, folder, lang)
- }
- for _, lang := range g.cfg.Languages {
- if lang != g.root {
- line(lang, lang)
- }
- }
- if g.newsLang != g.root {
- line(strings.Trim(gemNews, "/"), g.newsLang)
- }
- return out.String()
-}
-
-// pageGemAddress returns the address in the capsule of a page of lang whose
-// address in the website is html: the root language at the root, the others
-// under their code, .gmi for .html.
-func (g *gemini) pageGemAddress(lang, html string) string {
- p := html
- if lang != g.defaultLang {
- p = strings.TrimPrefix(p, "/"+lang)
- }
- if strings.HasSuffix(p, ".html") {
- p = strings.TrimSuffix(p, ".html") + ".gmi"
- }
- if lang != g.root {
- p = "/" + lang + p
- }
- return p
-}
-
-// gemPostAddress, gemCategoryAddress, gemYearAddress and gemMonthAddress are the
-// addresses in the capsule of a post, a category and the archives.
-func gemPostAddress(p content.Post) string { return strings.TrimSuffix(p.Path, ".html") + ".gmi" }
-func gemCategoryAddress(slug string) string { return gemNews + "category/" + slug + ".gmi" }
-func gemYearAddress(year int) string { return fmt.Sprintf("%s%04d/", gemNews, year) }
-func gemMonthAddress(year, month int) string {
- return fmt.Sprintf("%s%04d/%02d/", gemNews, year, month)
-}
-
-// mapAddresses fills the maps from the addresses of the website to those of the capsule.
-func (g *gemini) mapAddresses() {
- for _, p := range g.pages {
- address := g.pageGemAddress(p.Lang, p.Path)
- if p.ID == "news" && p.Lang == g.newsLang {
- address = gemNews
- }
- g.pageAddr[pageKey{p.ID, p.Lang}] = address
- g.addr[p.Path] = address
- }
- for _, p := range g.posts {
- g.addr[p.Path] = gemPostAddress(p)
- }
- for _, c := range g.categories {
- g.addr[categoryPath(c.Slug)] = gemCategoryAddress(c.Slug)
- }
- for _, y := range groupArchive(g.posts) {
- g.addr[g.yearPath(y.year)] = gemYearAddress(y.year)
- for _, m := range y.months {
- g.addr[g.monthPath(m.year, m.month)] = gemMonthAddress(m.year, m.month)
- }
- }
- g.addr[g.newsPath+"feed.xml"] = gemNews + "feed.gmi"
-}
-
-// publish stores a file of the capsule; source names what produced it.
-func (g *gemini) publish(rel, source, text string) error {
- if other, taken := g.gemOwners[rel]; taken {
- return fmt.Errorf("%s and %s are both published as %s", other, source, rel)
- }
- g.gemOwners[rel] = source
- g.gemFiles[rel] = text
- return nil
-}
-
-// gemFile returns the file of an address of the capsule: a folder gets index.gmi.
-func gemFile(address string) string {
- rel := strings.TrimPrefix(address, "/")
- if rel == "" || strings.HasSuffix(rel, "/") {
- rel += "index.gmi"
- }
- return rel
-}
-
-// scheme matches the start of an address that names a protocol.
-var scheme = regexp.MustCompile(`^([A-Za-z][A-Za-z0-9+.-]*):`)
-
-// externalSchemes are the protocols a link may use to leave the capsule.
-var externalSchemes = map[string]bool{
- "http": true, "https": true, "mailto": true, "gemini": true, "xmpp": true, "irc": true, "ircs": true, "matrix": true,
- "bitcoin": true, "magnet": true, "tel": true, "sms": true,
-}
-
-// resolve turns an address found in the HTML of the page at base into the
-// address to write in the capsule. An address with a protocol stays as it is
-// when the protocol is a known one, and is an error otherwise; an address in the
-// website is mapped to its page or file, and a file is copied by the end of the
-// build. An address that starts with one of the paths of gemini_web_paths in
-// site.json is one the website serves by other means: it becomes a link to the
-// website. A fragment alone is dropped, and so is the fragment of an address: a
-// gemini link cannot point inside a document.
-func (g *gemini) resolve(href, base string) (string, error) {
- if strings.HasPrefix(href, "#") {
- return "", nil
- }
- if m := scheme.FindStringSubmatch(href); m != nil {
- if !externalSchemes[strings.ToLower(m[1])] {
- return "", fmt.Errorf("the protocol %q is not supported", m[1])
- }
- return href, nil
- }
- if strings.HasPrefix(href, "//") {
- return "", errors.New("an address that starts with // is not supported")
- }
- target, _, _ := strings.Cut(href, "#")
- if !strings.HasPrefix(target, "/") {
- folder := path.Dir(base)
- if strings.HasSuffix(base, "/") {
- folder = strings.TrimSuffix(base, "/")
- }
- joined := path.Join("/", folder, target)
- if strings.HasSuffix(target, "/") && joined != "/" {
- joined += "/"
- }
- target = joined
- }
- if address, ok := g.addr[target]; ok {
- return address, nil
- }
- name := strings.TrimPrefix(target, "/")
- for asset := range g.cfg.Assets {
- if path.Clean(asset) == name {
- g.usedAssets[asset] = true
- return target, nil
- }
- }
- for _, prefix := range strings.Split(g.cfg.Strings["gemini_web_paths"], ",") {
- if prefix = strings.TrimSpace(prefix); prefix != "" && strings.HasPrefix(target, prefix) {
- return g.cfg.Strings["base_url"] + target, nil
- }
- }
- return "", errors.New("no page or file of the site has this address (a path the website serves by other means goes in gemini_web_paths of site.json)")
-}
-
-// convert converts the HTML of a page or post to gemtext. base is the address
-// of the page in the website, lang its language.
-func (g *gemini) convert(name, html, base, lang string) (string, error) {
- text, err := gemtext.Convert(html, gemtext.Options{
- Link: func(href string) (string, error) { return g.resolve(href, base) },
- Block: func(block string) (string, error) { return g.block(block, lang) },
- })
- if err != nil {
- return "", fmt.Errorf("%s: %w", name, err)
- }
- return strings.TrimRight(text, "\n"), nil
-}
-
-// markdown replaces the placeholders of a source, converts it to HTML and puts
-// the element where a generated list goes, for convert to expand. A
-// list with nothing in it leaves no element, and the heading of an empty list of
-// categories or of the archive goes with it.
-func (g *gemini) markdown(name, source string, ctx map[string]string) (string, error) {
- text, err := mdx.SubstituteMarkdown(name, source, ctx)
- if err != nil {
- return "", err
- }
- html, _, err := mdx.Render(text)
- if err != nil {
- return "", fmt.Errorf("%s: %w", name, err)
- }
- lang := ctx["lang"]
- html, err = replaceBlocks(name, html, func(block string) (string, error) {
- text, err := g.block(block, lang)
- if err != nil || text == "" {
- return "", err
- }
- return ``, nil
- })
- if err != nil {
- return "", err
- }
- return render.Unescape(html), nil
-}
-
-// assets reads the files some page points to.
-func (g *gemini) assets() (map[string][]byte, error) {
- names := make([]string, 0, len(g.usedAssets))
- for name := range g.usedAssets {
- names = append(names, name)
- }
- sort.Strings(names)
- out := map[string][]byte{}
- for _, name := range names {
- source := g.cfg.Assets[name]
- data, err := os.ReadFile(filepath.Join(g.opts.SiteDir, filepath.FromSlash(source)))
- if err != nil {
- return nil, fmt.Errorf("asset %q: %w", name, err)
- }
- rel := path.Clean(name)
- if other, taken := g.gemOwners[rel]; taken {
- return nil, fmt.Errorf("the asset %q and %s are both published as %s", name, other, rel)
- }
- out[rel] = data
- }
- return out, nil
-}
-
-// heading is the first level heading of a page.
-func heading(title string) string { return "# " + strings.Join(strings.Fields(title), " ") }
-
-// withoutTitle prepares a body converted to gemtext to go under the heading of
-// the title. A leading heading that says the title is dropped, since the page
-// has it already, and the other first level headings go one level down: a page
-// has one.
-func withoutTitle(title, body string) string {
- lines := strings.Split(body, "\n")
- if first, ok := strings.CutPrefix(lines[0], "# "); ok && (first == title || strings.HasSuffix(title, ": "+first)) {
- lines = lines[1:]
- }
- fenced := false
- for i, line := range lines {
- switch {
- case strings.HasPrefix(line, "```"):
- fenced = !fenced
- case !fenced && strings.HasPrefix(line, "# "):
- lines[i] = "#" + line
- }
- }
- return strings.Join(lines, "\n")
-}
-
-// navigation returns the links every page ends with: the home and the entries
-// of the menu of the language, in the order its file lists them, then the
-// other languages. An entry whose page the language lacks is left out.
-func (g *gemini) navigation(d document) string {
- l := g.langs[d.lang]
- var menu []string
- if home, ok := g.pageAddr[pageKey{"home", d.lang}]; ok {
- label := l.Strings["back"]
- if label == "" {
- label = g.byKey[pageKey{"home", d.lang}].Title
- }
- menu = append(menu, gemtext.Link(home, label))
- }
- for _, key := range l.NavOrder {
- address, ok := g.pageAddr[pageKey{key, d.lang}]
- if !ok && key == "news" {
- address, ok = gemNews, true
- }
- if ok {
- menu = append(menu, gemtext.Link(address, l.Nav[key]))
- }
- }
- parts := []string{strings.Join(menu, "\n")}
- var others []string
- for _, t := range g.languageTargets(d) {
- if address, err := g.resolve(t.path, d.path); err == nil && address != "" {
- others = append(others, gemtext.Link(address, g.langs[t.lang].Strings["lang_name"]))
- }
- }
- if len(others) > 0 {
- parts = append(parts, strings.Join(others, "\n"))
- }
- return strings.Join(parts, "\n\n")
-}
-
-// translationNote returns the line, and the link to report a problem, that a
-// machine translated language puts at the top of its pages; empty for the others.
-func (g *gemini) translationNote(lang string) string {
- l := g.langs[lang]
- note := l.Strings["translation_note"]
- if note == "" {
- return ""
- }
- label, issues := l.Strings["translation_note_a"], g.cfg.Strings["issues_url"]
- if label == "" || issues == "" {
- return gemtext.Text(note)
- }
- return gemtext.Text(note+" "+label+".") + "\n" + gemtext.Link(issues, label)
-}
-
-// compose joins the parts of a page with a blank line between them, leaving out
-// the empty ones, and ends the text with a line break.
-func compose(parts ...string) string {
- var kept []string
- for _, part := range parts {
- if part = strings.Trim(part, "\n"); part != "" {
- kept = append(kept, part)
- }
- }
- return strings.Join(kept, "\n\n") + "\n"
-}
-
-// renderPage converts a page and writes it with the navigation.
-func (g *gemini) renderPage(p content.Page) error {
- d := document{
- lang: p.Lang, id: p.ID, nav: p.ID, path: p.Path, title: p.Title,
- description: p.Description, switches: p.Switch, source: p.Source,
- }
- ctx := g.documentContext(d)
- version, date := g.cfg.Strings["manifesto_version"], g.cfg.Strings["manifesto_date"]
- if p.ManifestoVersion != "" {
- version = p.ManifestoVersion
- }
- if p.ManifestoDate != "" {
- date = p.ManifestoDate
- }
- ctx["manifesto_version"], ctx["manifesto_date"] = render.Escape(version), render.Escape(date)
-
- source := p.Body
- if p.Layout == "manifesto" {
- var err error
- if source, err = mdx.NoEmDash(source); err != nil {
- return fmt.Errorf("%s: %w", p.Source, err)
- }
- }
- html, err := g.markdown(p.Source, source, ctx)
- if err != nil {
- return err
- }
- body, err := g.convert(p.Source, html, p.Path, p.Lang)
- if err != nil {
- return err
- }
- var intro []string
- if p.Layout == "manifesto" {
- intro = []string{g.manifestoLine(p.Lang, version, date), gemtext.Text(p.Note)}
- }
- parts := append([]string{heading(p.Title), g.translationNote(p.Lang)}, intro...)
- parts = append(parts, withoutTitle(p.Title, body), g.navigation(d))
- return g.publish(gemFile(g.pageAddr[pageKey{p.ID, p.Lang}]), p.Source, compose(parts...))
-}
-
-// manifestoLine is the line that says the version and the date of the manifesto.
-func (g *gemini) manifestoLine(lang, version, date string) string {
- line := strings.TrimSpace(g.langs[lang].Strings["version"] + " " + version)
- if date != "" {
- line += ", " + date
- }
- return gemtext.Text(line)
-}
diff --git a/internal/build/gemini_news.go b/internal/build/gemini_news.go
deleted file mode 100644
index 4a1742c..0000000
--- a/internal/build/gemini_news.go
+++ /dev/null
@@ -1,249 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package build
-
-import (
- "fmt"
- "strings"
-
- "git.kmalloc.org/squid/motorino/internal/content"
- "git.kmalloc.org/squid/motorino/internal/gemtext"
-)
-
-// newsLines returns the lines of a list of posts: a link line for each, with
-// its date in front of the title, the format feed readers know, and the
-// description under it when asked for.
-func newsLines(posts []content.Post, withDescription bool) string {
- var lines []string
- for _, p := range posts {
- lines = append(lines, gemtext.Link(gemPostAddress(p), p.Date.Format(dateOnly)+" "+p.Title))
- if withDescription && p.Description != "" {
- lines = append(lines, gemtext.Text(p.Description))
- }
- }
- return strings.Join(lines, "\n")
-}
-
-// block returns the gemtext of a generated list. The blog list is the whole list
-// of the posts: a capsule has no pages of ten.
-func (g *gemini) block(name, lang string) (string, error) {
- l := g.langs[lang]
- empty := gemtext.Text(l.Strings["news_empty"])
- switch name {
- case "news_list", "news_blog":
- if len(g.posts) == 0 {
- return empty, nil
- }
- return newsLines(g.posts, true), nil
- case "latest_news":
- return g.latestNews(lang), nil
- case "categories_list":
- lines := make([]string, len(g.categories))
- for i, c := range g.categories {
- lines[i] = gemtext.Link(gemCategoryAddress(c.Slug), fmt.Sprintf("%s (%d)", c.Name, len(c.posts)))
- }
- return strings.Join(lines, "\n"), nil
- default:
- return g.archiveLines(lang), nil
- }
-}
-
-// latestNews returns the block of the latest news of the home page: a heading
-// with the name of the news in the menu, the sentence news_p, the first posts
-// and the link to all of them. It is empty without posts.
-func (g *gemini) latestNews(lang string) string {
- if len(g.posts) == 0 {
- return ""
- }
- l := g.langs[lang]
- var lines []string
- if name := l.Nav["news"]; name != "" {
- lines = append(lines, "#"+heading(name)+"\n")
- }
- if text := gemtext.Text(l.Strings["news_p"]); text != "" {
- lines = append(lines, text)
- }
- n := newsOnHome
- if n > len(g.posts) {
- n = len(g.posts)
- }
- lines = append(lines, newsLines(g.posts[:n], false))
- label := l.Strings["news_all"]
- if label == "" {
- label = l.Nav["news"]
- }
- return strings.Join(append(lines, gemtext.Link(gemNews, label)), "\n")
-}
-
-// archiveLines returns the years that have posts, each followed by its months, or
-// nothing when there are none: the list of the news says there is no news.
-func (g *gemini) archiveLines(lang string) string {
- years := groupArchive(g.posts)
- if len(years) == 0 {
- return ""
- }
- var lines []string
- for _, y := range years {
- lines = append(lines, gemtext.Link(gemYearAddress(y.year), fmt.Sprintf("%d (%d)", y.year, len(y.posts))))
- lines = append(lines, g.monthLines(y, lang)...)
- }
- return strings.Join(lines, "\n")
-}
-
-// monthLines returns the link lines of the months of a year.
-func (g *gemini) monthLines(y archiveYear, lang string) []string {
- lines := make([]string, len(y.months))
- for i, m := range y.months {
- lines[i] = gemtext.Link(gemMonthAddress(m.year, m.month), fmt.Sprintf("%s (%d)", monthYear(m.year, m.month, g.langs[lang]), len(m.posts)))
- }
- return lines
-}
-
-// newsDocument describes a page of the news for the navigation.
-func (g *gemini) newsDocument(lang, path, title, source string) document {
- return document{lang: lang, nav: "news", path: path, title: title, source: source}
-}
-
-// renderPosts converts every post.
-func (g *gemini) renderPosts() error {
- for i, p := range g.posts {
- if err := g.renderPost(i, p); err != nil {
- return err
- }
- }
- return nil
-}
-
-// renderPost converts a post: the title, a line with the date, the author, the
-// categories and the reading time, the summary when it was written, the text,
-// the link to reply on Mastodon, and the links to the older and the newer post
-// and to all the news.
-func (g *gemini) renderPost(i int, p content.Post) error {
- l := g.langs[p.Language]
- d := g.newsDocument(p.Language, p.Path, p.Title, p.Source)
- ctx := g.documentContext(d)
- html, err := g.markdown(p.Source, p.Body, ctx)
- if err != nil {
- return err
- }
- body, err := g.convert(p.Source, html, p.Path, p.Language)
- if err != nil {
- return err
- }
-
- parts := []string{longDate(p.Date, l)}
- if p.Author != "" {
- parts = append(parts, p.Author)
- }
- if len(p.Categories) > 0 {
- names := make([]string, len(p.Categories))
- for i, c := range p.Categories {
- names[i] = c.Name
- }
- parts = append(parts, strings.Join(names, ", "))
- }
- if reading := readingText(p.ReadingMinutes(), l); reading != "" {
- parts = append(parts, reading)
- }
- meta := []string{gemtext.Text(strings.Join(parts, " · "))}
- for _, c := range p.Categories {
- meta = append(meta, gemtext.Link(gemCategoryAddress(c.Slug), c.Name))
- }
-
- summary := ""
- if p.HasDescription {
- summary = gemtext.Text(p.Description)
- }
- 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)
- }
- mastodon = gemtext.Link(p.Mastodon, label)
- }
- out := compose(heading(p.Title), strings.Join(meta, "\n"), summary, withoutTitle(p.Title, body), mastodon, g.postNavigation(i, l.Code), g.navigation(d))
- return g.publish(gemFile(gemPostAddress(p)), p.Source, out)
-}
-
-// postNavigation returns the links to the newer and the older post and to all
-// the news. A link whose label the language lacks is left out.
-func (g *gemini) postNavigation(i int, lang string) string {
- l := g.langs[lang]
- var lines []string
- if label := l.Strings["post_newer"]; label != "" && i > 0 {
- lines = append(lines, gemtext.Link(gemPostAddress(g.posts[i-1]), label+": "+g.posts[i-1].Title))
- }
- if label := l.Strings["post_older"]; label != "" && i+1 < len(g.posts) {
- lines = append(lines, gemtext.Link(gemPostAddress(g.posts[i+1]), label+": "+g.posts[i+1].Title))
- }
- if label := l.Strings["news_all"]; label != "" {
- lines = append(lines, gemtext.Link(gemNews, label))
- }
- return strings.Join(lines, "\n")
-}
-
-// renderCategories writes the page of every category.
-func (g *gemini) renderCategories() error {
- l := g.langs[g.newsLang]
- for _, c := range g.categories {
- address := gemCategoryAddress(c.Slug)
- d := g.newsDocument(g.newsLang, categoryPath(c.Slug), c.Name, fmt.Sprintf("the page of the category %q", c.Name))
- title := c.Name
- if h := l.Strings["category_h"]; h != "" {
- title = h + ": " + c.Name
- }
- text := compose(heading(title), newsLines(c.posts, true), g.navigation(d))
- if err := g.publish(gemFile(address), d.source, text); err != nil {
- return err
- }
- }
- return nil
-}
-
-// renderArchives writes the page of every year and every month that has posts.
-func (g *gemini) renderArchives() error {
- lang := g.newsLang
- l := g.langs[lang]
- page := func(address, htmlPath, name string, posts []content.Post, links []string, source string) error {
- title := name
- if h := l.Strings["archive_h"]; h != "" {
- title = h + ": " + name
- }
- d := g.newsDocument(lang, htmlPath, name, source)
- text := compose(heading(title), strings.Join(links, "\n"), newsLines(posts, true), g.navigation(d))
- return g.publish(gemFile(address), source, text)
- }
- for _, y := range groupArchive(g.posts) {
- year := fmt.Sprint(y.year)
- if err := page(gemYearAddress(y.year), g.yearPath(y.year), year, y.posts, g.monthLines(y, lang), "the archive of "+year); err != nil {
- return err
- }
- var up []string
- if text := l.Strings["archive_up"]; text != "" {
- up = []string{gemtext.Link(gemYearAddress(y.year), text+" "+year)}
- }
- for _, m := range y.months {
- name := monthYear(m.year, m.month, l)
- if err := page(gemMonthAddress(m.year, m.month), g.monthPath(m.year, m.month), name, m.posts, up, "the archive of "+name); err != nil {
- return err
- }
- }
- }
- return nil
-}
-
-// renderFeed writes the list of the latest posts, newest first, a date before
-// each title: the format that Gemini feed readers subscribe to.
-func (g *gemini) renderFeed() error {
- title := g.byKey[pageKey{"news", g.newsLang}].Title
- if !strings.HasPrefix(title, sitePrefix) {
- title = sitePrefix + title
- }
- posts := g.posts
- if len(posts) > feedLimit {
- posts = posts[:feedLimit]
- }
- text := compose(heading(title), newsLines(posts, false))
- return g.publish(gemFile(gemNews+"feed.gmi"), "the feed", text)
-}
diff --git a/internal/build/gemini_test.go b/internal/build/gemini_test.go
deleted file mode 100644
index b96dcc8..0000000
--- a/internal/build/gemini_test.go
+++ /dev/null
@@ -1,523 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package build
-
-import (
- "io/fs"
- "os"
- "path/filepath"
- "regexp"
- "sort"
- "strings"
- "testing"
-)
-
-// buildGem builds the Gemini output of the site made of files, with the options changed by tune.
-func buildGem(t *testing.T, files map[string]string, tune func(*GeminiOptions)) (string, error) {
- t.Helper()
- out := filepath.Join(t.TempDir(), "capsule")
- opts := GeminiOptions{SiteDir: writeFiles(t, files), OutDir: out, Version: "1.2.3", Now: fixedNow, Language: "it"}
- if tune != nil {
- tune(&opts)
- }
- _, err := BuildGemini(opts)
- return out, err
-}
-
-// gemSite is the base site with a services page that has a table and an image, a Spanish news page left out and
-// the news index of the English pages.
-func gemSite(extra map[string]string) map[string]string {
- files := withFiles(map[string]string{
- "lang/en.json": blogLangEn, "lang/it.json": blogLangIt,
- "content/en/services.md": page("services", "Services", "", "Write to **{{contact_shown}}**.\n\n
\n
Service
Kept
\n
Mail
30 days
\n
\n\n\n"),
- "content/en/news/index.md": page("news", "News", "Layout: bare\n", "# News\n\n{{news_list}}\n\n## Categories\n\n{{categories_list}}\n\n## Archive\n\n{{news_archive}}\n\n[Feed](/news/feed.xml)\n"),
- "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. Mail me at squid@kmalloc.org or visit [the site](https://kmalloc.org/).\n",
- })
- for k, v := range extra {
- if v == "" {
- delete(files, k)
- continue
- }
- files[k] = v
- }
- return files
-}
-
-// gemFiles returns every file of the output, as slash paths relative to it.
-func gemFiles(t *testing.T, out string) []string {
- t.Helper()
- var files []string
- err := filepath.WalkDir(out, func(path string, d fs.DirEntry, err error) error {
- if err != nil || d.IsDir() {
- return err
- }
- rel, _ := filepath.Rel(out, path)
- files = append(files, filepath.ToSlash(rel))
- return nil
- })
- if err != nil {
- t.Fatal(err)
- }
- sort.Strings(files)
- return files
-}
-
-// TestGeminiTree checks which files the capsule has, with Italian at the root.
-func TestGeminiTree(t *testing.T) {
- out, err := buildGem(t, gemSite(nil), nil)
- if err != nil {
- t.Fatalf("BuildGemini() error = %v", err)
- }
- have := map[string]bool{}
- for _, f := range gemFiles(t, out) {
- have[f] = true
- }
- for _, want := range []string{
- "index.gmi", "manifesto.gmi", "persone.gmi", "servizi.gmi", "cronologia-manifesto.gmi", "progetti.gmi",
- "en/index.gmi", "en/manifesto.gmi", "en/people.gmi", "en/services.gmi", "es/manifesto.gmi",
- "news/index.gmi", "news/feed.gmi", "news/2026/11/shop.gmi", "news/2026/11/status.gmi", "news/2026/09/gnu-linux-day-2026.gmi",
- "news/category/flug.gmi", "news/category/linux-day.gmi", "news/2026/index.gmi", "news/2026/11/index.gmi", "news/2026/09/index.gmi",
- ".meta", "logo.svg",
- } {
- if !have[want] {
- t.Errorf("the capsule has no %s", want)
- }
- }
- for f := range have {
- if strings.HasSuffix(f, ".html") || strings.HasPrefix(f, "it/") || strings.HasPrefix(f, "en/news/") || strings.HasPrefix(f, "es/news/") || strings.HasSuffix(f, "robots.txt") {
- t.Errorf("the capsule has %s, which it should not", f)
- }
- }
-}
-
-// TestGeminiRootLanguage checks the language at the root: the option, site.json, then the default language.
-func TestGeminiRootLanguage(t *testing.T) {
- plain, err := buildGem(t, gemSite(nil), func(o *GeminiOptions) { o.Language = "" })
- if err != nil {
- t.Fatal(err)
- }
- mustContain(t, "index.gmi", readOut(t, plain, "index.gmi"), "# kmalloc.org")
- if !exists(t, plain, "it/index.gmi") || exists(t, plain, "en/index.gmi") {
- t.Error("without a choice the default language is at the root and the others under their code")
- }
- files := gemSite(map[string]string{"site.json": strings.Replace(baseFiles()["site.json"], `"languages"`, `"gemini_language": "it", "languages"`, 1)})
- fromSite, err := buildGem(t, files, func(o *GeminiOptions) { o.Language = "" })
- if err != nil {
- t.Fatal(err)
- }
- if !exists(t, fromSite, "en/index.gmi") || exists(t, fromSite, "it/index.gmi") {
- t.Error("gemini_language in site.json does not put Italian at the root")
- }
- for name, tune := range map[string]func(*GeminiOptions){"xx": func(o *GeminiOptions) { o.Language = "xx" }, "es has no home": func(o *GeminiOptions) { o.Language = "es" }} {
- if _, err := buildGem(t, gemSite(nil), tune); err == nil {
- t.Errorf("language %s: no error", name)
- }
- }
-}
-
-// TestGeminiMeta checks the .meta file that sets the language of the documents.
-func TestGeminiMeta(t *testing.T) {
- out, err := buildGem(t, gemSite(nil), nil)
- if err != nil {
- t.Fatal(err)
- }
- want := "en/*:;lang=en\nen/**/*:;lang=en\nes/*:;lang=es\nes/**/*:;lang=es\nnews/*:;lang=en\nnews/**/*:;lang=en\n"
- if got := readOut(t, out, ".meta"); got != want {
- t.Errorf(".meta =\n%q\nwant\n%q", got, want)
- }
- plain, err := buildGem(t, gemSite(nil), func(o *GeminiOptions) { o.Language = "en" })
- if err != nil {
- t.Fatal(err)
- }
- want = "it/*:;lang=it\nit/**/*:;lang=it\nes/*:;lang=es\nes/**/*:;lang=es\n"
- if got := readOut(t, plain, ".meta"); got != want {
- t.Errorf(".meta with English at the root =\n%q\nwant\n%q (the news are in the language of the root: no lines for them)", got, want)
- }
- for _, f := range gemFiles(t, out) {
- if strings.HasSuffix(f, ".gmi") && strings.Contains(readOut(t, out, f), ".meta") {
- t.Errorf("%s mentions .meta", f)
- }
- }
-}
-
-// TestGeminiPages checks the headings, the layouts and the navigation of a page.
-func TestGeminiPages(t *testing.T) {
- out, err := buildGem(t, gemSite(nil), nil)
- if err != nil {
- t.Fatal(err)
- }
- services := readOut(t, out, "en/services.gmi")
- mustContain(t, "en/services.gmi", services, "# Services\n", "Write to squid (at) kmalloc.org.\n",
- "```\nService Kept\n------- -------\nMail 30 days\n```\n", "=> /logo.svg The mark of kmalloc\n")
- if strings.Contains(services, "<") || strings.Contains(services, "**") {
- t.Errorf("the page has markup left:\n%s", services)
- }
- mustContain(t, "en/services.gmi navigation", services,
- "=> /en/ kmalloc.org\n", "=> /en/manifesto.gmi Manifesto\n", "=> /en/people.gmi People\n", "=> /en/services.gmi Services\n", "=> /news/ News\n",
- "=> /servizi.gmi Italiano\n")
- manifesto := readOut(t, out, "es/manifesto.gmi")
- mustContain(t, "es/manifesto.gmi", manifesto, "# Manifiesto\n", "Version 1.0, 2026-11-12\n", "Traduccion de la version 1.0.\n", "=> /es/manifesto.gmi Manifiesto\n")
- home := readOut(t, out, "index.gmi")
- mustContain(t, "index.gmi", home, "=> /news/ Tutte le news\n", "=> /news/2026/11/shop.gmi 2026-11-14 A shop\n", "=> /en/ English\n")
- if strings.HasPrefix(home, "# ") && !strings.Contains(home, "kmalloc.org") {
- t.Errorf("home has no title:\n%s", home)
- }
-}
-
-// TestGeminiHomesLinkToTheNews checks that every home links to the one copy of the news.
-func TestGeminiHomesLinkToTheNews(t *testing.T) {
- out, err := buildGem(t, gemSite(nil), nil)
- if err != nil {
- t.Fatal(err)
- }
- for _, rel := range []string{"index.gmi", "en/index.gmi"} {
- mustContain(t, rel, readOut(t, out, rel), "=> /news/ ", "=> /news/2026/11/shop.gmi 2026-11-14 A shop\n")
- }
-}
-
-// TestGeminiNews checks a post, the index, a category, the archive and the feed.
-func TestGeminiNews(t *testing.T) {
- out, err := buildGem(t, blogGem(), nil)
- if err != nil {
- t.Fatal(err)
- }
- post := readOut(t, out, "news/2026/11/shop.gmi")
- mustContain(t, "post", post, "# A shop\n", "14 November 2026 · squid · FLUG · 1 min read\n", "About the shop.\n",
- "There is a shop. Mail me at squid@kmalloc.org or visit the site.\n", "=> https://kmalloc.org/ the site\n",
- "=> /news/category/flug.gmi FLUG\n", "=> https://social.kmalloc.org/@squid/115 Reply on Mastodon\n",
- "=> /news/2026/11/status.gmi Older: Status page\n", "=> /news/ All news\n", "=> /en/manifesto.gmi Manifesto\n")
- if strings.Contains(post, "Newer:") {
- t.Error("the newest post has a link to a newer one")
- }
- gnu := readOut(t, out, "news/2026/09/gnu-linux-day-2026.gmi")
- mustContain(t, "older post", gnu, "=> /en/people.gmi people\n", "=> /news/2026/11/status.gmi Newer: Status page\n")
- index := readOut(t, out, "news/index.gmi")
- mustContain(t, "index", index, "# News\n",
- "=> /news/2026/11/shop.gmi 2026-11-14 A shop\nAbout the shop.\n", "=> /news/2026/11/status.gmi 2026-11-12 Status page\n",
- "=> /news/category/flug.gmi FLUG (2)\n", "=> /news/2026/ 2026 (3)\n", "=> /news/2026/11/ November 2026 (2)\n", "=> /news/feed.gmi Feed\n")
- category := readOut(t, out, "news/category/flug.gmi")
- mustContain(t, "category", category, "# Category: FLUG\n", "=> /news/2026/11/shop.gmi 2026-11-14 A shop\n", "=> /news/2026/09/gnu-linux-day-2026.gmi 2026-09-18 GNU/Linux Day 2026\n")
- month := readOut(t, out, "news/2026/11/index.gmi")
- mustContain(t, "month", month, "# Archive: November 2026\n", "=> /news/2026/ Archive of the year 2026\n", "A shop")
- if strings.Contains(month, "GNU/Linux") {
- t.Error("the archive of November lists a post of September")
- }
- year := readOut(t, out, "news/2026/index.gmi")
- mustContain(t, "year", year, "# Archive: 2026\n", "=> /news/2026/09/ September 2026 (1)\n", "=> /news/2026/11/ November 2026 (2)\n")
-}
-
-// blogGem is the site of the tests of the news pages.
-func blogGem() map[string]string { return gemSite(nil) }
-
-// TestGeminiFeed checks the feed: newest first, a date before each title.
-func TestGeminiFeed(t *testing.T) {
- out, err := buildGem(t, blogGem(), nil)
- if err != nil {
- t.Fatal(err)
- }
- feed := readOut(t, out, "news/feed.gmi")
- want := "=> /news/2026/11/shop.gmi 2026-11-14 A shop\n=> /news/2026/11/status.gmi 2026-11-12 Status page\n=> /news/2026/09/gnu-linux-day-2026.gmi 2026-09-18 GNU/Linux Day 2026\n"
- mustContain(t, "feed", feed, "# kmalloc.org: News\n", want)
- if first := strings.Index(feed, "A shop"); first > strings.Index(feed, "Status page") {
- t.Error("the feed is not newest first")
- }
-}
-
-// TestGeminiNeverHasBrokenLinksOrEmptyFiles walks the whole capsule: no empty file, and every
-// link that stays in the capsule leads to a file.
-func TestGeminiNeverHasBrokenLinksOrEmptyFiles(t *testing.T) {
- out, err := buildGem(t, blogGem(), nil)
- if err != nil {
- t.Fatal(err)
- }
- link := regexp.MustCompile(`(?m)^=> (\S+)`)
- for _, f := range gemFiles(t, out) {
- data, err := os.ReadFile(filepath.Join(out, filepath.FromSlash(f)))
- if err != nil {
- t.Fatal(err)
- }
- if len(strings.TrimSpace(string(data))) == 0 && f != ".meta" {
- t.Errorf("%s is empty", f)
- }
- if !strings.HasSuffix(f, ".gmi") {
- continue
- }
- for _, m := range link.FindAllStringSubmatch(string(data), -1) {
- target := m[1]
- if strings.Contains(target, ":") || !strings.HasPrefix(target, "/") {
- if !strings.Contains(target, ":") {
- t.Errorf("%s has the relative link %s", f, target)
- }
- continue
- }
- rel := strings.TrimPrefix(target, "/")
- if rel == "" || strings.HasSuffix(rel, "/") {
- rel += "index.gmi"
- }
- if !exists(t, out, rel) {
- t.Errorf("%s links to %s, which is not in the capsule", f, target)
- }
- }
- }
-}
-
-// TestGeminiLinksMustResolve checks that a link to nothing stops the build and names the page and the address.
-func TestGeminiLinksMustResolve(t *testing.T) {
- for name, extra := range map[string]map[string]string{
- "page": {"content/en/people.md": page("people", "People", "", "See [nowhere](/nowhere.html).\n")},
- "post": {"news/broken.md": "Title: Broken\nDate: 2026-11-01T12:00:00+0100\n-\nSee [nowhere](/nowhere.html).\n"},
- "unsafe scheme": {"content/en/people.md": page("people", "People", "", "[x](javascript:alert(1))\n")},
- } {
- t.Run(name, func(t *testing.T) {
- _, err := buildGem(t, gemSite(extra), nil)
- if err == nil || !strings.Contains(err.Error(), "nowhere.html") && !strings.Contains(err.Error(), "javascript") {
- t.Errorf("error = %v, want one that names the address", err)
- }
- })
- }
-}
-
-// TestGeminiOnlyReferencedAssets checks that an asset is copied when a page uses it and not otherwise.
-func TestGeminiOnlyReferencedAssets(t *testing.T) {
- out, err := buildGem(t, gemSite(map[string]string{"content/en/services.md": page("services", "Services", "", "No image.\n")}), nil)
- if err != nil {
- t.Fatal(err)
- }
- if exists(t, out, "logo.svg") {
- t.Error("an asset no page uses is copied")
- }
-}
-
-// TestGeminiDraftsAndFuture checks that hidden posts stay out of the capsule, as in the site.
-func TestGeminiDraftsAndFuture(t *testing.T) {
- out, err := buildGem(t, gemSite(postNews()), nil)
- if err != nil {
- t.Fatal(err)
- }
- for _, f := range gemFiles(t, out) {
- if strings.Contains(f, "a-draft") || strings.Contains(f, "in-future") || strings.Contains(f, "secret") {
- t.Errorf("the capsule has %s, but the post is hidden", f)
- }
- }
- with, err := buildGem(t, gemSite(postNews()), func(o *GeminiOptions) { o.Drafts = true })
- if err != nil {
- t.Fatal(err)
- }
- if !exists(t, with, "news/2026/11/a-draft.gmi") {
- t.Error("a build with drafts lacks the draft")
- }
-}
-
-// TestGeminiBlockMustStandAlone checks the rule of the generated blocks.
-func TestGeminiBlockMustStandAlone(t *testing.T) {
- _, err := buildGem(t, gemSite(map[string]string{"content/en/people.md": page("people", "People", "", "Text {{news_list}} text.\n")}), nil)
- if err == nil || !strings.Contains(err.Error(), "news_list") {
- t.Errorf("error = %v, want one about {{news_list}}", err)
- }
-}
-
-// TestGeminiWebPaths checks that a path the website serves by other means can stay a link to the website.
-func TestGeminiWebPaths(t *testing.T) {
- files := gemSite(map[string]string{
- "site.json": strings.Replace(baseFiles()["site.json"], `"languages"`, `"gemini_web_paths": "/~, /pastes/", "languages"`, 1),
- "content/en/people.md": page("people", "People", "", "Pages of the [people](/~squid/) and the [pastes](/pastes/x).\n"),
- })
- out, err := buildGem(t, files, nil)
- if err != nil {
- t.Fatalf("BuildGemini() error = %v", err)
- }
- mustContain(t, "en/people.gmi", readOut(t, out, "en/people.gmi"),
- "=> https://kmalloc.org/~squid/ people\n", "=> https://kmalloc.org/pastes/x pastes\n")
- if _, err := buildGem(t, gemSite(map[string]string{"content/en/people.md": page("people", "People", "", "[x](/~squid/)\n")}), nil); err == nil {
- t.Error("a path of the website is a link when the site did not say so")
- }
-}
-
-// TestGeminiHeadings checks that a page has one first level heading and that code is left alone.
-func TestGeminiHeadings(t *testing.T) {
- out, err := buildGem(t, gemSite(map[string]string{
- "content/en/people.md": page("people", "People", "", "# People\n\n# Other\n\n```\n# a comment in code\n```\n"),
- }), nil)
- if err != nil {
- t.Fatal(err)
- }
- got := readOut(t, out, "en/people.gmi")
- mustContain(t, "en/people.gmi", got, "# People\n\n## Other\n\n```\n# a comment in code\n```\n")
- if strings.Count(got, "# People") != 1 {
- t.Errorf("the title is repeated:\n%s", got)
- }
- home := readOut(t, out, "en/index.gmi")
- mustContain(t, "en/index.gmi", home, "# kmalloc.org\n\n## Technology.\n")
-}
-
-// TestGeminiKeepsLinksToOtherProtocols checks the protocols that leave the capsule as they are.
-func TestGeminiKeepsLinksToOtherProtocols(t *testing.T) {
- out, err := buildGem(t, gemSite(map[string]string{"content/en/people.md": page("people", "People", "",
- "[Mail](mailto:squid@kmalloc.org) [Pay](bitcoin:bc1qxyz) [Chat](xmpp:squid@kmalloc.org) [Capsule](gemini://example.org/)\n")}), nil)
- if err != nil {
- t.Fatal(err)
- }
- mustContain(t, "en/people.gmi", readOut(t, out, "en/people.gmi"),
- "=> mailto:squid@kmalloc.org Mail\n", "=> bitcoin:bc1qxyz Pay\n", "=> xmpp:squid@kmalloc.org Chat\n", "=> gemini://example.org/ Capsule\n")
-}
-
-// TestGeminiTitleThatSaysTheHeading checks that a heading the title already says is not repeated, as in
-// the real site where the page title is "kmalloc.org: Services" and the text starts with "# Services".
-func TestGeminiTitleThatSaysTheHeading(t *testing.T) {
- out, err := buildGem(t, gemSite(map[string]string{
- "content/en/people.md": page("people", "kmalloc.org: People", "", "# People\n\nText.\n"),
- }), nil)
- if err != nil {
- t.Fatal(err)
- }
- got := readOut(t, out, "en/people.gmi")
- if !strings.HasPrefix(got, "# kmalloc.org: People\n\nText.\n") {
- t.Errorf("en/people.gmi starts with\n%q", got)
- }
-}
-
-// TestGeminiFeedTitleIsNotPrefixedTwice checks the feed title when the news page title has the prefix already.
-func TestGeminiFeedTitleIsNotPrefixedTwice(t *testing.T) {
- out, err := buildGem(t, gemSite(map[string]string{
- "content/en/news/index.md": page("news", "kmalloc.org: News", "", "{{news_list}}\n"),
- }), nil)
- if err != nil {
- t.Fatal(err)
- }
- if got := readOut(t, out, "news/feed.gmi"); !strings.HasPrefix(got, "# kmalloc.org: News\n") {
- t.Errorf("news/feed.gmi starts with %q", got)
- }
-}
-
-// TestGeminiTranslationNote checks that the note of a machine translated language reads as one sentence.
-func TestGeminiTranslationNote(t *testing.T) {
- files := gemSite(map[string]string{
- "lang/es.json": strings.Replace(baseFiles()["lang/es.json"], `"translation_note": "Traduccion automatica."`, `"translation_note": "Traduccion automatica, avisa si ves un error:"`, 1),
- })
- out, err := buildGem(t, files, nil)
- if err != nil {
- t.Fatal(err)
- }
- mustContain(t, "es/manifesto.gmi", readOut(t, out, "es/manifesto.gmi"),
- "Traduccion automatica, avisa si ves un error: avisar.\n=> https://git.kmalloc.org/squid/kmalloc.org/issues avisar\n")
-}
-
-// TestGeminiMetaForPostsInAnotherLanguage checks that a post with its own Language has a line of its own in
-// .meta, with the real path of its file and before the lines of the folders: the server uses the first line that
-// matches a file, and the line of the news folder would hide a line that comes after it.
-func TestGeminiMetaForPostsInAnotherLanguage(t *testing.T) {
- files := gemSite(map[string]string{
- "news/ciao.md": "Title: Ciao\nDate: 2026-11-05T09:00:00+0100\nLanguage: it\n-\nUn testo.\n",
- "news/hola.md": "Title: Hola\nDate: 2026-11-04T09:00:00+0100\nLanguage: es\n-\nUn texto.\n",
- "news/same.md": "Title: Same\nDate: 2026-11-03T09:00:00+0100\nLanguage: en\n-\nText.\n",
- })
- out, err := buildGem(t, files, nil)
- if err != nil {
- t.Fatalf("BuildGemini() error = %v", err)
- }
- want := "news/2026/11/ciao.gmi:;lang=it\nnews/2026/11/hola.gmi:;lang=es\n" +
- "en/*:;lang=en\nen/**/*:;lang=en\nes/*:;lang=es\nes/**/*:;lang=es\nnews/*:;lang=en\nnews/**/*:;lang=en\n"
- if got := readOut(t, out, ".meta"); got != want {
- t.Errorf(".meta =\n%q\nwant\n%q", got, want)
- }
- for _, rel := range []string{"news/2026/11/ciao.gmi", "news/2026/11/hola.gmi"} {
- if !exists(t, out, rel) {
- t.Errorf("the .meta names %s, which is not in the capsule", rel)
- }
- }
- // With English at the root and the news in English too, only the posts in other languages have a line.
- plain, err := buildGem(t, files, func(o *GeminiOptions) { o.Language = "en" })
- if err != nil {
- t.Fatalf("BuildGemini() error = %v", err)
- }
- want = "news/2026/11/ciao.gmi:;lang=it\nnews/2026/11/hola.gmi:;lang=es\n" +
- "it/*:;lang=it\nit/**/*:;lang=it\nes/*:;lang=es\nes/**/*:;lang=es\n"
- if got := readOut(t, plain, ".meta"); got != want {
- t.Errorf(".meta with English at the root =\n%q\nwant\n%q", got, want)
- }
-}
-
-// TestGeminiNoNewsAtAll checks that a site without posts says so once, in the news list, and that the empty
-// lists leave their headings out.
-func TestGeminiNoNewsAtAll(t *testing.T) {
- index := "# News\n\n{{news_list}}\n\n## Categories\n\n{{categories_list}}\n\n## Archive\n\n{{news_archive}}\n"
- out, err := buildGem(t, gemSite(map[string]string{
- "content/en/news/index.md": page("news", "News", "Layout: bare\n", index),
- "news/shop.md": "", "news/gnu-linux-day-2026.md": "", "news/status.md": "",
- }), nil)
- if err != nil {
- t.Fatalf("BuildGemini() error = %v", err)
- }
- got := readOut(t, out, "news/index.gmi")
- 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", "## Archive"} {
- if strings.Contains(got, heading) {
- t.Errorf("the index keeps the heading %q of an empty list:\n%s", heading, got)
- }
- }
- mustContain(t, "news/index.gmi", got, "# News\n")
- mustContain(t, "news/feed.gmi", readOut(t, out, "news/feed.gmi"), "# kmalloc.org: News\n")
- home := readOut(t, out, "index.gmi")
- if strings.Contains(home, "Tutte le news") {
- t.Errorf("the home links to the news list of a site with no news:\n%s", home)
- }
- mustContain(t, "index.gmi", home, "# kmalloc.org\n")
-}
-
-// TestGeminiOnlyOnePost checks that a single post has no link to a newer or an older one, but has the one to all the news.
-func TestGeminiOnlyOnePost(t *testing.T) {
- out, err := buildGem(t, gemSite(map[string]string{"news/gnu-linux-day-2026.md": "", "news/status.md": ""}), nil)
- if err != nil {
- t.Fatalf("BuildGemini() error = %v", err)
- }
- post := readOut(t, out, "news/2026/11/shop.gmi")
- for _, absent := range []string{"Older", "Newer"} {
- if strings.Contains(post, absent) {
- t.Errorf("the only post has %q:\n%s", absent, post)
- }
- }
- mustContain(t, "the post", post, "=> /news/ All news\n")
-}
-
-// TestGeminiUnusualTitle checks that a title with quotes, an ampersand, a tag and non Latin letters is written as it is.
-func TestGeminiUnusualTitle(t *testing.T) {
- title := `Say "hi" & go ünï 日本語`
- out, err := buildGem(t, gemSite(map[string]string{
- "news/odd.md": "Title: " + title + "\nDate: 2026-11-15T09:00:00+0100\nCategories: Odd\n-\nText.\n",
- }), nil)
- if err != nil {
- t.Fatalf("BuildGemini() error = %v", err)
- }
- mustContain(t, "the post", readOut(t, out, "news/2026/11/odd.gmi"), "# "+title+"\n")
- mustContain(t, "news/feed.gmi", readOut(t, out, "news/feed.gmi"), "=> /news/2026/11/odd.gmi 2026-11-15 "+title+"\n")
- mustContain(t, "news/index.gmi", readOut(t, out, "news/index.gmi"), "=> /news/2026/11/odd.gmi 2026-11-15 "+title+"\n")
- mustContain(t, "the post below", readOut(t, out, "news/2026/11/shop.gmi"), "Newer: "+title)
- for _, rel := range []string{"news/2026/11/odd.gmi", "news/index.gmi", "news/category/odd.gmi"} {
- if strings.Contains(readOut(t, out, rel), "<") || strings.Contains(readOut(t, out, rel), "&") {
- t.Errorf("%s has an HTML escape in the title", rel)
- }
- }
-}
-
-// TestGeminiLeavesTheLogoOut checks that the logo of the home page leaves no link line and no copied file.
-func TestGeminiLeavesTheLogoOut(t *testing.T) {
- out, err := buildGem(t, gemSite(map[string]string{
- "content/en/services.md": page("services", "Services", "", "No image.\n"),
- "content/en/index.md": page("home", "kmalloc.org", "Layout: bare\n", "\n\n
Technology.
\n\n{{latest_news}}\n"),
- }), nil)
- if err != nil {
- t.Fatalf("BuildGemini() error = %v", err)
- }
- home := readOut(t, out, "en/index.gmi")
- if strings.Contains(home, "logo.svg") {
- t.Errorf("the home links to the logo:\n%s", home)
- }
- if !strings.HasPrefix(home, "# kmalloc.org\n\n## Technology.\n") {
- t.Errorf("the home starts with %q", home)
- }
- if exists(t, out, "logo.svg") {
- t.Error("the logo is copied, and nothing points to it")
- }
-}
diff --git a/internal/build/news.go b/internal/build/news.go
index eafa38c..a9f6e89 100644
--- a/internal/build/news.go
+++ b/internal/build/news.go
@@ -24,13 +24,12 @@ type renderedPost struct {
}
// newsItem returns the
of a post for a list: the date, the title as a
-// 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.
+// 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.
func newsItem(p content.Post, lang string, withDescription bool) string {
mark := ""
- if p.Language != "" && p.Language != lang {
- mark = fmt.Sprintf(` hreflang="%s" lang="%s"`, p.Language, p.Language)
+ if lang != "en" {
+ mark = ` hreflang="en" lang="en"`
}
day := p.Date.Format(dateOnly)
item := fmt.Sprintf(`
"
}
-// 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(``, 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("
")
- 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
, or an empty string
// when there are no posts.
func newsList(posts []content.Post, lang string) string {
diff --git a/internal/build/news_test.go b/internal/build/news_test.go
index 3960f21..39bddfe 100644
--- a/internal/build/news_test.go
+++ b/internal/build/news_test.go
@@ -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,
- Language: "en", Date: date, Categories: categories, Source: "news/" + slug + ".md",
+ Date: date, Categories: categories, Source: "news/" + slug + ".md",
}
}
diff --git a/internal/build/output.go b/internal/build/output.go
deleted file mode 100644
index 0dbe133..0000000
--- a/internal/build/output.go
+++ /dev/null
@@ -1,105 +0,0 @@
-// 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
-}
diff --git a/internal/build/output_gemini_test.go b/internal/build/output_gemini_test.go
deleted file mode 100644
index c69a639..0000000
--- a/internal/build/output_gemini_test.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// 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")
- }
-}
diff --git a/internal/build/output_test.go b/internal/build/output_test.go
deleted file mode 100644
index 8fd0efa..0000000
--- a/internal/build/output_test.go
+++ /dev/null
@@ -1,162 +0,0 @@
-// 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")
- }
-}
diff --git a/internal/build/pages.go b/internal/build/pages.go
index cc6ffa6..31849d3 100644
--- a/internal/build/pages.go
+++ b/internal/build/pages.go
@@ -5,7 +5,6 @@ package build
import (
"fmt"
"regexp"
- "strconv"
"strings"
"git.kmalloc.org/squid/motorino/internal/content"
@@ -23,51 +22,20 @@ func (b *builder) renderPages() error {
return nil
}
-// 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.
+// renderPage converts the body of a page to HTML, expands the generated lists,
+// puts it in its layout and in the shared frame.
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: pagePath(p.Path, n), title: p.Title,
+ lang: p.Lang, id: p.ID, lead: "back", path: p.Path, title: p.Title,
description: p.Description, switches: p.Switch, source: p.Source,
}
- d.nav = p.ID
+ if contains(menuPages, p.ID) {
+ 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)
}
@@ -133,13 +101,11 @@ func (b *builder) markdown(name, source, lang string, ctx map[string]string) (st
// codeElement matches a code element, where a placeholder is shown as written.
var codeElement = regexp.MustCompile(`(?s)]*>.*?`)
-// replaceBlocks replaces each paragraph that holds only a block placeholder by
-// 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) {
+// expandBlocks replaces each paragraph that holds only a block placeholder by
+// the generated HTML. 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) {
outside := codeElement.ReplaceAllString(html, "")
for _, block := range blockNames {
token := "{{" + block + "}}"
@@ -152,50 +118,15 @@ func replaceBlocks(name, html string, replace func(block string) (string, error)
if !strings.Contains(html, marker) {
continue
}
- generated, err := replace(block)
+ generated, err := b.block(block, lang, ctx)
if err != nil {
return "", err
}
- if generated == "" && headedBlocks[block] {
- html = removeWithHeading(html, marker)
- continue
- }
html = strings.ReplaceAll(html, marker, generated)
}
return html, nil
}
-// expandBlocks replaces the block placeholders of a page by the generated HTML.
-func (b *builder) expandBlocks(name, html, lang string, ctx map[string]string) (string, error) {
- 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(`$`)
-
-// 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]], "= 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 {
@@ -204,11 +135,6 @@ func (b *builder) block(name, lang string, ctx map[string]string) (string, error
return list, nil
}
return "
\n" + ctx["news_empty"] + "\n
", 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
@@ -232,13 +158,13 @@ func (b *builder) renderPosts() error {
if err != nil {
return err
}
- for i, p := range b.posts {
+ for _, p := range b.posts {
d := document{
- lang: p.Language, nav: "news", lead: "news", path: p.Path, title: p.Title,
+ lang: b.defaultLang, 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, p.Language, ctx)
+ html, _, err := b.markdown(p.Source, p.Body, b.defaultLang, ctx)
if err != nil {
return err
}
@@ -247,9 +173,6 @@ 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
@@ -269,8 +192,12 @@ func byline(p content.Post) string {
if p.Author != "" {
out.WriteString(" · " + render.Escape(p.Author))
}
- if links := categoryLinks(p); links != "" {
- out.WriteString(" · " + links)
+ if len(p.Categories) > 0 {
+ links := make([]string, len(p.Categories))
+ for i, c := range p.Categories {
+ links[i] = fmt.Sprintf(`%s`, categoryPath(c.Slug), render.Escape(c.Name))
+ }
+ out.WriteString(" · " + strings.Join(links, ", "))
}
return out.String()
}
@@ -286,17 +213,13 @@ func (b *builder) renderCategories() error {
}
for _, c := range b.categories {
d := document{
- 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,
+ 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,
source: fmt.Sprintf("the page of the category %q", c.Name),
}
ctx := b.documentContext(d)
ctx["category_name"] = render.Escape(c.Name)
- panels, err := b.newsPanels(c.posts, b.newsLang)
- if err != nil {
- return err
- }
- ctx["category_posts"] = panels
+ ctx["category_posts"] = newsList(c.posts, b.defaultLang)
body, err := render.Substitute("templates/category.html", tmpl, ctx)
if err != nil {
return err
@@ -310,6 +233,17 @@ func (b *builder) renderCategories() error {
// renderFeed writes the feed next to the news page.
func (b *builder) renderFeed() error {
- 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)
+ 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)
+}
+
+// contains reports whether list has s.
+func contains(list []string, s string) bool {
+ for _, item := range list {
+ if item == s {
+ return true
+ }
+ }
+ return false
}
diff --git a/internal/build/post.go b/internal/build/post.go
deleted file mode 100644
index 6164108..0000000
--- a/internal/build/post.go
+++ /dev/null
@@ -1,113 +0,0 @@
-// 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(`%s`, 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"] = `
` + render.Escape(p.Description) + "
"
- }
-
- parts := []string{fmt.Sprintf(``, 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"] = `
` + strings.Join(parts, " · ") + "
"
-
- 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(`
`, render.EscapeAttr(p.Mastodon), render.Escape(label))
- }
-
- ctx["post_nav"] = b.postNav(i, l)
-
- ctx["og_type"] = "article"
- meta := []string{fmt.Sprintf(``, p.Date.Format(time.RFC3339))}
- for _, c := range p.Categories {
- meta = append(meta, fmt.Sprintf(``, 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(`%s`, p.Language, title)
- }
- return fmt.Sprintf(`
\n", render.EscapeAttr(label), strings.Join(items, "\n"))
-}
diff --git a/internal/content/new.go b/internal/content/new.go
deleted file mode 100644
index a293db0..0000000
--- a/internal/content/new.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// 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
-}
diff --git a/internal/content/new_test.go b/internal/content/new_test.go
deleted file mode 100644
index 7309e48..0000000
--- a/internal/content/new_test.go
+++ /dev/null
@@ -1,78 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package content
-
-import (
- "os"
- "path/filepath"
- "strings"
- "testing"
- "time"
-)
-
-// newsNow is the moment the new post tests run at.
-var newsNow = time.Date(2026, 11, 16, 10, 45, 12, 0, time.FixedZone("CET", 3600))
-
-// TestNewPostWritesADraftThatLoads checks the file, its name and its header.
-func TestNewPostWritesADraftThatLoads(t *testing.T) {
- dir := t.TempDir()
- rel, err := NewPost(dir, "Il manifesto è cambiato", "squid", newsNow)
- if err != nil {
- t.Fatalf("NewPost() error = %v", err)
- }
- if rel != "news/il-manifesto-e-cambiato.md" {
- t.Errorf("NewPost() = %q, want news/il-manifesto-e-cambiato.md", rel)
- }
- data, err := os.ReadFile(filepath.Join(dir, filepath.FromSlash(rel)))
- if err != nil {
- t.Fatal(err)
- }
- for _, want := range []string{"Title: Il manifesto è cambiato\n", "Author: squid\n", "Date: 2026-11-16T10:45:12+0100\n", "Categories: News\n", "Draft: true\n", "\n-\n"} {
- if !strings.Contains(string(data), want) {
- t.Errorf("the file does not contain %q\n%s", want, data)
- }
- }
- posts, err := LoadPosts(dir)
- if err != nil || len(posts) != 1 {
- t.Fatalf("LoadPosts() = %v, %v", posts, err)
- }
- if p := posts[0]; !p.Draft || p.Title != "Il manifesto è cambiato" || p.Author != "squid" || p.Visible(newsNow.Add(time.Hour)) {
- t.Errorf("the new post is %+v, want a hidden draft with the title and the author", p)
- }
-}
-
-// TestNewPostWithoutAuthor checks that no author line is written without one.
-func TestNewPostWithoutAuthor(t *testing.T) {
- dir := t.TempDir()
- rel, err := NewPost(dir, "No author", "", newsNow)
- if err != nil {
- t.Fatal(err)
- }
- data, _ := os.ReadFile(filepath.Join(dir, filepath.FromSlash(rel)))
- if strings.Contains(string(data), "Author:") {
- t.Errorf("an Author line without an author:\n%s", data)
- }
-}
-
-// TestNewPostRefuses checks the titles and the files it will not write over.
-func TestNewPostRefuses(t *testing.T) {
- dir := t.TempDir()
- if _, err := NewPost(dir, "Twice", "", newsNow); err != nil {
- t.Fatal(err)
- }
- tests := []struct{ name, title, want string }{
- {"existing file", "Twice", "already exists"},
- {"empty title", " ", "title"},
- {"no letters", "!!!", "no letters"},
- {"line break", "One\nTwo", "title"},
- {"em dash", "One — two", "dash"},
- }
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- rel, err := NewPost(dir, tt.title, "", newsNow)
- if err == nil || !strings.Contains(err.Error(), tt.want) {
- t.Errorf("NewPost(%q) = %q, %v, want an error with %q", tt.title, rel, err, tt.want)
- }
- })
- }
-}
diff --git a/internal/content/posts.go b/internal/content/posts.go
index b28b9c8..ae5f103 100644
--- a/internal/content/posts.go
+++ b/internal/content/posts.go
@@ -4,7 +4,6 @@ package content
import (
"fmt"
- "net/url"
"os"
"path/filepath"
"regexp"
@@ -29,54 +28,18 @@ type Post struct {
Date time.Time
// Categories are the categories of the post, in the order written.
Categories []Category
- // HasDescription is true when the header has a Description; without one,
- // Description is the first sentence of the body and a page should not show
- // it as a summary, because the text starts with it.
- HasDescription bool
- // Mastodon is the address of the post on Mastodon, where a reader can reply;
- // empty when the header has none.
- Mastodon string
- // Draft is true for a post that is not to be published yet.
- Draft bool
- // Language is the language the post is written in, from the Language key;
- // empty when the header has none, and the builder then uses the language of
- // the news.
- Language string
- // Words is the number of words of the body.
- Words int
// Source is the file the post was read from, relative to the site.
Source string
// Body is the Markdown after the header.
Body string
}
-// wordsPerMinute is the reading speed the reading time is worked out with.
-const wordsPerMinute = 200
-
-// ReadingMinutes returns how many minutes the post takes to read, at least 1.
-func (p Post) ReadingMinutes() int {
- minutes := (p.Words + wordsPerMinute - 1) / wordsPerMinute
- if minutes < 1 {
- return 1
- }
- return minutes
-}
-
-// Visible reports whether the post is published at the moment now: it is not a
-// draft and its date has come.
-func (p Post) Visible(now time.Time) bool {
- return !p.Draft && !p.Date.After(now)
-}
-
// postKeys are the keys a news header may have.
-var postKeys = []string{"Title", "Author", "Date", "Categories", "Description", "Mastodon", "Draft", "Language"}
+var postKeys = []string{"Title", "Author", "Date", "Categories", "Description"}
// dateLayouts are the accepted spellings of Date, ISO 8601 with an offset.
var dateLayouts = []string{"2006-01-02T15:04:05-0700", "2006-01-02T15:04:05Z07:00"}
-// LanguageCode is the shape of a language code: "en", "pt-BR".
-var LanguageCode = regexp.MustCompile(`^[a-z]{2,3}(-[A-Za-z0-9]+)?$`)
-
// slugName matches a file name made of lowercase words joined by hyphens.
var slugName = regexp.MustCompile(`^[a-z0-9]+(?:-[a-z0-9]+)*$`)
@@ -150,55 +113,16 @@ func loadPost(file string) (Post, error) {
if err != nil {
return Post{}, err
}
- mastodon, err := parseMastodon(source, h.Get("Mastodon"))
- if err != nil {
- return Post{}, err
- }
- draft, err := parseDraft(source, h.Get("Draft"))
- if err != nil {
- return Post{}, err
- }
- language := h.Get("Language")
- if language != "" && !LanguageCode.MatchString(language) {
- return Post{}, fmt.Errorf("%s: Language %q is not a language code like \"en\" or \"pt-BR\"", source, language)
- }
description := h.Get("Description")
- hasDescription := description != ""
- if !hasDescription {
+ if description == "" {
description = firstSentence(body)
}
return Post{
Slug: slug, Path: PostPath(date, slug), Title: h.Get("Title"), Author: h.Get("Author"),
- Description: description, HasDescription: hasDescription, Mastodon: mastodon, Draft: draft, Language: language,
- Words: len(strings.Fields(body)), Date: date, Categories: categories, Source: source, Body: body,
+ Description: description, Date: date, Categories: categories, Source: source, Body: body,
}, nil
}
-// parseMastodon accepts an empty value or an https address with a host and no
-// spaces, because the address becomes the target of a link.
-func parseMastodon(source, value string) (string, error) {
- if value == "" {
- return "", nil
- }
- u, err := url.Parse(value)
- if err != nil || u.Scheme != "https" || u.Host == "" || strings.ContainsAny(value, " \t\"'<>") {
- return "", fmt.Errorf("%s: Mastodon %q is not an https address, such as https://social.kmalloc.org/@squid/115000000000000000", source, value)
- }
- return value, nil
-}
-
-// parseDraft reads the Draft key: true or yes make a draft; false, no or no key
-// do not.
-func parseDraft(source, value string) (bool, error) {
- switch strings.ToLower(value) {
- case "", "false", "no":
- return false, nil
- case "true", "yes":
- return true, nil
- }
- return false, fmt.Errorf("%s: Draft %q must be true or false", source, value)
-}
-
// parseDate reads Date in any of the accepted layouts.
func parseDate(source, value string) (time.Time, error) {
for _, layout := range dateLayouts {
diff --git a/internal/content/posts_test.go b/internal/content/posts_test.go
index 9e60ab9..c3dfda2 100644
--- a/internal/content/posts_test.go
+++ b/internal/content/posts_test.go
@@ -190,108 +190,3 @@ func TestLoadPostsNoNewsFolder(t *testing.T) {
t.Errorf("LoadPosts() = %v, %v, want no posts and no error", posts, err)
}
}
-
-// postFile returns a news file with the given extra header lines.
-func postFile(extra string) string {
- return "Title: A post\nDate: 2026-11-14T12:00:00+0100\n" + extra + "-\nOne two three four five.\n"
-}
-
-// loadOne loads a single news file and returns its post.
-func loadOne(t *testing.T, file string) (Post, error) {
- t.Helper()
- posts, err := LoadPosts(writeFiles(t, map[string]string{"news/a-post.md": file}))
- if err != nil {
- return Post{}, err
- }
- return posts[0], nil
-}
-
-// TestPostMastodon checks the optional reply address and its validation.
-func TestPostMastodon(t *testing.T) {
- p, err := loadOne(t, postFile("Mastodon: https://social.kmalloc.org/@squid/115000000000000000\n"))
- if err != nil || p.Mastodon != "https://social.kmalloc.org/@squid/115000000000000000" {
- t.Fatalf("Mastodon = %q, err = %v", p.Mastodon, err)
- }
- if p, _ = loadOne(t, postFile("")); p.Mastodon != "" {
- t.Errorf("a post without the key has Mastodon %q", p.Mastodon)
- }
- for _, bad := range []string{"http://social.kmalloc.org/@squid/1", "not an address", "https://", "https://a b/c", "javascript:alert(1)"} {
- if _, err := loadOne(t, postFile("Mastodon: "+bad+"\n")); err == nil || !strings.Contains(err.Error(), "Mastodon") {
- t.Errorf("Mastodon %q: error = %v, want one about Mastodon", bad, err)
- }
- }
-}
-
-// TestPostDraft checks the Draft key.
-func TestPostDraft(t *testing.T) {
- for value, want := range map[string]bool{"true": true, "True": true, "yes": true, "false": false, "no": false} {
- p, err := loadOne(t, postFile("Draft: "+value+"\n"))
- if err != nil || p.Draft != want {
- t.Errorf("Draft %q: got %v, err %v, want %v", value, p.Draft, err, want)
- }
- }
- if p, _ := loadOne(t, postFile("")); p.Draft {
- t.Error("a post without Draft must not be a draft")
- }
- if _, err := loadOne(t, postFile("Draft: maybe\n")); err == nil || !strings.Contains(err.Error(), "Draft") {
- t.Errorf("Draft maybe: error = %v, want one about Draft", err)
- }
-}
-
-// TestPostVisible checks that drafts and future dates stay hidden.
-func TestPostVisible(t *testing.T) {
- now, _ := time.Parse("2006-01-02T15:04:05-0700", "2026-11-15T12:00:00+0100")
- past, _ := loadOne(t, postFile(""))
- draft, _ := loadOne(t, postFile("Draft: true\n"))
- future, _ := loadOne(t, "Title: Later\nDate: 2026-12-01T09:00:00+0100\n-\nSoon.\n")
- if !past.Visible(now) || draft.Visible(now) || future.Visible(now) {
- t.Errorf("Visible: past %v draft %v future %v, want true false false", past.Visible(now), draft.Visible(now), future.Visible(now))
- }
- if !future.Visible(future.Date) {
- t.Error("a post is visible from the moment of its date")
- }
-}
-
-// TestPostHasDescription tells a written description from the fallback.
-func TestPostHasDescription(t *testing.T) {
- written, _ := loadOne(t, postFile("Description: Written by hand.\n"))
- fallback, _ := loadOne(t, postFile(""))
- if !written.HasDescription || written.Description != "Written by hand." {
- t.Errorf("written = %+v", written)
- }
- if fallback.HasDescription || fallback.Description != "One two three four five." {
- t.Errorf("fallback: HasDescription %v, Description %q", fallback.HasDescription, fallback.Description)
- }
-}
-
-// TestPostReadingMinutes checks the word count and the reading time.
-func TestPostReadingMinutes(t *testing.T) {
- p, _ := loadOne(t, postFile(""))
- if p.Words != 5 || p.ReadingMinutes() != 1 {
- t.Errorf("Words %d, ReadingMinutes %d, want 5 and 1", p.Words, p.ReadingMinutes())
- }
- long := strings.Repeat("word ", 401) + "\n"
- p, _ = loadOne(t, "Title: Long\nDate: 2026-11-14T12:00:00+0100\n-\n"+long)
- if p.Words != 401 || p.ReadingMinutes() != 3 {
- t.Errorf("Words %d, ReadingMinutes %d, want 401 and 3", p.Words, p.ReadingMinutes())
- }
- if (Post{}).ReadingMinutes() != 1 {
- t.Error("an empty post still reads in 1 minute")
- }
-}
-
-// TestPostLanguage checks the optional Language key and its validation.
-func TestPostLanguage(t *testing.T) {
- p, err := loadOne(t, postFile("Language: it\n"))
- if err != nil || p.Language != "it" {
- t.Fatalf("Language = %q, err = %v", p.Language, err)
- }
- if p, _ = loadOne(t, postFile("")); p.Language != "" {
- t.Errorf("a post without the key has Language %q, want empty (the builder gives it the language of the news)", p.Language)
- }
- for _, bad := range []string{"Italian", "IT", "i", "it_IT", "it fr"} {
- if _, err := loadOne(t, postFile("Language: "+bad+"\n")); err == nil || !strings.Contains(err.Error(), "Language") {
- t.Errorf("Language %q: error = %v, want one about Language", bad, err)
- }
- }
-}
diff --git a/internal/gemtext/gemtext.go b/internal/gemtext/gemtext.go
deleted file mode 100644
index f0049b1..0000000
--- a/internal/gemtext/gemtext.go
+++ /dev/null
@@ -1,767 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-// Package gemtext turns the HTML of a page into gemtext, the format of the
-// Gemini protocol. Gemtext has headings, one-line paragraphs, bullet items,
-// quotes, preformatted blocks and links on lines of their own, and nothing
-// else: no emphasis, no links inside text, no tables, no images.
-package gemtext
-
-import (
- "encoding/xml"
- "fmt"
- "io"
- "regexp"
- "strconv"
- "strings"
- "unicode/utf8"
-)
-
-// Options tell Convert how to treat the addresses and the generated blocks.
-type Options struct {
- // Link turns an address found in the HTML (a link or an image) into the
- // address to write. An empty result drops the link and keeps its text, as
- // for "#section"; an error stops the conversion and names the address. A
- // nil Link leaves every address as it is.
- Link func(href string) (string, error)
- // Block returns the gemtext of a block placeholder, the element
- // . A nil Block makes such an element an error.
- Block func(name string) (string, error)
-}
-
-// node is an element or a piece of text of the parsed HTML.
-type node struct {
- tag string
- text string
- attrs map[string]string
- kids []*node
-}
-
-// link is an address with the text that labels it.
-type link struct{ target, label string }
-
-// block is a part of the output: lines of text followed by link lines.
-type block struct {
- text []string
- links []link
-}
-
-// converter holds the options of one conversion.
-type converter struct{ opts Options }
-
-// Convert converts html, the body of a page, to gemtext. Blocks are separated
-// by a blank line; the links of a paragraph, a list, a quote or a table come
-// right after it, each on a line of its own, and the output ends with a line
-// break unless it is empty.
-func Convert(html string, opts Options) (string, error) {
- root, err := parse(html)
- if err != nil {
- return "", err
- }
- c := &converter{opts: opts}
- blocks, err := c.blocks(root.kids)
- if err != nil {
- return "", err
- }
- parts := make([]string, 0, len(blocks))
- for _, b := range blocks {
- if text := b.String(); text != "" {
- parts = append(parts, text)
- }
- }
- if len(parts) == 0 {
- return "", nil
- }
- return strings.Join(parts, "\n\n") + "\n", nil
-}
-
-// String returns the lines of the block, text first, then the link lines.
-func (b block) String() string {
- lines := append([]string(nil), b.text...)
- seen := map[link]bool{}
- for _, l := range b.links {
- if seen[l] {
- continue
- }
- seen[l] = true
- lines = append(lines, linkLine(l))
- }
- return strings.Join(lines, "\n")
-}
-
-// Text returns plain text as one line of gemtext: white space collapsed, and a
-// leading space when the text would be read as another kind of line.
-func Text(s string) string { return protect(strings.Join(strings.Fields(s), " ")) }
-
-// Link returns the link line of an address with a label.
-func Link(target, label string) string {
- return linkLine(link{target, strings.Join(strings.Fields(label), " ")})
-}
-
-// linkLine writes a link on its own line.
-func linkLine(l link) string {
- target := strings.Join(strings.Fields(l.target), "%20")
- if l.label == "" || l.label == l.target {
- return "=> " + target
- }
- return "=> " + target + " " + l.label
-}
-
-// voidTags are the elements that have no end tag.
-var voidTags = map[string]bool{
- "area": true, "base": true, "br": true, "col": true, "hr": true, "img": true, "input": true,
- "link": true, "meta": true, "param": true, "source": true, "basefont": true, "frame": true, "isindex": true,
-}
-
-// parse reads a fragment of HTML into a tree. The decoder is the lenient mode
-// of encoding/xml with the HTML void elements and entities: the HTML of a page
-// comes from a Markdown renderer and from the author's own raw HTML, which are
-// well formed apart from the void elements.
-func parse(html string) (*node, error) {
- source := "" + html + ""
- decoder := xml.NewDecoder(strings.NewReader(source))
- decoder.Strict = false
- decoder.AutoClose = xml.HTMLAutoClose
- decoder.Entity = xml.HTMLEntity
- root := &node{tag: "root"}
- stack := []*node{root}
- for {
- token, err := decoder.Token()
- if err == io.EOF {
- break
- }
- if err != nil {
- return nil, fmt.Errorf("read the HTML: %w", err)
- }
- top := stack[len(stack)-1]
- switch t := token.(type) {
- case xml.StartElement:
- n := &node{tag: strings.ToLower(t.Name.Local), attrs: map[string]string{}}
- for _, a := range t.Attr {
- n.attrs[strings.ToLower(a.Name.Local)] = a.Value
- }
- top.kids = append(top.kids, n)
- stack = append(stack, n)
- case xml.EndElement:
- // The lenient mode closes by itself what the text left open; that is
- // a mistake in the page, so an end that the text does not have is an error.
- name := strings.ToLower(t.Name.Local)
- written := strings.ToLower(source[:decoder.InputOffset()])
- if !voidTags[name] && !strings.HasSuffix(written, ""+name+">") && !strings.HasSuffix(written, "/>") {
- return nil, fmt.Errorf("read the HTML: the element <%s> is not closed", name)
- }
- if len(stack) > 1 {
- stack = stack[:len(stack)-1]
- }
- case xml.CharData:
- top.kids = append(top.kids, &node{text: string(t)})
- }
- }
- if len(stack) != 1 || len(root.kids) != 1 {
- return nil, fmt.Errorf("read the HTML: the element <%s> is not closed", stack[len(stack)-1].tag)
- }
- return root.kids[0], nil
-}
-
-// blockTags are the elements that start a block of their own.
-var blockTags = map[string]bool{
- "h1": true, "h2": true, "h3": true, "h4": true, "h5": true, "h6": true, "p": true,
- "ul": true, "ol": true, "blockquote": true, "pre": true, "hr": true, "table": true,
- "div": true, "section": true, "article": true, "main": true, "header": true, "footer": true,
- "nav": true, "aside": true, "figure": true, "figcaption": true, "details": true, "summary": true,
- "dl": true, "dt": true, "dd": true, "form": true, "fieldset": true, "address": true, "gemblock": true,
-}
-
-// cellTags are the elements of tables and lists whose text is kept apart from the
-// text next to it when they are read as part of a line.
-var cellTags = map[string]bool{"tr": true, "td": true, "th": true, "li": true}
-
-// skippedTags are the elements that have nothing to read.
-var skippedTags = map[string]bool{
- "script": true, "style": true, "svg": true, "noscript": true, "template": true,
- "head": true, "title": true, "meta": true, "link": true,
-}
-
-// skipped reports whether an element is left out: one with nothing to read, or
-// one that is hidden.
-func skipped(n *node) bool {
- _, hidden := n.attrs["hidden"]
- return skippedTags[n.tag] || hidden || n.attrs["aria-hidden"] == "true"
-}
-
-// blocks converts a list of nodes into blocks: block elements make their own,
-// and the text and the inline elements between them make paragraphs.
-func (c *converter) blocks(nodes []*node) ([]block, error) {
- var out []block
- var run []*node
- flush := func() error {
- if len(run) == 0 {
- return nil
- }
- b, err := c.paragraph(run)
- run = nil
- if err != nil {
- return err
- }
- out = append(out, b)
- return nil
- }
- for _, n := range nodes {
- if n.tag != "" && skipped(n) {
- continue
- }
- if n.tag == "" || !blockTags[n.tag] {
- run = append(run, n)
- continue
- }
- if err := flush(); err != nil {
- return nil, err
- }
- got, err := c.element(n)
- if err != nil {
- return nil, err
- }
- out = append(out, got...)
- }
- if err := flush(); err != nil {
- return nil, err
- }
- return out, nil
-}
-
-// element converts one block element.
-func (c *converter) element(n *node) ([]block, error) {
- switch n.tag {
- case "h1", "h2", "h3", "h4", "h5", "h6":
- return c.heading(n)
- case "p", "summary", "figcaption", "dt", "dd":
- if strings.Contains(" "+n.attrs["class"]+" ", " note ") || n.attrs["role"] == "note" {
- return c.quote(n.kids)
- }
- b, err := c.paragraph(n.kids)
- return []block{b}, err
- case "ul", "ol":
- b, err := c.list(n)
- return []block{b}, err
- case "blockquote":
- return c.quote(n.kids)
- case "pre":
- return []block{preformatted(n)}, nil
- case "hr":
- return nil, nil
- case "table":
- b, err := c.table(n)
- return []block{b}, err
- case "gemblock":
- return c.generated(n)
- default:
- return c.blocks(n.kids)
- }
-}
-
-// generated asks Options.Block for the gemtext of a block placeholder.
-func (c *converter) generated(n *node) ([]block, error) {
- name := n.attrs["name"]
- if c.opts.Block == nil {
- return nil, fmt.Errorf("the block %q has no generator", name)
- }
- text, err := c.opts.Block(name)
- if err != nil {
- return nil, fmt.Errorf("block %q: %w", name, err)
- }
- text = strings.Trim(text, "\n")
- if text == "" {
- return nil, nil
- }
- return []block{{text: strings.Split(text, "\n")}}, nil
-}
-
-// heading converts h1 to h6; gemtext has three levels.
-func (c *converter) heading(n *node) ([]block, error) {
- text, links, err := c.inline(n.kids, " ")
- if err != nil {
- return nil, err
- }
- text = strings.Join(strings.Fields(text), " ")
- if text == "" {
- return nil, nil
- }
- level := int(n.tag[1] - '0')
- if level > 3 {
- level = 3
- }
- return []block{{text: []string{strings.Repeat("#", level) + " " + text}, links: links}}, nil
-}
-
-// paragraph converts a run of text and inline elements. Each line break is a
-// line of its own, and the links come after. A paragraph that is only a link
-// is only the link line.
-func (c *converter) paragraph(nodes []*node) (block, error) {
- text, links, err := c.inline(nodes, "\n")
- if err != nil {
- return block{}, err
- }
- lines := cleanLines(text)
- if len(lines) == 1 && len(links) == 1 && lines[0] == links[0].label {
- return block{links: links}, nil
- }
- for i := range lines {
- lines[i] = protect(lines[i])
- }
- return block{text: lines, links: links}, nil
-}
-
-// cleanLines splits text at its line breaks, collapses the white space of every
-// line and drops the empty ones.
-func cleanLines(text string) []string {
- var lines []string
- for _, line := range strings.Split(text, "\n") {
- if line = strings.Join(strings.Fields(line), " "); line != "" {
- lines = append(lines, line)
- }
- }
- return lines
-}
-
-// protect keeps a line of text from being read as another kind of line: a
-// leading space does not change what it says and gemtext has no escape.
-func protect(line string) string {
- for _, prefix := range []string{"=>", "#", ">", "```", "* "} {
- if strings.HasPrefix(line, prefix) {
- return " " + line
- }
- }
- return line
-}
-
-// space matches a run of white space, the no-break space included.
-var space = regexp.MustCompile(`[\s\x{00a0}]+`)
-
-// inline returns the text of the nodes, the links in them and the addresses of
-// their images. lineBreak is what a becomes.
-func (c *converter) inline(nodes []*node, lineBreak string) (string, []link, error) {
- var text strings.Builder
- var links []link
- var walk func(n *node) error
- walk = func(n *node) error {
- if n.tag == "" {
- text.WriteString(space.ReplaceAllString(n.text, " "))
- return nil
- }
- if skipped(n) {
- return nil
- }
- switch n.tag {
- case "br":
- text.WriteString(lineBreak)
- return nil
- case "img":
- alt := strings.Join(strings.Fields(n.attrs["alt"]), " ")
- if alt == "" || n.attrs["src"] == "" || decorative(n) {
- return nil
- }
- target, err := c.address(n.attrs["src"])
- if err != nil {
- return err
- }
- if target != "" {
- links = append(links, link{target, alt})
- }
- return nil
- case "a":
- label, inner, err := c.inline(n.kids, " ")
- if err != nil {
- return err
- }
- text.WriteString(label)
- links = append(links, inner...)
- if href := n.attrs["href"]; href != "" {
- target, err := c.address(href)
- if err != nil {
- return err
- }
- if target != "" {
- links = append(links, link{target, strings.Join(strings.Fields(label), " ")})
- }
- }
- return nil
- }
- if blockTags[n.tag] || cellTags[n.tag] {
- text.WriteString(" ")
- }
- for _, kid := range n.kids {
- if err := walk(kid); err != nil {
- return err
- }
- }
- if blockTags[n.tag] || cellTags[n.tag] {
- text.WriteString(" ")
- }
- return nil
- }
- for _, n := range nodes {
- if err := walk(n); err != nil {
- return "", nil, err
- }
- }
- return text.String(), links, nil
-}
-
-// decorativeClasses are the classes of an image that belongs to the layout of the
-// page (the logo, a mark, an ornament), not to what the page says.
-var decorativeClasses = map[string]bool{"logo": true, "mark": true, "decorative": true}
-
-// decorative reports whether an image is there for the look of the page: it says
-// so with a role, or has one of the decorativeClasses. It is left out, a link line
-// to it would tell a reader of a capsule nothing.
-func decorative(n *node) bool {
- if role := n.attrs["role"]; role == "presentation" || role == "none" {
- return true
- }
- for _, class := range strings.Fields(n.attrs["class"]) {
- if decorativeClasses[class] {
- return true
- }
- }
- return false
-}
-
-// address maps an address through Options.Link.
-func (c *converter) address(href string) (string, error) {
- if c.opts.Link == nil {
- return href, nil
- }
- target, err := c.opts.Link(href)
- if err != nil {
- return "", fmt.Errorf("the address %q: %w", href, err)
- }
- return target, nil
-}
-
-// item is one bullet of a list, with the preformatted blocks it holds.
-type item struct {
- text string
- links []link
- // pre holds the lines of the preformatted blocks of the item, fences included.
- pre []string
-}
-
-// list converts a list: bullets, with the links after them. A list in which
-// every item is only a link is a list of link lines. An item with no text, only
-// an image or a link without a label, has no bullet; its links are written all
-// the same. A list inside an item is flattened into the same list, and a
-// preformatted block in an item follows its bullet. An ordered list numbers its
-// items.
-func (c *converter) list(n *node) (block, error) {
- var items []item
- if err := c.items(n, &items); err != nil {
- return block{}, err
- }
- linksOnly := len(items) > 0
- var links []link
- for _, it := range items {
- links = append(links, it.links...)
- if len(it.pre) > 0 || len(it.links) != 1 || it.text != it.links[0].label {
- linksOnly = false
- }
- }
- if linksOnly {
- return block{links: links}, nil
- }
- var lines []string
- number := 0
- for _, it := range items {
- if it.text != "" {
- number++
- prefix := "* "
- if n.tag == "ol" {
- prefix += strconv.Itoa(number) + ". "
- }
- lines = append(lines, prefix+it.text)
- }
- lines = append(lines, it.pre...)
- }
- return block{text: lines, links: links}, nil
-}
-
-// items collects the items of a list and of the lists inside it.
-func (c *converter) items(list *node, out *[]item) error {
- for _, li := range list.kids {
- if li.tag != "li" || skipped(li) {
- continue
- }
- var own, nested []*node
- var pre []string
- for _, kid := range li.kids {
- switch {
- case kid.tag == "ul" || kid.tag == "ol":
- nested = append(nested, kid)
- case kid.tag == "pre" && !skipped(kid):
- pre = append(pre, preformatted(kid).text...)
- default:
- own = append(own, kid)
- }
- }
- text, links, err := c.inline(own, " ")
- if err != nil {
- return err
- }
- if text = strings.Join(strings.Fields(text), " "); text != "" || len(links) > 0 || len(pre) > 0 {
- *out = append(*out, item{text: text, links: links, pre: pre})
- }
- for _, inner := range nested {
- if err := c.items(inner, out); err != nil {
- return err
- }
- }
- }
- return nil
-}
-
-// quote converts the content of a quote: every line starts with "> ", the
-// blocks are separated by an empty quote line, and the links come after.
-func (c *converter) quote(nodes []*node) ([]block, error) {
- inner, err := c.blocks(nodes)
- if err != nil {
- return nil, err
- }
- var lines []string
- var links []link
- for _, b := range inner {
- if len(b.text) == 0 {
- links = append(links, b.links...)
- continue
- }
- if len(lines) > 0 {
- lines = append(lines, ">")
- }
- for _, line := range b.text {
- lines = append(lines, "> "+strings.TrimPrefix(line, " "))
- }
- links = append(links, b.links...)
- }
- if len(lines) == 0 && len(links) == 0 {
- return nil, nil
- }
- return []block{{text: lines, links: links}}, nil
-}
-
-// preformatted converts a
: its text as it is between two fence lines. A
-// line that would close the block early gets a space in front.
-func preformatted(n *node) block {
- var text strings.Builder
- var walk func(n *node)
- walk = func(n *node) {
- if n.tag == "" {
- text.WriteString(n.text)
- return
- }
- if n.tag == "br" {
- text.WriteString("\n")
- return
- }
- for _, kid := range n.kids {
- walk(kid)
- }
- }
- walk(n)
- lines := strings.Split(strings.TrimSuffix(text.String(), "\n"), "\n")
- out := []string{"```"}
- for _, line := range lines {
- if strings.HasPrefix(line, "```") {
- line = " " + line
- }
- out = append(out, strings.TrimRight(line, " \t"))
- }
- return block{text: append(out, "```")}
-}
-
-// table converts a table to a preformatted block of aligned columns, with a
-// line under a header row, and the caption as a line of text before it. The
-// links of the cells come after the block.
-func (c *converter) table(n *node) (block, error) {
- var rows [][]string
- var links []link
- var caption string
- headerRow := false
- var walk func(n *node) error
- walk = func(n *node) error {
- for _, kid := range n.kids {
- if kid.tag == "" || skipped(kid) {
- continue
- }
- switch kid.tag {
- case "caption":
- text, inner, err := c.inline(kid.kids, " ")
- if err != nil {
- return err
- }
- caption = strings.Join(strings.Fields(text), " ")
- links = append(links, inner...)
- case "tr":
- var cells []string
- onlyHeaders := true
- for _, cell := range kid.kids {
- if cell.tag != "td" && cell.tag != "th" {
- continue
- }
- text, inner, err := c.inline(cell.kids, " ")
- if err != nil {
- return err
- }
- cells = append(cells, strings.Join(strings.Fields(text), " "))
- links = append(links, inner...)
- if cell.tag != "th" {
- onlyHeaders = false
- }
- }
- if len(cells) > 0 {
- if len(rows) == 0 && onlyHeaders {
- headerRow = true
- }
- rows = append(rows, cells)
- }
- default:
- if err := walk(kid); err != nil {
- return err
- }
- }
- }
- return nil
- }
- if err := walk(n); err != nil {
- return block{}, err
- }
- var text []string
- if caption != "" {
- text = append(text, protect(caption))
- }
- switch {
- case len(rows) == 0:
- case tableWidth(rows) <= maxTableWidth:
- text = append(text, "```")
- text = append(text, alignRows(rows, headerRow)...)
- text = append(text, "```")
- default:
- if caption != "" {
- text = append(text, "")
- }
- text = append(text, records(rows, headerRow)...)
- }
- return block{text: text, links: links}, nil
-}
-
-// maxTableWidth is the widest a table can be and stay a preformatted block: lines
-// of a preformatted block are not wrapped by the readers.
-const maxTableWidth = 80
-
-// tableWidth returns the width of the rows written as columns two spaces apart.
-func tableWidth(rows [][]string) int {
- widest := 0
- for _, line := range alignRows(rows, false) {
- if w := utf8.RuneCountInString(line); w > widest {
- widest = w
- }
- }
- return widest
-}
-
-// records writes the rows of a wide table as a list. With a header row and
-// more than one column each row is a heading, its first cell when it has
-// something in it, and a bullet for each other cell that is not empty, named by
-// the header of its column. A table of one column is a bullet for each cell, the
-// header a line of text before them. Without a header, or with a header and
-// nothing else, each row is a bullet with the cells between bars.
-func records(rows [][]string, header bool) []string {
- columns := 0
- for _, r := range rows {
- if len(r) > columns {
- columns = len(r)
- }
- }
- if header && len(rows) == 1 {
- header = false
- }
- var lines []string
- if columns <= 1 {
- if header {
- lines = append(lines, protect(rows[0][0]))
- rows = rows[1:]
- }
- for _, r := range rows {
- lines = append(lines, "* "+strings.Join(r, " | "))
- }
- return lines
- }
- if !header {
- for _, r := range rows {
- lines = append(lines, "* "+strings.Join(r, " | "))
- }
- return lines
- }
- names := rows[0]
- for i, r := range rows[1:] {
- if i > 0 {
- lines = append(lines, "")
- }
- if len(r) > 0 && r[0] != "" {
- lines = append(lines, "### "+r[0])
- }
- for j := 1; j < len(r); j++ {
- if r[j] == "" {
- continue
- }
- name := ""
- if j < len(names) {
- name = names[j] + ": "
- }
- lines = append(lines, "* "+name+r[j])
- }
- }
- return lines
-}
-
-// alignRows writes rows of cells as columns two spaces apart, each as wide as
-// its widest cell, with a line of dashes under the first row when it is a header.
-func alignRows(rows [][]string, header bool) []string {
- columns := 0
- for _, r := range rows {
- if len(r) > columns {
- columns = len(r)
- }
- }
- widths := make([]int, columns)
- for _, r := range rows {
- for i, cell := range r {
- if w := utf8.RuneCountInString(cell); w > widths[i] {
- widths[i] = w
- }
- }
- }
- write := func(r []string) string {
- cells := make([]string, columns)
- for i := range cells {
- cell := ""
- if i < len(r) {
- cell = r[i]
- }
- cells[i] = cell + strings.Repeat(" ", widths[i]-utf8.RuneCountInString(cell))
- }
- line := strings.TrimRight(strings.Join(cells, " "), " ")
- if strings.HasPrefix(line, "```") {
- line = " " + line
- }
- return line
- }
- var lines []string
- for i, r := range rows {
- lines = append(lines, write(r))
- if i == 0 && header {
- dashes := make([]string, columns)
- for j := range dashes {
- dashes[j] = strings.Repeat("-", widths[j])
- }
- lines = append(lines, strings.Join(dashes, " "))
- }
- }
- return lines
-}
diff --git a/internal/gemtext/gemtext_test.go b/internal/gemtext/gemtext_test.go
deleted file mode 100644
index 9f61a2f..0000000
--- a/internal/gemtext/gemtext_test.go
+++ /dev/null
@@ -1,235 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package gemtext
-
-import (
- "errors"
- "strings"
- "testing"
-)
-
-// identity leaves every address as it is.
-func identity(href string) (string, error) { return href, nil }
-
-// convert converts html with addresses left as they are and no blocks.
-func convert(t *testing.T, html string) string {
- t.Helper()
- got, err := Convert(html, Options{Link: identity})
- if err != nil {
- t.Fatalf("Convert(%q) error = %v", html, err)
- }
- return got
-}
-
-// TestConvert checks the gemtext of every kind of element the site uses.
-func TestConvert(t *testing.T) {
- tests := []struct {
- name, html, want string
- }{
- {"headings", `
Title
Sub
Deep
`, "# Title\n\n## Sub\n\n### Deep\n"},
- {"hero with line breaks", `
Technology. Freedom. Dissent.
`, "# Technology. Freedom. Dissent.\n"},
- {"links go after the paragraph",
- `
`, Options{Link: link})
- if err == nil || !strings.Contains(err.Error(), "/broken.html") || !strings.Contains(err.Error(), "no such page") {
- t.Errorf("error = %v, want one that names the address and the cause", err)
- }
- _, err = Convert(`
`, Options{Link: link})
- if err == nil {
- t.Error("a broken image address is not an error")
- }
-}
-
-// TestConvertBlocks checks the placeholders of generated blocks.
-func TestConvertBlocks(t *testing.T) {
- block := func(name string) (string, error) {
- if name != "news_list" {
- return "", errors.New("unknown block " + name)
- }
- return "=> /a 2026-01-01 A\n=> /b 2025-12-31 B", nil
- }
- got, err := Convert(`
intro
end
`, Options{Link: identity, Block: block})
- if err != nil || got != "intro\n\n=> /a 2026-01-01 A\n=> /b 2025-12-31 B\n\nend\n" {
- t.Errorf("Convert() = %q, %v", got, err)
- }
- if _, err := Convert(``, Options{Link: identity, Block: block}); err == nil {
- t.Error("an unknown block is not an error")
- }
- if _, err := Convert(``, Options{Link: identity}); err == nil {
- t.Error("a block without a Block function is not an error")
- }
-}
-
-// TestConvertRejectsBrokenHTML checks that markup that cannot be read is an error.
-func TestConvertRejectsBrokenHTML(t *testing.T) {
- if _, err := Convert(`
unclosed`, Options{Link: identity}); err == nil || !strings.Contains(err.Error(), "HTML") {
- t.Errorf("error = %v, want one about the HTML", err)
- }
-}
-
-// TestTextAndLink checks the helpers that write single lines.
-func TestTextAndLink(t *testing.T) {
- if got := Text(" two \n words "); got != "two words" {
- t.Errorf("Text() = %q", got)
- }
- if got := Text("# not a heading"); got != " # not a heading" {
- t.Errorf("Text() = %q, want a leading space", got)
- }
- if got := Link("/a.gmi", " A page "); got != "=> /a.gmi A page" {
- t.Errorf("Link() = %q", got)
- }
- if got := Link("/a.gmi", ""); got != "=> /a.gmi" {
- t.Errorf("Link() without a label = %q", got)
- }
-}
-
-// TestConvertWideTable checks that a table that does not fit in 80 columns becomes a list of records, a
-// heading for the first cell of each row and a bullet for each other cell, named by its column.
-func TestConvertWideTable(t *testing.T) {
- long := strings.Repeat("word ", 20) + "end"
- html := `
`
- if got, want := convert(t, noHeader), "* a | "+long+"\n* b | c\n"; got != want {
- t.Errorf("Convert() without a header =\n%q\nwant\n%q", got, want)
- }
-}
-
-// TestConvertListItems checks the items that have no text, more than one paragraph or a preformatted block.
-func TestConvertListItems(t *testing.T) {
- tests := []struct {
- name, html, want string
- }{
- {"an item that is only an image has no bullet", `
Text
`, "* Text\n=> /a.png pic\n"},
- {"an item that is a link without text has no bullet", `
Text
`, "* Text\n=> /x\n"},
- {"an item of only an image in a list of only images", `
`, "=> /a.png A\n=> /b.png B\n"},
- {"paragraphs of an item do not stick", `
First
Second
`, "* First Second\n"},
- {"cells of a table in an item do not stick", `
a
b
`, "* a b\n"},
- {"a preformatted block in an item stays a block", "
Run:
x\n y
Next
", "* Run:\n```\nx\n y\n```\n* Next\n"},
- {"a preformatted block that is all of an item", "
code
", "```\ncode\n```\n"},
- }
- for _, tt := range tests {
- t.Run(tt.name, func(t *testing.T) {
- if got := convert(t, tt.html); got != tt.want {
- t.Errorf("Convert() =\n%q\nwant\n%q", got, tt.want)
- }
- })
- }
-}
-
-// TestConvertAddressWithSpaces checks that a space in an address does not end the address of a link line.
-func TestConvertAddressWithSpaces(t *testing.T) {
- if got, want := convert(t, `