1 files changed, 57 insertions, 89 deletions

diff --git a/roseh.moe.go b/roseh.moe.go
index 932579f..98febd1 100644
--- a/roseh.moe.go
+++ b/roseh.moe.go
@@ -1,7 +1,6 @@
 package main
 
 import (
-	"bytes"
 	"embed"
 	"flag"
 	"fmt"
@@ -55,128 +54,97 @@ var (
 	blogPostFiles embed.FS
 )
 
-func posts() []string {
-	postFiles, err := blogPostFiles.ReadDir("templates/blog/posts")
-	if err != nil {
-		log.Fatalf("blog posts: %s", err)
-	}
-	posts := make([]string, len(postFiles))
-	for i, f := range postFiles {
-		posts[i] = strings.TrimSuffix(f.Name(), ".html.template")
-	}
-	return posts
-}
-
-func postName(post string) string {
-	postBytes, err := blogPostFiles.ReadFile("templates/blog/posts/" + post + ".html.template")
-	if err != nil {
-		log.Fatalf("blog post %q: %s", post, err)
-	}
-	return string(bytes.TrimSuffix(bytes.TrimPrefix(postBytes[:bytes.IndexByte(postBytes, '\n')], []byte("<h1>")), []byte("</h1>")))
-}
-
-func preloadBlogPosts() map[string][]byte {
+func mustParseBlogPostTemplates() map[string]*template.Template {
 	base, err := outlineTemplate.Clone()
 	if err != nil {
 		log.Fatalf("outlineTemplate.Clone: %s", err)
 	}
-	base, err = base.New("body").Parse(postString)
+	if _, err := base.New("body").Parse(postString); err != nil {
+		log.Fatalf("post.html.template: %s", err)
+	}
+	postFiles, err := blogPostFiles.ReadDir("templates/blog/posts")
 	if err != nil {
-		log.Fatalf("post.html.template: invalid template: %s", err)
+		log.Fatalf("read blog post templates: %s", err)
 	}
-	postSlugs := posts()
-	posts := make(map[string][]byte, len(postSlugs))
-	for _, post := range postSlugs {
-		postTemplate, err := base.Clone()
-		if err != nil {
-			log.Fatalf("base.Clone: %s", err)
-		}
-		postString, err := blogPostFiles.ReadFile("templates/blog/posts/" + post + ".html.template")
+	posts := make(map[string]*template.Template, len(postFiles))
+	for _, file := range postFiles {
+		fileContent, err := blogPostFiles.ReadFile("templates/blog/posts/" + file.Name())
 		if err != nil {
-			log.Fatalf("somehow I fucked the paths up: %s", err)
+			log.Fatalf("read blog post template %q: %s", file.Name(), err)
 		}
-		postTemplate, err = postTemplate.New("post").Parse(string(postString))
+		tmpl, err := base.Clone()
 		if err != nil {
-			log.Fatalf("%q: invalid template: %s", post, err)
-		}
-		type args struct {
-			Title string
+			log.Fatalf("base.Clone: %s", err)
 		}
-		buf := new(bytes.Buffer)
-		if err := postTemplate.ExecuteTemplate(buf, "outline", args{Title: postName(post)}); err != nil {
-			log.Fatalf("%q: error: %s", post, err)
+		if _, err := tmpl.New("post").Parse(string(fileContent)); err != nil {
+			log.Fatalf("%q: %s", file.Name(), err)
 		}
-		posts[post] = buf.Bytes()
+		posts[strings.TrimSuffix(file.Name(), ".html.template")] = tmpl
 	}
 	return posts
 }
 
-var blogPostsHTML = preloadBlogPosts()
+var blogPostTemplates = mustParseBlogPostTemplates()
 
 func blog(w http.ResponseWriter, r *http.Request) {
-	post, ok := blogPostsHTML[strings.TrimPrefix(r.URL.Path, "/blog/")]
+	tmpl, ok := blogPostTemplates[strings.TrimPrefix(r.URL.Path, "/blog/")]
 	if !ok {
 		notFound(w, r)
 		return
 	}
-	http.ServeContent(w, r, "post.html", serverStartTime, bytes.NewReader(post))
+	if err := tmpl.ExecuteTemplate(w, "outline", nil); err != nil {
+		log.Printf("Warning: blog: %s", err)
+	}
 }
 
-//go:embed templates/index.html.template
-var indexString string
+type blogPost struct {
+	Name string
+	Slug string
+}
 
-func preloadIndex() []byte {
-	base, err := outlineTemplate.Clone()
-	if err != nil {
-		log.Fatalf("outlineTemplate.Clone: %s", err)
-	}
-	base.Funcs(template.FuncMap{
-		"name": func(post string) string {
-			return post[:strings.IndexByte(post, '_')] + ": " + postName(post)
-		},
-	})
-	indexTemplate, err := base.New("body").Parse(indexString)
-	if err != nil {
-		log.Fatalf("index.html.template: invalid template: %s", err)
-	}
-	posts := posts()
-	slices.SortFunc(posts, func(x, y string) int { return strings.Compare(y, x) })
-	type args struct {
-		Title string
-		Posts []string
-	}
-	buf := new(bytes.Buffer)
-	if err := indexTemplate.ExecuteTemplate(buf, "outline", args{Title: "roseh.moe", Posts: posts}); err != nil {
-		log.Fatalf("index.html.template: error: %s", err)
+func mustLoadBlogPosts() []blogPost {
+	buf := new(strings.Builder)
+	posts := make([]blogPost, 0, len(blogPostTemplates))
+	for slug, tmpl := range blogPostTemplates {
+		buf.Reset()
+		if err := tmpl.ExecuteTemplate(buf, "title", nil); err != nil {
+			log.Fatalf("blog post %q: title: %s", slug, err)
+		}
+		posts = append(posts, blogPost{
+			Name: buf.String(),
+			Slug: slug,
+		})
 	}
-	return buf.Bytes()
+	slices.SortFunc(posts, func(x, y blogPost) int { return strings.Compare(y.Slug, x.Slug) })
+	return posts
 }
 
-var indexHTML = preloadIndex()
+var (
+	//go:embed templates/index.html.template
+	indexString string
 
-func index(w http.ResponseWriter, r *http.Request) {
-	http.ServeContent(w, r, "index.html", serverStartTime, bytes.NewReader(indexHTML))
-}
+	indexTemplate = template.Must(template.Must(outlineTemplate.Clone()).New("body").Parse(indexString))
 
-//go:embed templates/pong.html.template
-var pongString string
+	blogPostsList = mustLoadBlogPosts()
+)
 
-func preloadPong() []byte {
-	pongTemplate, err := template.New("pong").Parse(pongString)
-	if err != nil {
-		log.Fatalf("pong.html.template: invalid template: %s", err)
+func index(w http.ResponseWriter, _ *http.Request) {
+	if err := indexTemplate.ExecuteTemplate(w, "outline", blogPostsList); err != nil {
+		log.Printf("Warning: index: %s", err)
 	}
-	buf := new(bytes.Buffer)
-	if err := pongTemplate.Execute(buf, nil); err != nil {
-		log.Fatalf("pong.html.template: error: %s", err)
-	}
-	return buf.Bytes()
 }
 
-var pongHTML = preloadPong()
+var (
+	//go:embed templates/pong.html.template
+	pongString string
 
-func pong(w http.ResponseWriter, r *http.Request) {
-	http.ServeContent(w, r, "pong.html", serverStartTime, bytes.NewReader(pongHTML))
+	pongTemplate = template.Must(template.New("pong").Parse(pongString))
+)
+
+func pong(w http.ResponseWriter, _ *http.Request) {
+	if err := pongTemplate.Execute(w, nil); err != nil {
+		log.Printf("Warning: pong: %s", err)
+	}
 }
 
 //go:embed static