about summary refs log tree commit diff stats
path: root/cmd
diff options
context:
space:
mode:
Diffstat (limited to 'cmd')
-rw-r--r--cmd/build/build.go408
-rw-r--r--cmd/build/main.go52
-rw-r--r--cmd/build/posts.go121
-rw-r--r--cmd/build/template.go275
-rw-r--r--cmd/server/filemap.go77
-rw-r--r--cmd/server/logging.go55
-rw-r--r--cmd/server/main.go38
-rw-r--r--cmd/server/server.go146
8 files changed, 625 insertions, 547 deletions
diff --git a/cmd/build/build.go b/cmd/build/build.go
index f165361..9b58095 100644
--- a/cmd/build/build.go
+++ b/cmd/build/build.go
@@ -1,391 +1,21 @@
 package main
 
 import (
-	"bytes"
-	"encoding/xml"
 	"fmt"
 	"io"
-	"io/fs"
 	"log"
 	"log/slog"
 	"net/url"
 	"os"
 	"path"
-	"path/filepath"
 	"slices"
-	"strings"
-	"time"
 
-	"website/internal/atom"
 	"website/internal/config"
 
-	"github.com/BurntSushi/toml"
-	"github.com/PuerkitoBio/goquery"
-	"github.com/a-h/htmlformat"
-	"github.com/adrg/frontmatter"
-	"github.com/antchfx/xmlquery"
-	"github.com/antchfx/xpath"
-	"github.com/ardanlabs/conf/v3"
-	mapset "github.com/deckarep/golang-set/v2"
 	cp "github.com/otiai10/copy"
 	"github.com/pkg/errors"
-	"github.com/yuin/goldmark"
-	"github.com/yuin/goldmark/extension"
-	htmlrenderer "github.com/yuin/goldmark/renderer/html"
-	"golang.org/x/net/html"
 )
 
