Experimental: use map[string]any for post Meta

atom/feed.go

···
 	"path/filepath"
 	"time"
 
-	"git.icyphox.sh/vite/config"
-	"git.icyphox.sh/vite/types"
+	"tangled.sh/icyphox.sh/vite/config"
+	"tangled.sh/icyphox.sh/vite/types"
 )
 
 type AtomLink struct {
···
 	entries := []AtomEntry{}
 
 	for _, p := range posts {
-		dateStr := p.Meta["date"]
+		dateStr := p.Meta["date"].(string)
 		date, err := time.Parse("2006-01-02", dateStr)
 		if err != nil {
 			return nil, err
···
 		rfc3339 := date.Format(time.RFC3339)
 
 		entry := AtomEntry{
-			Title:   p.Meta["title"],
+			Title:   p.Meta["title"].(string),
 			Updated: rfc3339,
 			// tag:icyphox.sh,2019-10-23:blog/some-post/
 			ID: fmt.Sprintf(
 				"tag:%s,%s:%s",
 				config.Config.URL[8:], // strip https://
 				dateStr,
-				filepath.Join(srcDir, p.Meta["slug"]),
+				filepath.Join(srcDir, p.Meta["slug"].(string)),
 			),
 			// filepath.Join strips the second / in http://
-			Link: &AtomLink{Href: config.Config.URL + filepath.Join(srcDir, p.Meta["slug"])},
+			Link: &AtomLink{Href: config.Config.URL + filepath.Join(srcDir, p.Meta["slug"].(string))},
 			Summary: &AtomSummary{
 				Content: fmt.Sprintf("<h2>%s</h2>\n%s",
-					p.Meta["subtitle"],
+					p.Meta["subtitle"].(string),
 					string(p.Body)),
 				Type: "html",
 			},

commands/build.go

···
 	"strings"
 	"time"
 
-	"git.icyphox.sh/vite/atom"
-	"git.icyphox.sh/vite/config"
-	"git.icyphox.sh/vite/formats"
-	"git.icyphox.sh/vite/formats/markdown"
-	"git.icyphox.sh/vite/formats/yaml"
-	"git.icyphox.sh/vite/types"
-	"git.icyphox.sh/vite/util"
+	"tangled.sh/icyphox.sh/vite/atom"
+	"tangled.sh/icyphox.sh/vite/config"
+	"tangled.sh/icyphox.sh/vite/formats"
+	"tangled.sh/icyphox.sh/vite/formats/markdown"
+	"tangled.sh/icyphox.sh/vite/formats/yaml"
+	"tangled.sh/icyphox.sh/vite/types"
+	"tangled.sh/icyphox.sh/vite/util"
 )
 
 type Dir struct {
···
 
 			// Copy the post to the root if it's marked as such.
 			// ex: build/blog/foo-bar -> build/foo-bar
-			if post.Meta["atroot"] == "true" {
+			if post.Meta["atroot"].(bool) {
 				os.Mkdir(filepath.Join(types.BuildDir, slug), 0755)
 				df := filepath.Join(types.BuildDir, slug+".html")
 				util.CopyFile(filepath.Join(dstDir, slug, "index.html"), df)
···
 		}
 
 		sort.Slice(posts, func(i, j int) bool {
-			dateStr1 := posts[j].Meta["date"]
-			dateStr2 := posts[i].Meta["date"]
+			dateStr1 := posts[j].Meta["date"].(string)
+			dateStr2 := posts[i].Meta["date"].(string)
 			date1, _ := time.Parse("2006-01-02", dateStr1)
 			date2, _ := time.Parse("2006-01-02", dateStr2)
 			return date1.Before(date2)

formats/anything.go

···
 import (
 	"path/filepath"
 
-	"git.icyphox.sh/vite/util"
+	"tangled.sh/icyphox.sh/vite/util"
 )
 
 // Anything is a stub format for unrecognized files
 type Anything struct{ Path string }
 
-func (Anything) Ext() string                    { return "" }
-func (Anything) Frontmatter() map[string]string { return nil }
-func (Anything) Body() string                   { return "" }
-func (a Anything) Basename() string             { return filepath.Base(a.Path) }
+func (Anything) Ext() string                 { return "" }
+func (Anything) Frontmatter() map[string]any { return nil }
+func (Anything) Body() string                { return "" }
+func (a Anything) Basename() string          { return filepath.Base(a.Path) }
 
 func (a Anything) Render(dest string, data interface{}, drafts bool) error {
 	return util.CopyFile(a.Path, dest)

formats/markdown/markdown.go

···
 	gotmpl "text/template"
 	"time"
 
-	"git.icyphox.sh/vite/config"
-	"git.icyphox.sh/vite/template"
-	"git.icyphox.sh/vite/types"
 	"github.com/adrg/frontmatter"
+	"tangled.sh/icyphox.sh/vite/config"
+	"tangled.sh/icyphox.sh/vite/template"
+	"tangled.sh/icyphox.sh/vite/types"
 
 	bf "git.icyphox.sh/grayfriday"
 )
···
 
 type Markdown struct {
 	body        []byte
-	frontmatter map[string]string
+	frontmatter map[string]any
 	Path        string
 }
 
···
 // template checks the frontmatter for a specified template or falls back
 // to the default template -- to which it, well, templates whatever is in
 // data and writes it to dest.
-func (md *Markdown) template(dest, tmplDir string, data interface{}) error {
-	metaTemplate := md.frontmatter["template"]
-	if metaTemplate == "" {
+func (md *Markdown) template(dest, tmplDir string, data any) error {
+	metaTemplate, ok := md.frontmatter["template"].(string)
+	if !ok || metaTemplate == "" {
 		metaTemplate = config.Config.DefaultTemplate
 	}
 
···
 	return nil
 }
 
-func (md *Markdown) Frontmatter() map[string]string {
+func (md *Markdown) Frontmatter() map[string]any {
 	return md.frontmatter
 }
 
···
 
 type templateData struct {
 	Cfg   config.ConfigYaml
-	Meta  map[string]string
+	Meta  map[string]any
 	Body  string
-	Extra interface{}
+	Extra any
 }
 
-func (md *Markdown) Render(dest string, data interface{}, drafts bool) error {
+func (md *Markdown) Render(dest string, data any, drafts bool) error {
 	source, err := os.ReadFile(md.Path)
 	if err != nil {
 		return fmt.Errorf("markdown: error reading file: %w", err)
···
 		return fmt.Errorf("markdown: error extracting frontmatter: %w", err)
 	}
 
-	if md.frontmatter["draft"] == "true" {
+	isDraft, ok := md.frontmatter["draft"].(bool)
+	if ok && isDraft {
 		if !drafts {
 			fmt.Printf("vite: skipping draft %s\n", md.Path)
 			return nil

formats/yaml/yaml.go

···
 	gotmpl "text/template"
 	"time"
 
-	"git.icyphox.sh/vite/config"
-	"git.icyphox.sh/vite/template"
-	"git.icyphox.sh/vite/types"
 	"gopkg.in/yaml.v3"
+	"tangled.sh/icyphox.sh/vite/config"
+	"tangled.sh/icyphox.sh/vite/template"
+	"tangled.sh/icyphox.sh/vite/types"
 )
 
 type YAML struct {
 	Path string
 
-	meta map[string]string
+	meta map[string]any
 }
 
 func (*YAML) Ext() string        { return ".yaml" }
 func (*YAML) Body() string       { return "" }
 func (y *YAML) Basename() string { return filepath.Base(y.Path) }
 
-func (y *YAML) Frontmatter() map[string]string {
+func (y *YAML) Frontmatter() map[string]any {
 	return y.meta
 }
 
 type templateData struct {
 	Cfg  config.ConfigYaml
-	Meta map[string]string
-	Yaml map[string]interface{}
+	Meta map[string]any
+	Yaml map[string]any
 	Body string
 }
 
-func (y *YAML) template(dest, tmplDir string, data interface{}) error {
-	metaTemplate := y.meta["template"]
+func (y *YAML) template(dest, tmplDir string, data any) error {
+	var metaTemplate string
+	if templateVal, ok := y.meta["template"]; ok {
+		if strVal, isStr := templateVal.(string); isStr {
+			metaTemplate = strVal
+		}
+	}
 	if metaTemplate == "" {
 		metaTemplate = config.Config.DefaultTemplate
 	}
···
 	return tmpl.Write(dest, metaTemplate, data)
 }
 
-func (y *YAML) Render(dest string, data interface{}, drafts bool) error {
+func (y *YAML) Render(dest string, data any, drafts bool) error {
 	yamlBytes, err := os.ReadFile(y.Path)
 	if err != nil {
 		return fmt.Errorf("yaml: failed to read file: %s: %w", y.Path, err)
 	}
 
-	yamlData := map[string]interface{}{}
+	yamlData := map[string]any{}
 	err = yaml.Unmarshal(yamlBytes, yamlData)
 	if err != nil {
 		return fmt.Errorf("yaml: failed to unmarshal yaml file: %s: %w", y.Path, err)
 	}
 
-	metaInterface := yamlData["meta"].(map[string]interface{})
-
-	meta := make(map[string]string)
-	for k, v := range metaInterface {
-		vStr := convertToString(v)
-		meta[k] = vStr
+	metaInterface, ok := yamlData["meta"].(map[string]any)
+	if !ok {
+		return fmt.Errorf("yaml: meta section is not a map: %s", y.Path)
 	}
 
-	y.meta = meta
+	y.meta = metaInterface
 
 	err = y.template(dest, types.TemplatesDir, templateData{
 		config.Config,
···
 	return nil
 }
 
-func convertToString(value interface{}) string {
+func convertToString(value any) string {
 	// Infer type and convert to string
 	switch v := value.(type) {
 	case string:

go.mod

···
-module git.icyphox.sh/vite
+module tangled.sh/icyphox.sh/vite
 
 go 1.21
 

main.go

···
 	"fmt"
 	"os"
 
-	"git.icyphox.sh/vite/commands"
+	"tangled.sh/icyphox.sh/vite/commands"
 )
 
 func main() {

types/types.go

···
 	Render(dest string, data interface{}, drafts bool) error
 
 	// Frontmatter will not be populated if Render hasn't been called.
-	Frontmatter() map[string]string
+	Frontmatter() map[string]any
 	// Body will not be populated if Render hasn't been called.
 	Body() string
 	Basename() string
···
 
 // Only used for building indexes and Atom feeds
 type Post struct {
-	Meta map[string]string
+	Meta map[string]any
 	// HTML-formatted body of post
 	Body string
 }