prime8dev

renderer.go (5887B)

---

 package web
 
 import (
 	"crypto/sha256"
 	"embed"
 	"encoding/hex"
 	"fmt"
 	"html/template"
 	"io/fs"
 	"os"
 	"path"
 	"path/filepath"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
 
 	"git.prime8.dev/moncheeta/prime8dev/internal/config"
 	"git.prime8.dev/moncheeta/prime8dev/internal/utils"
 	"git.prime8.dev/moncheeta/prime8dev/internal/vfs"
 )
 
 //go:embed templates/*.gohtml templates/partials/*.gohtml styles/*.css
 var templatesFS embed.FS
 
 type Data struct {
 	Title                string
 	Path                 string
 	Description          string
 	ActiveTab            string
 	ContentTemplate      string
 	About                config.About
 	Uptime               string
 	Experience           []config.Experience
 	SelectedExperienceID string
 	CurrentJob           *config.Experience
 	Projects             []config.Project
 	SelectedProjectID    string
 	Project              *config.Project
 	ProjectReadme        template.HTML
 	Tabs                 []Tab
 	SiteURL              string
 }
 
 type Tab struct {
 	ID    string
 	Label string
 	Num   int
 }
 
 type Renderer struct {
 	tpl *template.Template
 }
 
 // StaticDir is where the server serves /static/ from (relative to the working
 // directory, /app in the Docker image). assetVersion hashes files from here.
 var StaticDir = "static"
 
 // assetVersions caches one content hash per static file for the life of the
 // process. Static files only change on deploy, which restarts the server.
 var (
 	assetVersionsMu sync.Mutex
 	assetVersions   = map[string]string{}
 	startupVersion  = strconv.FormatInt(time.Now().Unix(), 36)
 )
 
 // AssetVersion returns a short content hash of static/<name>, for cache
 // busting: /static/app.js?v=<hash>. If the file can't be read (e.g. tests run
 // from another directory) it falls back to the process start time, which
 // still changes on every deploy.
 func AssetVersion(name string) string {
 	assetVersionsMu.Lock()
 	defer assetVersionsMu.Unlock()
 	if v, ok := assetVersions[name]; ok {
 		return v
 	}
 	v := startupVersion
 	if b, err := os.ReadFile(filepath.Join(StaticDir, filepath.FromSlash(path.Clean("/"+name)))); err == nil {
 		sum := sha256.Sum256(b)
 		v = hex.EncodeToString(sum[:])[:12]
 	}
 	assetVersions[name] = v
 	return v
 }
 
 func New() (*Renderer, error) {
 	inlineStyles, err := loadInlineStyles()
 	if err != nil {
 		return nil, err
 	}
 
 	funcs := template.FuncMap{
 		"tabPath":        utils.TabPath,
 		"tabURL":         utils.TabURL,
 		"tagClass":       utils.TagClass,
 		"tagColor":       func(label string) template.CSS { return template.CSS(utils.TagColor(label)) },
 		"shellPath":      ShellPath,
 		"windowTitle":    func(p string) string { return utils.WindowTitle(ShellPath(p)) },
 		"shellUser":      func() string { return vfs.FallbackUser },
 		"tagCSS":         func() template.CSS { return template.CSS(utils.TagCSS()) },
 		"inc":            func(i int) int { return i + 1 },
 		"techMeta":       utils.TechMeta,
 		"shortMonthYear": utils.FormatShortMonthYear,
 		"shortEndDate":   utils.FormatShortEndDate,
 		"formatRange":    utils.FormatRange,
 		"shortDuration":  utils.FormatDurationShort,
 		"monthStamp":     utils.MonthStamp,
 		"endStamp":       utils.EndStamp,
 		"experienceAxis": experienceAxis,
 		"pct":            func(f float64) string { return strconv.FormatFloat(f*100, 'f', 3, 64) + "%" },
 		"toHTML":         toHTML,
 		"assetVersion":   AssetVersion,
 		"gitCloneURL":    config.GitCloneURL,
 		"gitSSHCloneURL": config.GitSSHCloneURL,
 		"wakaTimeUser":   func() string { return config.WakaTimeUser },
 		"inlineCSS": func(name string) template.CSS {
 			if css, ok := inlineStyles[name]; ok {
 				return css
 			}
 			return ""
 		},
 	}
 
 	// hash the bundle once at startup rather than on the first request
 	AssetVersion("app.js")
 
 	tpl, err := template.New("site").Funcs(funcs).ParseFS(templatesFS, "templates/*.gohtml", "templates/partials/*.gohtml")
 	if err != nil {
 		return nil, fmt.Errorf("parse templates: %w", err)
 	}
 
 	return &Renderer{tpl: tpl}, nil
 }
 
 func (r *Renderer) Render(name string, data Data) (string, error) {
 	var b strings.Builder
 	if err := r.tpl.ExecuteTemplate(&b, name, data); err != nil {
 		return "", err
 	}
 	return b.String(), nil
 }
 
 func DefaultTabs() []Tab {
 	return []Tab{
 		{ID: "about", Label: "About", Num: 1},
 		{ID: "experience", Label: "Experience", Num: 2},
 		{ID: "projects", Label: "Projects", Num: 3},
 	}
 }
 
 func BaseData(title, activeTab string, about config.About) Data {
 	return Data{
 		Title:           title,
 		Description:     fmt.Sprintf("Portfolio of %s", about.Name),
 		ActiveTab:       activeTab,
 		ContentTemplate: activeTab,
 		About:           about,
 		Uptime:          utils.Uptime(config.Birthday, time.Now()),
 		Tabs:            DefaultTabs(),
 		SiteURL:         config.SiteURL,
 	}
 }
 
 func toHTML(s string) template.HTML {
 	return template.HTML(s)
 }
 
 func loadInlineStyles() (map[string]template.CSS, error) {
 	entries, err := fs.ReadDir(templatesFS, "styles")
 	if err != nil {
 		return nil, fmt.Errorf("read styles: %w", err)
 	}
 
 	styles := make(map[string]template.CSS, len(entries))
 	for _, entry := range entries {
 		if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".css") {
 			continue
 		}
 
 		stylePath := path.Join("styles", entry.Name())
 		content, err := templatesFS.ReadFile(stylePath)
 		if err != nil {
 			return nil, fmt.Errorf("read style %s: %w", entry.Name(), err)
 		}
 
 		styles[entry.Name()] = template.CSS(string(content))
 	}
 
 	return styles, nil
 }
 
 // ShellPath renders a URL path the way a shell prompt shows cwd: "/" is "~".
 func ShellPath(path string) string {
 	return "~" + strings.TrimRight(path, "/")
 }
 
 // experienceAxis lays every role on one month axis for the timeline strip.
 func experienceAxis(exps []config.Experience) utils.Axis {
 	spans := make([]utils.Span, len(exps))
 	for i, e := range exps {
 		spans[i] = utils.Span{Start: e.StartDate, End: e.EndDate, Current: e.Current}
 	}
 	return utils.NewAxis(spans)
 }