1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
package generator
import (
"encoding/json"
"fmt"
"html/template"
"os"
"path/filepath"
"sort"
"strings"
"time"
"codeberg.org/snonux/snonux/internal/config"
"codeberg.org/snonux/snonux/internal/generator/atom"
"codeberg.org/snonux/snonux/internal/post"
)
// pageData holds the template variables for a single HTML page.
type pageData struct {
Posts []postView
PrevPage string // URL of the newer page, empty if none
NextPage string // URL of the older page, empty if none
PrevPageJSON template.JS
NextPageJSON template.JS
}
// postView is a render-friendly representation of a post for the HTML template.
type postView struct {
FormattedTime string
ContentHTML template.HTML // pre-rendered; trusted — generated by this tool
}
// Run loads all posts, generates all HTML pages, and writes atom.xml.
func Run(cfg *config.Config) error {
posts, err := loadAllPosts(cfg.OutputDir)
if err != nil {
return err
}
// Sort newest-first so page 1 (index.html) has the latest content.
sort.Slice(posts, func(i, j int) bool {
return posts[i].Timestamp.After(posts[j].Timestamp)
})
pages := paginate(posts, config.PostsPerPage)
// Combine the theme HTML (which uses {{template "navhints"}} etc.) with the
// shared navDefs sub-templates so a single parse call resolves all references.
combined := getTheme(cfg.Theme) + "\n" + navDefs
tmpl, err := template.New("page").Parse(combined)
if err != nil {
return fmt.Errorf("parse page template: %w", err)
}
for i, page := range pages {
if err := writePage(tmpl, page, i, len(pages), cfg); err != nil {
return err
}
}
return atom.Generate(posts, cfg)
}
// loadAllPosts walks outdir/posts/ and deserialises every post.json found.
func loadAllPosts(outputDir string) ([]*post.Post, error) {
postsDir := filepath.Join(outputDir, "posts")
entries, err := os.ReadDir(postsDir)
if os.IsNotExist(err) {
return nil, nil // no posts yet — normal on first run
}
if err != nil {
return nil, fmt.Errorf("read posts dir: %w", err)
}
var posts []*post.Post
for _, entry := range entries {
if !entry.IsDir() {
continue
}
p, err := post.Load(filepath.Join(postsDir, entry.Name()))
if err != nil {
return nil, err
}
posts = append(posts, p)
}
return posts, nil
}
// paginate splits posts into chunks of size pageSize.
func paginate(posts []*post.Post, pageSize int) [][]*post.Post {
var pages [][]*post.Post
for i := 0; i < len(posts); i += pageSize {
end := i + pageSize
if end > len(posts) {
end = len(posts)
}
pages = append(pages, posts[i:end])
}
return pages
}
// pageFilename returns "index.html" for page 0 and "pageN.html" for page N>0.
func pageFilename(index int) string {
if index == 0 {
return "index.html"
}
return fmt.Sprintf("page%d.html", index+1)
}
// writePage renders one HTML page and writes it to cfg.OutputDir.
func writePage(tmpl *template.Template, posts []*post.Post, pageIndex, totalPages int, cfg *config.Config) error {
data := buildPageData(posts, pageIndex, totalPages)
filename := pageFilename(pageIndex)
path := filepath.Join(cfg.OutputDir, filename)
f, err := os.Create(path)
if err != nil {
return fmt.Errorf("create %s: %w", filename, err)
}
defer f.Close()
if err := tmpl.Execute(f, data); err != nil {
return fmt.Errorf("render %s: %w", filename, err)
}
return nil
}
// buildPageData constructs the template data for a single page.
func buildPageData(posts []*post.Post, pageIndex, totalPages int) pageData {
views := make([]postView, len(posts))
for i, p := range posts {
views[i] = postView{
FormattedTime: formatPostTime(p.Timestamp),
ContentHTML: template.HTML(p.Content), //nolint:gosec // content is tool-generated HTML
}
}
var prevPage, nextPage string
// "Prev" means newer — page index decreases.
if pageIndex > 0 {
prevPage = pageFilename(pageIndex - 1)
}
// "Next" means older — page index increases.
if pageIndex < totalPages-1 {
nextPage = pageFilename(pageIndex + 1)
}
return pageData{
Posts: views,
PrevPage: prevPage,
NextPage: nextPage,
PrevPageJSON: jsonStringOrNull(prevPage),
NextPageJSON: jsonStringOrNull(nextPage),
}
}
// formatPostTime formats a UTC timestamp in the style used on posts: "09.04.26 • 14:30 UTC".
func formatPostTime(t time.Time) string {
utc := t.UTC()
return fmt.Sprintf("%02d.%02d.%02d • %02d:%02d UTC",
utc.Day(), int(utc.Month()), utc.Year()%100,
utc.Hour(), utc.Minute(),
)
}
// jsonStringOrNull returns a JS-safe JSON string literal for s, or "null" if empty.
// The result is safe to embed directly in a <script> block as a JS value.
func jsonStringOrNull(s string) template.JS {
if s == "" {
return "null"
}
b, _ := json.Marshal(s)
return template.JS(strings.TrimSpace(string(b))) //nolint:gosec // filename is tool-generated
}
|