-type PostMatter struct {
-	Date        time.Time `toml:"date"`
-	Description string    `toml:"description"`
-	Title       string    `toml:"title"`
-	Taxonomies  struct {
-		Tags []string `toml:"tags"`
-	} `toml:"taxonomies"`
-}
-
-type Post struct {
-	Input    string
-	Output   string
-	Basename string
-	URL      string
-	Content  string
-	PostMatter
-}
-
-type Tags mapset.Set[string]
-
-func getPost(filename string) (*PostMatter, *[]byte, error) {
-	matter := PostMatter{}
-	content, err := os.Open(filename)
-	defer content.Close()
-	if err != nil {
-		return nil, nil, errors.WithMessagef(err, "could not open post %s", filename)
-	}
-	rest, err := frontmatter.MustParse(content, &matter)
-	if err != nil {
-		return nil, nil, errors.WithMessagef(err, "could not parse front matter of post %s", filename)
-	}
-
-	return &matter, &rest, nil
-}
-
-func readPosts(root string, inputDir string, outputDir string) ([]Post, Tags, error) {
-	tags := mapset.NewSet[string]()
-	posts := []Post{}
-	subdir := filepath.Join(root, inputDir)
-	files, err := os.ReadDir(subdir)
-	if err != nil {
-		return nil, nil, errors.WithMessagef(err, "could not read post directory %s", subdir)
-	}
-	outputReplacer := strings.NewReplacer(root, outputDir, ".md", "/index.html")
-	urlReplacer := strings.NewReplacer(root, "", ".md", "/")
-	markdown := goldmark.New(
-		goldmark.WithRendererOptions(
-			htmlrenderer.WithUnsafe(),
-		),
-		goldmark.WithExtensions(
-			extension.GFM,
-			extension.Footnote,
-			extension.Typographer,
-		),
-	)
-	for _, f := range files {
-		pathFromRoot := filepath.Join(subdir, f.Name())
-		if !f.IsDir() && path.Ext(pathFromRoot) == ".md" {
-			output := outputReplacer.Replace(pathFromRoot)
-			url := urlReplacer.Replace(pathFromRoot)
-			slog.Debug("reading post", "post", pathFromRoot)
-			matter, content, err := getPost(pathFromRoot)
-			if err != nil {
-				return nil, nil, err
-			}
-
-			for _, tag := range matter.Taxonomies.Tags {
-				tags.Add(strings.ToLower(tag))
-			}
-
-			var buf bytes.Buffer
-			slog.Debug("rendering markdown in post", "post", pathFromRoot)
-			if err := markdown.Convert(*content, &buf); err != nil {
-				return nil, nil, errors.WithMessage(err, "could not convert markdown content")
-			}
-			post := Post{
-				Input:      pathFromRoot,
-				Output:     output,
-				Basename:   filepath.Base(url),
-				URL:        url,
-				PostMatter: *matter,
-				Content:    buf.String(),
-			}
-
-			posts = append(posts, post)
-		}
-	}
-	slices.SortFunc(posts, func(a, b Post) int {
-		return b.Date.Compare(a.Date)
-	})
-	return posts, tags, nil
-}
-
-func layout(filename string, config config.Config, pageTitle string) (*goquery.Document, error) {
-	html, err := os.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-	defer html.Close()
-	css, err := os.ReadFile("templates/style.css")
-	if err != nil {
-		return nil, err
-	}
-	doc, err := goquery.NewDocumentFromReader(html)
-	if err != nil {
-		return nil, err
-	}
-	doc.Find("html").SetAttr("lang", config.DefaultLanguage)
-	doc.Find("head > link[rel=alternate]").SetAttr("title", config.Title)
-	doc.Find(".title").SetText(config.Title)
-	doc.Find("title").Add(".p-name").SetText(pageTitle)
-	doc.Find("head > style").SetHtml("\n" + string(css))
-	nav := doc.Find("nav")
-	navLink := doc.Find("nav a")
-	nav.Empty()
-	for _, link := range config.Menus["main"] {
-		nav.AppendSelection(navLink.Clone().SetAttr("href", link.URL).SetText(link.Name))
-	}
-	return doc, nil
-}
-
-func renderHTML(doc *goquery.Document) io.Reader {
-	r, w := io.Pipe()
-
-	// TODO: return errors to main thread
-	go func() {
-		w.Write([]byte("<!doctype html>\n"))
-		err := htmlformat.Nodes(w, []*html.Node{doc.Children().Get(0)})
-		if err != nil {
-			slog.Error("error rendering html", "error", err)
-			w.CloseWithError(err)
-			return
-		}
-		defer w.Close()
-	}()
-	return r
-}
-
-func renderPost(post Post, config config.Config) (r io.Reader, err error) {
-	doc, err := layout("templates/post.html", config, post.PostMatter.Title)
-	if err != nil {
-		return nil, err
-	}
-	doc.Find(".title").AddClass("p-author h-card").SetAttr("rel", "author")
-	doc.Find(".h-entry .dt-published").
-		SetAttr("datetime", post.PostMatter.Date.UTC().Format(time.RFC3339)).
-		SetText(
-			post.PostMatter.Date.Format("2006-01-02"),
-		)
-	doc.Find(".h-entry .e-content").SetHtml(post.Content)
-	categories := doc.Find(".h-entry .p-categories")
-	tpl := categories.Find(".p-category").ParentsUntilSelection(categories)
-	tpl.Remove()
-	for _, tag := range post.Taxonomies.Tags {
-		cat := tpl.Clone()
-		cat.Find(".p-category").SetAttr("href", fmt.Sprintf("/tags/%s/", tag)).SetText("#" + tag)
-		categories.AppendSelection(cat)
-	}
-
-	return renderHTML(doc), nil
-}
-
-func renderTags(tags Tags, config config.Config) (io.Reader, error) {
-	doc, err := layout("templates/tags.html", config, config.Title)
-	if err != nil {
-		return nil, err
-	}
-	tagList := doc.Find(".tags")
-	tpl := doc.Find(".h-feed")
-	tpl.Remove()
-	for _, tag := range mapset.Sorted(tags) {
-		li := tpl.Clone()
-		li.Find("a").SetAttr("href", fmt.Sprintf("/tags/%s/", tag)).SetText("#" + tag)
-		tagList.AppendSelection(li)
-	}
-	return renderHTML(doc), nil
-}
-
-func renderListPage(tag string, config config.Config, posts []Post) (io.Reader, error) {
-	var title string
-	if len(tag) > 0 {
-		title = tag
-	} else {
-		title = config.Title
-	}
-	doc, err := layout("templates/list.html", config, title)
-	if err != nil {
-		return nil, err
-	}
-	feed := doc.Find(".h-feed")
-	tpl := feed.Find(".h-entry")
-	tpl.Remove()
-
-	doc.Find(".title").AddClass("p-author h-card").SetAttr("rel", "author")
-	if tag == "" {
-		doc.Find(".filter").Remove()
-	} else {
-		doc.Find(".filter").Find("h3").SetText("#" + tag)
-	}
-
-	for _, post := range posts {
-		entry := tpl.Clone()
-		entry.Find(".p-name").SetText(post.Title).SetAttr("href", post.URL)
-		entry.Find(".dt-published").
-			SetAttr("datetime", post.PostMatter.Date.UTC().Format(time.RFC3339)).
-			SetText(post.PostMatter.Date.Format("2006-01-02"))
-		feed.AppendSelection(entry)
-	}
-
-	return renderHTML(doc), nil
-}
-
-func renderHomepage(config config.Config, posts []Post) (io.Reader, error) {
-	_, index, err := getPost("content/_index.md")
-	if err != nil {
-		return nil, err
-	}
-	doc, err := layout("templates/homepage.html", config, config.Title)
-	if err != nil {
-		return nil, err
-	}
-	doc.Find("body").AddClass("h-card")
-	doc.Find(".title").AddClass("p-name u-url")
-	var buf bytes.Buffer
-
-	md := goldmark.New(goldmark.WithRendererOptions(htmlrenderer.WithUnsafe()))
-	if err := md.Convert(*index, &buf); err != nil {
-		return nil, err
-	}
-	doc.Find("#content").SetHtml(buf.String())
-
-	feed := doc.Find(".h-feed")
-	tpl := feed.Find(".h-entry")
-	tpl.Remove()
-
-	for _, post := range posts[0:3] {
-		entry := tpl.Clone()
-		entry.Find(".p-name").SetText(post.Title)
-		entry.Find(".u-url").SetAttr("href", post.URL)
-		entry.
-			Find(".dt-published").
-			SetAttr("datetime", post.PostMatter.Date.UTC().Format(time.RFC3339)).
-			SetText(post.PostMatter.Date.Format("2006-01-02"))
-
-		feed.AppendSelection(entry)
-	}
-	doc.Find(".u-email").
-		SetAttr("href", fmt.Sprintf("mailto:%s", config.Email)).
-		SetText(config.Email)
-
-	elsewhere := doc.Find(".elsewhere")
-	linkRelMe := elsewhere.Find(".u-url[rel=me]").ParentsUntil("ul")
-	linkRelMe.Remove()
-
-	for _, link := range config.Menus["me"] {
-		el := linkRelMe.Clone()
-		el.Find("a").SetAttr("href", link.URL).SetText(link.Name)
-		elsewhere.AppendSelection(el)
-	}
-
-	return renderHTML(doc), nil
-}
-
-func render404(config config.Config) (io.Reader, error) {
-	doc, err := layout("templates/404.html", config, "404 Not Found")
-	if err != nil {
-		return nil, err
-	}
-	return renderHTML(doc), nil
-}
-
-func renderFeed(title string, config config.Config, posts []Post, specific string) (io.Reader, error) {
-	reader, err := os.Open("templates/feed.xml")
-	if err != nil {
-		return nil, err
-	}
-	defer reader.Close()
-	doc, err := xmlquery.Parse(reader)
-	feed := doc.SelectElement("feed")
-	feed.SelectElement("title").FirstChild.Data = title
-	feed.SelectElement("link").SetAttr("href", config.BaseURL.String())
-	feed.SelectElement("id").FirstChild.Data = atom.MakeTagURI(config, specific)
-	datetime, err := posts[0].Date.UTC().MarshalText()
-	feed.SelectElement("updated").FirstChild.Data = string(datetime)
-	tpl := feed.SelectElement("entry")
-	xmlquery.RemoveFromTree(tpl)
-
-	for _, post := range posts {
-		fullURL, err := url.JoinPath(config.BaseURL.String(), post.URL)
-		if err != nil {
-			return nil, err
-		}
-		text, err := xml.MarshalIndent(&atom.FeedEntry{
-			Title:   post.Title,
-			Link:    atom.MakeLink(fullURL),
-			Id:      atom.MakeTagURI(config, post.Basename),
-			Updated: post.Date.UTC(),
-			Summary: post.Description,
-			Author:  config.Title,
-			Content: atom.FeedContent{
-				Content: post.Content,
-				Type:    "html",
-			},
-		}, "  ", "    ")
-		if err != nil {
-			return nil, err
-		}
-		entry, err := xmlquery.ParseWithOptions(strings.NewReader(string(text)), xmlquery.ParserOptions{
-			Decoder: &xmlquery.DecoderOptions{
-				Strict:    false,
-				AutoClose: xml.HTMLAutoClose,
-				Entity:    xml.HTMLEntity,
-			},
-		})
-		if err != nil {
-			return nil, err
-		}
-		xmlquery.AddChild(feed, entry.SelectElement("entry"))
-	}
-
-	return strings.NewReader(doc.OutputXML(true)), nil
-}
-
-func renderFeedStyles() (io.Reader, error) {
-	reader, err := os.Open("templates/feed-styles.xsl")
-	if err != nil {
-		return nil, err
-	}
-	defer reader.Close()
-	nsMap := map[string]string{
-		"xsl":   "http://www.w3.org/1999/XSL/Transform",
-		"atom":  "http://www.w3.org/2005/Atom",
-		"xhtml": "http://www.w3.org/1999/xhtml",
-	}
-	doc, err := xmlquery.Parse(reader)
-	expr, err := xpath.CompileWithNS("//xhtml:style", nsMap)
-	if err != nil {
-		return nil, err
-	}
-	style := xmlquery.QuerySelector(doc, expr)
-	css, err := os.ReadFile("templates/style.css")
-	if err != nil {
-		return nil, err
-	}
-	xmlquery.AddChild(style, &xmlquery.Node{
-		Type: xmlquery.TextNode,
-		Data: string(css),
-	})
-	return strings.NewReader(doc.OutputXML(true)), nil
-}
-
 func mkdirp(dirs ...string) error {
 	return os.MkdirAll(path.Join(dirs...), 0755)
 }
@@ -539,28 +169,7 @@ type IOConfig struct {
 	BaseURL     config.URL
 }
 
-func main() {
-	if os.Getenv("DEBUG") != "" {
-		slog.SetLogLoggerLevel(slog.LevelDebug)
-	}
-	slog.Debug("starting build process")
-
-	ioConfig := IOConfig{}
-	if help, err := conf.Parse("", &ioConfig); err != nil {
-		if errors.Is(err, conf.ErrHelpWanted) {
-			fmt.Println(help)
-			os.Exit(1)
-		}
-		log.Panicf("parsing I/O configuration: %v", err)
-	}
-
-	if ioConfig.Source != "." {
-		err := os.Chdir(ioConfig.Source)
-		if err != nil {
-			log.Panic("could not change to source directory")
-		}
-	}
-
+func buildSite(ioConfig IOConfig) error {
 	config, err := config.GetConfig()
 	if err != nil {
 		log.Panic(errors.Errorf("could not get config: %v", err))
@@ -579,20 +188,9 @@ func main() {
 	}
 
 	if err := build(ioConfig.Destination, *config); err != nil {
-		switch cause := errors.Cause(err).(type) {
-		case *fs.PathError:
-			slog.Info("pathError")
-			slog.Error(fmt.Sprintf("%s", err))
-		case toml.ParseError:
-			slog.Info("parseError")
-			slog.Error(fmt.Sprintf("%s", err))
-		default:
-			slog.Info("other")
-			slog.Error(fmt.Sprintf("cause:%+v", errors.Cause(cause)))
-			slog.Error(fmt.Sprintf("%+v", cause))
-		}
-		os.Exit(1)
+		return err
 	}
 
 	slog.Debug("done")
+	return nil
 }
diff --git a/cmd/build/main.go b/cmd/build/main.go
new file mode 100644
index 0000000..9b6a79b
--- /dev/null
+++ b/cmd/build/main.go
@@ -0,0 +1,52 @@
+package main
+
+import (
+	"fmt"
+	"io/fs"
+	"log"
+	"log/slog"
+	"os"
+
+	"github.com/BurntSushi/toml"
+	"github.com/ardanlabs/conf/v3"
+	"github.com/pkg/errors"
+)
+
+func main() {
+	if os.Getenv("DEBUG") != "" {
+		slog.SetLogLoggerLevel(slog.LevelDebug)
+	}
+	slog.Debug("starting build process")
+
+	ioConfig := IOConfig{}
+	if help, err := conf.Parse("", &ioConfig); err != nil {
+		if errors.Is(err, conf.ErrHelpWanted) {
+			fmt.Println(help)
+			os.Exit(1)
+		}
+		log.Panicf("parsing I/O configuration: %v", err)
+	}
+
+	if ioConfig.Source != "." {
+		err := os.Chdir(ioConfig.Source)
+		if err != nil {
+			log.Panic("could not change to source directory")
+		}
+	}
+
+	if err := buildSite(ioConfig); err != nil {
+		switch cause := errors.Cause(err).(type) {
+		case *fs.PathError:
+			slog.Info("pathError")
+			slog.Error(fmt.Sprintf("%s", err))
+		case toml.ParseError:
+			slog.Info("parseError")
+			slog.Error(fmt.Sprintf("%s", err))
+		default:
+			slog.Info("other")
+			slog.Error(fmt.Sprintf("cause:%+v", errors.Cause(cause)))
+			slog.Error(fmt.Sprintf("%+v", cause))
+		}
+		os.Exit(1)
+	}
+}
diff --git a/cmd/build/posts.go b/cmd/build/posts.go
new file mode 100644
index 0000000..f03caf3
--- /dev/null
+++ b/cmd/build/posts.go
@@ -0,0 +1,121 @@
+package main
+
+import (
+	"bytes"
+	"log/slog"
+	"os"
+	"path"
+	"path/filepath"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/adrg/frontmatter"
+	mapset "github.com/deckarep/golang-set/v2"
+	"github.com/pkg/errors"
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/extension"
+	htmlrenderer "github.com/yuin/goldmark/renderer/html"
+)
+
+type PostMatter struct {
+	Date        time.Time `toml:"date"`
+	Description string    `toml:"description"`
+	Title       string    `toml:"title"`
+	Taxonomies  struct {
+		Tags []string `toml:"tags"`
+	} `toml:"taxonomies"`
+}
+
+type Post struct {
+	Input    string
+	Output   string
+	Basename string
+	URL      string
+	Content  string
+	PostMatter
+}
+
+type Tags mapset.Set[string]
+
+var markdown = goldmark.New(
+	goldmark.WithRendererOptions(
+		htmlrenderer.WithUnsafe(),
+	),
+	goldmark.WithExtensions(
+		extension.GFM,
+		extension.Footnote,
+		extension.Typographer,
+	),
+)
+
+func getPost(filename string) (*PostMatter, []byte, error) {
+	matter := PostMatter{}
+	content, err := os.Open(filename)
+	defer content.Close()
+	if err != nil {
+		return nil, nil, errors.WithMessagef(err, "could not open post %s", filename)
+	}
+	rest, err := frontmatter.MustParse(content, &matter)
+	if err != nil {
+		return nil, nil, errors.WithMessagef(err, "could not parse front matter of post %s", filename)
+	}
+
+	return &matter, rest, nil
+}
+
+func renderMarkdown(content []byte) (string, error) {
+	var buf bytes.Buffer
+	if err := markdown.Convert(content, &buf); err != nil {
+		return "", errors.WithMessage(err, "could not convert markdown content")
+	}
+	return buf.String(), nil
+}
+
+func readPosts(root string, inputDir string, outputDir string) ([]Post, Tags, error) {
+	tags := mapset.NewSet[string]()
+	posts := []Post{}
+	subdir := filepath.Join(root, inputDir)
+	files, err := os.ReadDir(subdir)
+	if err != nil {
+		return nil, nil, errors.WithMessagef(err, "could not read post directory %s", subdir)
+	}
+	outputReplacer := strings.NewReplacer(root, outputDir, ".md", "/index.html")
+	urlReplacer := strings.NewReplacer(root, "", ".md", "/")
+	for _, f := range files {
+		pathFromRoot := filepath.Join(subdir, f.Name())
+		if !f.IsDir() && path.Ext(pathFromRoot) == ".md" {
+			output := outputReplacer.Replace(pathFromRoot)
+			url := urlReplacer.Replace(pathFromRoot)
+			slog.Debug("reading post", "post", pathFromRoot)
+			matter, content, err := getPost(pathFromRoot)
+			if err != nil {
+				return nil, nil, err
+			}
+
+			for _, tag := range matter.Taxonomies.Tags {
+				tags.Add(strings.ToLower(tag))
+			}
+
+			slog.Debug("rendering markdown in post", "post", pathFromRoot)
+			html, err := renderMarkdown(content)
+			if err != nil {
+				return nil, nil, err
+			}
+			post := Post{
+				Input:      pathFromRoot,
+				Output:     output,
+				Basename:   filepath.Base(url),
+				URL:        url,
+				PostMatter: *matter,
+				Content:    html,
+			}
+
+			posts = append(posts, post)
+		}
+	}
+	slices.SortFunc(posts, func(a, b Post) int {
+		return b.Date.Compare(a.Date)
+	})
+	return posts, tags, nil
+}
diff --git a/cmd/build/template.go b/cmd/build/template.go
new file mode 100644
index 0000000..5ea1912
--- /dev/null
+++ b/cmd/build/template.go
@@ -0,0 +1,275 @@
+package main
+
+import (
+	"encoding/xml"
+	"fmt"
+	"io"
+	"log/slog"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+	"website/internal/atom"
+	"website/internal/config"
+
+	"github.com/PuerkitoBio/goquery"
+	"github.com/a-h/htmlformat"
+	"github.com/antchfx/xmlquery"
+	"github.com/antchfx/xpath"
+	mapset "github.com/deckarep/golang-set/v2"
+	"golang.org/x/net/html"
+)
+
+func layout(filename string, config config.Config, pageTitle string) (*goquery.Document, error) {
+	html, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer html.Close()
+	css, err := os.ReadFile("templates/style.css")
+	if err != nil {
+		return nil, err
+	}
+	doc, err := goquery.NewDocumentFromReader(html)
+	if err != nil {
+		return nil, err
+	}
+	doc.Find("html").SetAttr("lang", config.DefaultLanguage)
+	doc.Find("head > link[rel=alternate]").SetAttr("title", config.Title)
+	doc.Find(".title").SetText(config.Title)
+	doc.Find("title").Add(".p-name").SetText(pageTitle)
+	doc.Find("head > style").SetHtml("\n" + string(css))
+	nav := doc.Find("nav")
+	navLink := doc.Find("nav a")
+	nav.Empty()
+	for _, link := range config.Menus["main"] {
+		nav.AppendSelection(navLink.Clone().SetAttr("href", link.URL).SetText(link.Name))
+	}
+	return doc, nil
+}
+
+func renderPost(post Post, config config.Config) (r io.Reader, err error) {
+	doc, err := layout("templates/post.html", config, post.PostMatter.Title)
+	if err != nil {
+		return nil, err
+	}
+	doc.Find(".title").AddClass("p-author h-card").SetAttr("rel", "author")
+	doc.Find(".h-entry .dt-published").
+		SetAttr("datetime", post.PostMatter.Date.UTC().Format(time.RFC3339)).
+		SetText(
+			post.PostMatter.Date.Format("2006-01-02"),
+		)
+	doc.Find(".h-entry .e-content").SetHtml(post.Content)
+	categories := doc.Find(".h-entry .p-categories")
+	tpl := categories.Find(".p-category").ParentsUntilSelection(categories)
+	tpl.Remove()
+	for _, tag := range post.Taxonomies.Tags {
+		cat := tpl.Clone()
+		cat.Find(".p-category").SetAttr("href", fmt.Sprintf("/tags/%s/", tag)).SetText("#" + tag)
+		categories.AppendSelection(cat)
+	}
+
+	return renderHTML(doc), nil
+}
+
+func renderTags(tags Tags, config config.Config) (io.Reader, error) {
+	doc, err := layout("templates/tags.html", config, config.Title)
+	if err != nil {
+		return nil, err
+	}
+	tagList := doc.Find(".tags")
+	tpl := doc.Find(".h-feed")
+	tpl.Remove()
+	for _, tag := range mapset.Sorted(tags) {
+		li := tpl.Clone()
+		li.Find("a").SetAttr("href", fmt.Sprintf("/tags/%s/", tag)).SetText("#" + tag)
+		tagList.AppendSelection(li)
+	}
+	return renderHTML(doc), nil
+}
+
+func renderListPage(tag string, config config.Config, posts []Post) (io.Reader, error) {
+	var title string
+	if len(tag) > 0 {
+		title = tag
+	} else {
+		title = config.Title
+	}
+	doc, err := layout("templates/list.html", config, title)
+	if err != nil {
+		return nil, err
+	}
+	feed := doc.Find(".h-feed")
+	tpl := feed.Find(".h-entry")
+	tpl.Remove()
+
+	doc.Find(".title").AddClass("p-author h-card").SetAttr("rel", "author")
+	if tag == "" {
+		doc.Find(".filter").Remove()
+	} else {
+		doc.Find(".filter").Find("h3").SetText("#" + tag)
+	}
+
+	for _, post := range posts {
+		entry := tpl.Clone()
+		entry.Find(".p-name").SetText(post.Title).SetAttr("href", post.URL)
+		entry.Find(".dt-published").
+			SetAttr("datetime", post.PostMatter.Date.UTC().Format(time.RFC3339)).
+			SetText(post.PostMatter.Date.Format("2006-01-02"))
+		feed.AppendSelection(entry)
+	}
+
+	return renderHTML(doc), nil
+}
+
+func renderHomepage(config config.Config, posts []Post) (io.Reader, error) {
+	_, index, err := getPost("content/_index.md")
+	if err != nil {
+		return nil, err
+	}
+	doc, err := layout("templates/homepage.html", config, config.Title)
+	if err != nil {
+		return nil, err
+	}
+	doc.Find("body").AddClass("h-card")
+	doc.Find(".title").AddClass("p-name u-url")
+
+	html, err := renderMarkdown(index)
+	doc.Find("#content").SetHtml(html)
+
+	feed := doc.Find(".h-feed")
+	tpl := feed.Find(".h-entry")
+	tpl.Remove()
+
+	for _, post := range posts[0:3] {
+		entry := tpl.Clone()
+		entry.Find(".p-name").SetText(post.Title)
+		entry.Find(".u-url").SetAttr("href", post.URL)
+		entry.
+			Find(".dt-published").
+			SetAttr("datetime", post.PostMatter.Date.UTC().Format(time.RFC3339)).
+			SetText(post.PostMatter.Date.Format("2006-01-02"))
+
+		feed.AppendSelection(entry)
+	}
+	doc.Find(".u-email").
+		SetAttr("href", fmt.Sprintf("mailto:%s", config.Email)).
+		SetText(config.Email)
+
+	elsewhere := doc.Find(".elsewhere")
+	linkRelMe := elsewhere.Find(".u-url[rel=me]").ParentsUntil("ul")
+	linkRelMe.Remove()
+
+	for _, link := range config.Menus["me"] {
+		el := linkRelMe.Clone()
+		el.Find("a").SetAttr("href", link.URL).SetText(link.Name)
+		elsewhere.AppendSelection(el)
+	}
+
+	return renderHTML(doc), nil
+}
+
+func render404(config config.Config) (io.Reader, error) {
+	doc, err := layout("templates/404.html", config, "404 Not Found")
+	if err != nil {
+		return nil, err
+	}
+	return renderHTML(doc), nil
+}
+
+func renderFeed(title string, config config.Config, posts []Post, specific string) (io.Reader, error) {
+	reader, err := os.Open("templates/feed.xml")
+	if err != nil {
+		return nil, err
+	}
+	defer reader.Close()
+	doc, err := xmlquery.Parse(reader)
+	feed := doc.SelectElement("feed")
+	feed.SelectElement("title").FirstChild.Data = title
+	feed.SelectElement("link").SetAttr("href", config.BaseURL.String())
+	feed.SelectElement("id").FirstChild.Data = atom.MakeTagURI(config, specific)
+	datetime, err := posts[0].Date.UTC().MarshalText()
+	feed.SelectElement("updated").FirstChild.Data = string(datetime)
+	tpl := feed.SelectElement("entry")
+	xmlquery.RemoveFromTree(tpl)
+
+	for _, post := range posts {
+		fullURL, err := url.JoinPath(config.BaseURL.String(), post.URL)
+		if err != nil {
+			return nil, err
+		}
+		text, err := xml.MarshalIndent(&atom.FeedEntry{
+			Title:   post.Title,
+			Link:    atom.MakeLink(fullURL),
+			Id:      atom.MakeTagURI(config, post.Basename),
+			Updated: post.Date.UTC(),
+			Summary: post.Description,
+			Author:  config.Title,
+			Content: atom.FeedContent{
+				Content: post.Content,
+				Type:    "html",
+			},
+		}, "  ", "    ")
+		if err != nil {
+			return nil, err
+		}
+		entry, err := xmlquery.ParseWithOptions(strings.NewReader(string(text)), xmlquery.ParserOptions{
+			Decoder: &xmlquery.DecoderOptions{
+				Strict:    false,
+				AutoClose: xml.HTMLAutoClose,
+				Entity:    xml.HTMLEntity,
+			},
+		})
+		if err != nil {
+			return nil, err
+		}
+		xmlquery.AddChild(feed, entry.SelectElement("entry"))
+	}
+
+	return strings.NewReader(doc.OutputXML(true)), nil
+}
+
+func renderFeedStyles() (io.Reader, error) {
+	reader, err := os.Open("templates/feed-styles.xsl")
+	if err != nil {
+		return nil, err
+	}
+	defer reader.Close()
+	nsMap := map[string]string{
+		"xsl":   "http://www.w3.org/1999/XSL/Transform",
+		"atom":  "http://www.w3.org/2005/Atom",
+		"xhtml": "http://www.w3.org/1999/xhtml",
+	}
+	doc, err := xmlquery.Parse(reader)
+	expr, err := xpath.CompileWithNS("//xhtml:style", nsMap)
+	if err != nil {
+		return nil, err
+	}
+	style := xmlquery.QuerySelector(doc, expr)
+	css, err := os.ReadFile("templates/style.css")
+	if err != nil {
+		return nil, err
+	}
+	xmlquery.AddChild(style, &xmlquery.Node{
+		Type: xmlquery.TextNode,
+		Data: string(css),
+	})
+	return strings.NewReader(doc.OutputXML(true)), nil
+}
+
+func renderHTML(doc *goquery.Document) io.Reader {
+	r, w := io.Pipe()
+
+	// TODO: return errors to main thread
+	go func() {
+		w.Write([]byte("<!doctype html>\n"))
+		err := htmlformat.Nodes(w, []*html.Node{doc.Children().Get(0)})
+		if err != nil {
+			slog.Error("error rendering html", "error", err)
+			w.CloseWithError(err)
+			return
+		}
+		defer w.Close()
+	}()
+	return r
+}
diff --git a/cmd/server/filemap.go b/cmd/server/filemap.go
new file mode 100644
index 0000000..5f7e1bb
--- /dev/null
+++ b/cmd/server/filemap.go
@@ -0,0 +1,77 @@
+package main
+
+import (
+	"fmt"
+	"hash/fnv"
+	"io"
+	"io/fs"
+	"log"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+type File struct {
+	filename string
+	etag     string
+}
+
+var files = map[string]File{}
+
+func hashFile(filename string) (string, error) {
+	f, err := os.Open(filename)
+	if err != nil {
+		return "", err
+	}
+	defer f.Close()
+	hash := fnv.New64a()
+	if _, err := io.Copy(hash, f); err != nil {
+		return "", err
+	}
+	return fmt.Sprintf(`W/"%x"`, hash.Sum(nil)), nil
+}
+
+func registerFile(urlpath string, filepath string) error {
+	if files[urlpath] != (File{}) {
+		log.Printf("registerFile called with duplicate file, urlPath: %s", urlpath)
+		return nil
+	}
+	hash, err := hashFile(filepath)
+	if err != nil {
+		return err
+	}
+	files[urlpath] = File{
+		filename: filepath,
+		etag:     hash,
+	}
+	return nil
+}
+
+func registerContentFiles(root string) error {
+	err := filepath.WalkDir(root, func(filePath string, f fs.DirEntry, err error) error {
+		if err != nil {
+			return errors.WithMessagef(err, "failed to access path %s", filePath)
+		}
+		relPath, err := filepath.Rel(root, filePath)
+		if err != nil {
+			return errors.WithMessagef(err, "failed to make path relative, path: %s", filePath)
+		}
+		urlPath, _ := strings.CutSuffix(relPath, "index.html")
+		if !f.IsDir() {
+			slog.Debug("registering file", "urlpath", "/"+urlPath)
+			return registerFile("/"+urlPath, filePath)
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetFile(urlPath string) File {
+	return files[urlPath]
+}
diff --git a/cmd/server/logging.go b/cmd/server/logging.go
new file mode 100644
index 0000000..601baab
--- /dev/null
+++ b/cmd/server/logging.go
@@ -0,0 +1,55 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+)
+
+type loggingResponseWriter struct {
+	http.ResponseWriter
+	statusCode int
+}
+
+func (lrw *loggingResponseWriter) WriteHeader(code int) {
+	lrw.statusCode = code
+	// avoids warning: superfluous response.WriteHeader call
+	if lrw.statusCode != http.StatusOK {
+		lrw.ResponseWriter.WriteHeader(code)
+	}
+}
+
+func NewLoggingResponseWriter(w http.ResponseWriter) *loggingResponseWriter {
+	return &loggingResponseWriter{w, http.StatusOK}
+}
+
+type wrappedHandlerOptions struct {
+	defaultHostname string
+	logger          io.Writer
+}
+
+func wrapHandlerWithLogging(wrappedHandler http.Handler, opts wrappedHandlerOptions) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		scheme := r.Header.Get("X-Forwarded-Proto")
+		if scheme == "" {
+			scheme = "http"
+		}
+		host := r.Header.Get("Host")
+		if host == "" {
+			host = opts.defaultHostname
+		}
+		lw := NewLoggingResponseWriter(w)
+		wrappedHandler.ServeHTTP(lw, r)
+		statusCode := lw.statusCode
+		fmt.Fprintf(
+			opts.logger,
+			"%s %s %d %s %s %s\n",
+			scheme,
+			r.Method,
+			statusCode,
+			host,
+			r.URL.Path,
+			lw.Header().Get("Location"),
+		)
+	})
+}
diff --git a/cmd/server/main.go b/cmd/server/main.go
new file mode 100644
index 0000000..9fb9f14
--- /dev/null
+++ b/cmd/server/main.go
@@ -0,0 +1,38 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"log/slog"
+	"os"
+	cfg "website/internal/config"
+
+	"github.com/ardanlabs/conf/v3"
+	"github.com/pkg/errors"
+)
+
+type Config struct {
+	Production             bool    `conf:"default:false"`
+	ListenAddress          string  `conf:"default:localhost"`
+	Port                   uint16  `conf:"default:3000,short:p"`
+	BaseURL                cfg.URL `conf:"default:http://localhost:3000,short:b"`
+	RedirectOtherHostnames bool    `conf:"default:false"`
+}
+
+func main() {
+	if os.Getenv("DEBUG") != "" {
+		slog.SetLogLoggerLevel(slog.LevelDebug)
+	}
+
+	runtimeConfig := Config{}
+	help, err := conf.Parse("", &runtimeConfig)
+	if err != nil {
+		if errors.Is(err, conf.ErrHelpWanted) {
+			fmt.Println(help)
+			os.Exit(1)
+		}
+		log.Panicf("parsing runtime configuration: %v", err)
+	}
+
+	startServer(&runtimeConfig)
+}
diff --git a/cmd/server/server.go b/cmd/server/server.go
index 9c9911a..10144bb 100644
--- a/cmd/server/server.go
+++ b/cmd/server/server.go
@@ -2,98 +2,27 @@ package main
 
 import (
 	"fmt"
-	"hash/fnv"
 	"io"
-	"io/fs"
 	"log"
 	"log/slog"
 	"mime"
 	"net"
 	"net/http"
 	"os"
-	"path/filepath"
 	"strings"
 	"time"
 
 	cfg "website/internal/config"
 
-	"github.com/ardanlabs/conf/v3"
 	"github.com/getsentry/sentry-go"
 	sentryhttp "github.com/getsentry/sentry-go/http"
-	"github.com/pkg/errors"
 	"github.com/shengyanli1982/law"
 )
 
-type Config struct {
-	Production             bool    `conf:"default:false"`
-	ListenAddress          string  `conf:"default:localhost"`
-	Port                   uint16  `conf:"default:3000,short:p"`
-	BaseURL                cfg.URL `conf:"default:http://localhost:3000,short:b"`
-	RedirectOtherHostnames bool    `conf:"default:false"`
-}
-
 var Commit string
 
 var config *cfg.Config
 
-type File struct {
-	filename string
-	etag     string
-}
-
-var files = map[string]File{}
-
-func hashFile(filename string) (string, error) {
-	f, err := os.Open(filename)
-	if err != nil {
-		return "", err
-	}
-	defer f.Close()
-	hash := fnv.New64a()
-	if _, err := io.Copy(hash, f); err != nil {
-		return "", err
-	}
-	return fmt.Sprintf(`W/"%x"`, hash.Sum(nil)), nil
-}
-
-func registerFile(urlpath string, filepath string) error {
-	if files[urlpath] != (File{}) {
-		log.Printf("registerFile called with duplicate file, urlPath: %s", urlpath)
-		return nil
-	}
-	hash, err := hashFile(filepath)
-	if err != nil {
-		return err
-	}
-	files[urlpath] = File{
-		filename: filepath,
-		etag:     hash,
-	}
-	return nil
-}
-
-func registerContentFiles(root string) error {
-	err := filepath.WalkDir(root, func(filePath string, f fs.DirEntry, err error) error {
-		if err != nil {
-			return errors.WithMessagef(err, "failed to access path %s", filePath)
-		}
-		relPath, err := filepath.Rel(root, filePath)
-		if err != nil {
-			return errors.WithMessagef(err, "failed to make path relative, path: %s", filePath)
-		}
-		urlPath, _ := strings.CutSuffix(relPath, "index.html")
-		if !f.IsDir() {
-			slog.Debug("registering file", "urlpath", "/"+urlPath)
-			return registerFile("/"+urlPath, filePath)
-		}
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
 type HTTPError struct {
 	Error   error
 	Message string
@@ -116,7 +45,7 @@ func serveFile(w http.ResponseWriter, r *http.Request) *HTTPError {
 		http.Redirect(w, r, urlPath, 302)
 		return nil
 	}
-	file := files[urlPath]
+	file := GetFile(urlPath)
 	if file == (File{}) {
 		return &HTTPError{
 			Message: "File not found",
@@ -166,81 +95,14 @@ func fixupMIMETypes() {
 	}
 }
 
-type loggingResponseWriter struct {
-	http.ResponseWriter
-	statusCode int
-}
-
-func (lrw *loggingResponseWriter) WriteHeader(code int) {
-	lrw.statusCode = code
-	// avoids warning: superfluous response.WriteHeader call
-	if lrw.statusCode != http.StatusOK {
-		lrw.ResponseWriter.WriteHeader(code)
-	}
-}
-
-func NewLoggingResponseWriter(w http.ResponseWriter) *loggingResponseWriter {
-	return &loggingResponseWriter{w, http.StatusOK}
-}
-
-type wrappedHandlerOptions struct {
-	defaultHostname string
-	logger          io.Writer
-}
-
-func wrapHandlerWithLogging(wrappedHandler http.Handler, opts wrappedHandlerOptions) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		scheme := r.Header.Get("X-Forwarded-Proto")
-		if scheme == "" {
-			scheme = "http"
-		}
-		host := r.Header.Get("Host")
-		if host == "" {
-			host = opts.defaultHostname
-		}
-		lw := NewLoggingResponseWriter(w)
-		wrappedHandler.ServeHTTP(lw, r)
-		statusCode := lw.statusCode
-		fmt.Fprintf(
-			opts.logger,
-			"%s %s %d %s %s %s\n",
-			scheme,
-			r.Method,
-			statusCode,
-			host,
-			r.URL.Path,
-			lw.Header().Get("Location"),
-		)
-	})
-}
-
-func main() {
-	if os.Getenv("DEBUG") != "" {
-		slog.SetLogLoggerLevel(slog.LevelDebug)
-	}
-
+func startServer(runtimeConfig *Config) {
 	fixupMIMETypes()
 
-	runtimeConfig := Config{}
-	help, err := conf.Parse("", &runtimeConfig)
-	if err != nil {
-		if errors.Is(err, conf.ErrHelpWanted) {
-			fmt.Println(help)
-			os.Exit(1)
-		}
-		log.Panicf("parsing runtime configuration: %v", err)
-	}
-
-	config, err = cfg.GetConfig()
+	c, err := cfg.GetConfig()
 	if err != nil {
 		log.Panicf("parsing configuration file: %v", err)
 	}
-
-	cwd, err := os.Getwd()
-	if err != nil {
-		log.Panicf("don't know where I am")
-	}
-	slog.Debug("starting at", "wd", cwd)
+	config = c
 
 	prefix := "website/public"
 	slog.Debug("registering content files", "prefix", prefix)
generated by cgit-pink 1.4.1 (git 2.36.1) at 2024-11-22 04:24:12 +0000