go
/
ssgod
1
0
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

Forgot the go fmt.

Browse Source
master
Zed A. Shaw 3 days ago
parent e10cc57bec
commit 0df151c7e4
1 changed files with 309 additions and 303 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 612
      main.go

612
main.go
Unescape View File

@ -1,414 +1,420 @@
package main package main
import ( import (
"bytes" "bytes"
"flag" _ "embed"
"fmt" "flag"
"github.com/fsnotify/fsnotify" "fmt"
"github.com/yuin/goldmark" "github.com/fsnotify/fsnotify"
"io" "github.com/yuin/goldmark"
"io/fs" "io"
"lcthw.dev/go/ssgod/config" "io/fs"
"log" "lcthw.dev/go/ssgod/config"
"os" "log"
"path/filepath" "os"
"strings" "path/filepath"
"text/template" "strings"
"time" "text/template"
_ "embed" "time"
) )
//go:embed example/.ssgod.json //go:embed example/.ssgod.json
var DEFAULT_CONFIG string var DEFAULT_CONFIG string
type PageMetaData struct { type PageMetaData struct {
pages []string pages []string
} }
func (meta *PageMetaData) AddPage(path string) { func (meta *PageMetaData) AddPage(path string) {
path = RePrefixPath(path, "/") path = RePrefixPath(path, "/")
path = filepath.ToSlash(path) path = filepath.ToSlash(path)
meta.pages = append(meta.pages, path) meta.pages = append(meta.pages, path)
} }
func Fatal(err error, format string, v ...any) { func Fatal(err error, format string, v ...any) {
err_format := fmt.Sprintf("ERROR: %v; %s", err, format) err_format := fmt.Sprintf("ERROR: %v; %s", err, format)
panic(fmt.Sprintf(err_format, v...)) panic(fmt.Sprintf(err_format, v...))
} }
func Fail(err error, format string, v ...any) error { func Fail(err error, format string, v ...any) error {
err_format := fmt.Sprintf("ERROR: %v; %s", err, format) err_format := fmt.Sprintf("ERROR: %v; %s", err, format)
panic(fmt.Sprintf(err_format, v...)) panic(fmt.Sprintf(err_format, v...))
return err return err
} }
func RenderTemplate(out io.Writer, embed string, variables any) error { func RenderTemplate(out io.Writer, embed string, variables any) error {
layout_path := config.Settings.Layout layout_path := config.Settings.Layout
layout_main, err := os.ReadFile(layout_path) layout_main, err := os.ReadFile(layout_path)
if err != nil { if err != nil {
return Fail(err, "can't read your layout file: %s", layout_path) return Fail(err, "can't read your layout file: %s", layout_path)
} }
tmpl := template.New(layout_path) tmpl := template.New(layout_path)
callbacks := template.FuncMap{ callbacks := template.FuncMap{
"embed": func() string { "embed": func() string {
tmpl, err = tmpl.Parse(embed) tmpl, err = tmpl.Parse(embed)
if err != nil { Fatal(err, "error in your template") } if err != nil {
out := bytes.NewBuffer(make([]byte, 0, 100)) Fatal(err, "error in your template")
tmpl.Execute(out, variables) }
return out.String() out := bytes.NewBuffer(make([]byte, 0, 100))
}, tmpl.Execute(out, variables)
} return out.String()
tmpl.Funcs(callbacks) },
}
tmpl.Funcs(callbacks)
tmpl, err = tmpl.Parse(string(layout_main)) tmpl, err = tmpl.Parse(string(layout_main))
if err != nil { if err != nil {
return Fail(err, "can't parse %s", layout_path) return Fail(err, "can't parse %s", layout_path)
} }
err = tmpl.Execute(out, variables) err = tmpl.Execute(out, variables)
return err return err
} }
func RenderMetaFiles(meta *PageMetaData) { func RenderMetaFiles(meta *PageMetaData) {
fmt.Println("PAGES: ", meta.pages) fmt.Println("PAGES: ", meta.pages)
for _, path := range config.Settings.MetaFiles { for _, path := range config.Settings.MetaFiles {
fmt.Println(">>> META >>>>", path) fmt.Println(">>> META >>>>", path)
ext := filepath.Ext(path) ext := filepath.Ext(path)
target_path := RePrefixPath(path, config.Settings.Target) target_path := RePrefixPath(path, config.Settings.Target)
if ext == ".md" { if ext == ".md" {
RenderMarkdown(path, target_path, RenderMarkdown(path, target_path,
map[string]any{"Pages": meta.pages}) map[string]any{"Pages": meta.pages})
} else if ext == ".html" { } else if ext == ".html" {
RenderHTML(path, target_path, RenderHTML(path, target_path,
map[string]any{"Pages": meta.pages}) map[string]any{"Pages": meta.pages})
} }
} }
} }
func RenderMarkdown(path string, target_path string, vars map[string]any) error { func RenderMarkdown(path string, target_path string, vars map[string]any) error {
log.Printf("MARKDOWN: %s -> %s", path, target_path) log.Printf("MARKDOWN: %s -> %s", path, target_path)
out, err := os.Create(target_path) out, err := os.Create(target_path)
defer out.Close() defer out.Close()
if err != nil { if err != nil {
return Fail(err, "writing file %s", target_path) return Fail(err, "writing file %s", target_path)
} }
input_data, err := os.ReadFile(path) input_data, err := os.ReadFile(path)
var md_out bytes.Buffer var md_out bytes.Buffer
err = goldmark.Convert(input_data, &md_out) err = goldmark.Convert(input_data, &md_out)
if err != nil { if err != nil {
return Fail(err, "failed converting markdown %s", path) return Fail(err, "failed converting markdown %s", path)
} }
err = RenderTemplate(out, md_out.String(), vars) err = RenderTemplate(out, md_out.String(), vars)
if err != nil { if err != nil {
return Fail(err, "failed to render template %s->%s", path, target_path) return Fail(err, "failed to render template %s->%s", path, target_path)
} }
return err return err
} }
func RenderHTML(source_path string, target_path string, vars map[string]any) error { func RenderHTML(source_path string, target_path string, vars map[string]any) error {
log.Printf("RENDER: %s -> %s", source_path, target_path) log.Printf("RENDER: %s -> %s", source_path, target_path)
out, err := os.Create(target_path) out, err := os.Create(target_path)
defer out.Close() defer out.Close()
content, err := os.ReadFile(source_path) content, err := os.ReadFile(source_path)
if err != nil { if err != nil {
return Fail(err, "cannot open input %s", source_path) return Fail(err, "cannot open input %s", source_path)
} }
err = RenderTemplate(out, string(content), vars) err = RenderTemplate(out, string(content), vars)
if err != nil { if err != nil {
return Fail(err, "writing file %s", target_path) return Fail(err, "writing file %s", target_path)
} }
return err return err
} }
func MkdirPath(target_path string) error { func MkdirPath(target_path string) error {
target_dir := filepath.Dir(target_path) target_dir := filepath.Dir(target_path)
_, err := os.Stat(target_dir) _, err := os.Stat(target_dir)
if os.IsNotExist(err) { if os.IsNotExist(err) {
log.Println("MAKING: ", target_dir) log.Println("MAKING: ", target_dir)
err = os.MkdirAll(target_dir, 0750) err = os.MkdirAll(target_dir, 0750)
if err != nil { if err != nil {
return Fail(err, "making path to %s", target_dir) return Fail(err, "making path to %s", target_dir)
} }
} }
return nil return nil
} }
func UnfuckedPathSplit(path string) []string { func UnfuckedPathSplit(path string) []string {
path = filepath.ToSlash(path) path = filepath.ToSlash(path)
// WARN: have to use strings.Split because fsnotify uses /, even on windows // WARN: have to use strings.Split because fsnotify uses /, even on windows
return strings.Split(path, "/")[1:] return strings.Split(path, "/")[1:]
} }
func SplitPathExt(path string) (string, string, bool) { func SplitPathExt(path string) (string, string, bool) {
split_path := UnfuckedPathSplit(path) split_path := UnfuckedPathSplit(path)
source_name := strings.Join(split_path, "/") // Render wants / even on windows source_name := strings.Join(split_path, "/") // Render wants / even on windows
ext := filepath.Ext(source_name) ext := filepath.Ext(source_name)
source_name, found := strings.CutSuffix(source_name, ext) source_name, found := strings.CutSuffix(source_name, ext)
return source_name, ext, found return source_name, ext, found
} }
func RePrefixPath(path string, new_prefix string) string { func RePrefixPath(path string, new_prefix string) string {
split_path := UnfuckedPathSplit(path) split_path := UnfuckedPathSplit(path)
prefixed_path := append([]string{new_prefix}, split_path...) prefixed_path := append([]string{new_prefix}, split_path...)
res := filepath.Join(prefixed_path...) res := filepath.Join(prefixed_path...)
return res return res
} }
func SamePath(a string, b string) bool { func SamePath(a string, b string) bool {
return filepath.ToSlash(a) == filepath.ToSlash(b) return filepath.ToSlash(a) == filepath.ToSlash(b)
} }
func ProcessDirEntry(path string, d fs.DirEntry, meta *PageMetaData) error { func ProcessDirEntry(path string, d fs.DirEntry, meta *PageMetaData) error {
settings := config.Settings settings := config.Settings
var err error = nil var err error = nil
if !d.IsDir() && !SamePath(path, config.Settings.Layout) { if !d.IsDir() && !SamePath(path, config.Settings.Layout) {
source_name, ext, found := SplitPathExt(path) source_name, ext, found := SplitPathExt(path)
if found && path != settings.Layout { if found && path != settings.Layout {
target_path := RePrefixPath(path, settings.Target) target_path := RePrefixPath(path, settings.Target)
err = MkdirPath(target_path) err = MkdirPath(target_path)
if err != nil { if err != nil {
return Fail(err, "making target path: %s", target_path) return Fail(err, "making target path: %s", target_path)
} }
// generate a data-testid for all pages based on template name // generate a data-testid for all pages based on template name
page_id := strings.ReplaceAll(source_name, "/", "-") + "-page" page_id := strings.ReplaceAll(source_name, "/", "-") + "-page"
if ext == ".html" { if ext == ".html" {
err = RenderHTML(path, target_path, err = RenderHTML(path, target_path,
map[string]any{"PageId": page_id}) map[string]any{"PageId": page_id})
if err != nil { if err != nil {
return Fail(err, "failed to render %s", path) return Fail(err, "failed to render %s", path)
} }
meta.AddPage(target_path) meta.AddPage(target_path)
} else if ext == ".md" { } else if ext == ".md" {
// need to strip the .md and replace with .html // need to strip the .md and replace with .html
html_name, _ := strings.CutSuffix(target_path, ext) html_name, _ := strings.CutSuffix(target_path, ext)
html_name = fmt.Sprintf("%s.html", html_name) html_name = fmt.Sprintf("%s.html", html_name)
RenderMarkdown(path, html_name, RenderMarkdown(path, html_name,
map[string]any{"PageId": page_id}) map[string]any{"PageId": page_id})
if err != nil { if err != nil {
return Fail(err, "failed to render markdown %s", path) return Fail(err, "failed to render markdown %s", path)
} }
meta.AddPage(html_name) meta.AddPage(html_name)
} }
} }
} }
return nil return nil
} }
func SyncStaticDir() { func SyncStaticDir() {
target := config.Settings.Target target := config.Settings.Target
sync_dir := config.Settings.SyncDir sync_dir := config.Settings.SyncDir
if sync_dir == "" { if sync_dir == "" {
return return
} }
log.Printf("removing target directory: %s", target) log.Printf("removing target directory: %s", target)
err := os.RemoveAll(target) err := os.RemoveAll(target)
if err != nil { if err != nil {
Fatal(err, "can't remove target directory: %s", target) Fatal(err, "can't remove target directory: %s", target)
} }
err = os.MkdirAll(target, 0750) err = os.MkdirAll(target, 0750)
if err != nil { if err != nil {
Fatal(err, "can't recreate target directory: %s", target) Fatal(err, "can't recreate target directory: %s", target)
} }
source := os.DirFS(sync_dir) source := os.DirFS(sync_dir)
log.Printf("SYNC %s -> %s", sync_dir, target) log.Printf("SYNC %s -> %s", sync_dir, target)
err = os.CopyFS(target, source) err = os.CopyFS(target, source)
if err != nil { if err != nil {
Fatal(err, "can't sync %s to target directory: %s", sync_dir, target) Fatal(err, "can't sync %s to target directory: %s", sync_dir, target)
} }
} }
func RenderPages() { func RenderPages() {
meta := new(PageMetaData) meta := new(PageMetaData)
err := filepath.WalkDir(config.Settings.Views, err := filepath.WalkDir(config.Settings.Views,
func(path string, d fs.DirEntry, err error) error { func(path string, d fs.DirEntry, err error) error {
if err != nil { return err } if err != nil {
return err
}
err = ProcessDirEntry(path, d, meta) err = ProcessDirEntry(path, d, meta)
if err != nil { return Fail(err, "failed to process %s", path) } if err != nil {
return Fail(err, "failed to process %s", path)
}
return err return err
}) })
if err != nil { if err != nil {
Fatal(err, "can't walk content") Fatal(err, "can't walk content")
} }
RenderMetaFiles(meta) RenderMetaFiles(meta)
} }
func WatchMatches(name string) bool { func WatchMatches(name string) bool {
is_static := strings.Index(name, config.Settings.SyncDir) == 0 is_static := strings.Index(name, config.Settings.SyncDir) == 0
return is_static || filepath.Ext(name) == ".html" || filepath.Ext(name) == ".md" return is_static || filepath.Ext(name) == ".html" || filepath.Ext(name) == ".md"
} }
func AddWatchDir(watcher *fsnotify.Watcher, name string) error { func AddWatchDir(watcher *fsnotify.Watcher, name string) error {
return filepath.WalkDir(name, return filepath.WalkDir(name,
func(path string, d fs.DirEntry, err error) error { func(path string, d fs.DirEntry, err error) error {
if err != nil { if err != nil {
log.Printf("WATCH ERROR! walking=%s path=%s: err=%v", name, path, err) log.Printf("WATCH ERROR! walking=%s path=%s: err=%v", name, path, err)
return err return err
} }
if d.IsDir() { if d.IsDir() {
log.Println("WATCHING: ", path) log.Println("WATCHING: ", path)
err = watcher.Add(path) err = watcher.Add(path)
if err != nil { if err != nil {
log.Printf("failed to watch %s", path) log.Printf("failed to watch %s", path)
return err return err
} }
} }
return nil return nil
}) })
} }
func WatchDir() { func WatchDir() {
watcher, err := fsnotify.NewWatcher() watcher, err := fsnotify.NewWatcher()
if err != nil { if err != nil {
Fatal(err, "can't create new watcher") Fatal(err, "can't create new watcher")
} }
defer watcher.Close() defer watcher.Close()
wait_time, err := time.ParseDuration(config.Settings.WatchDelay) wait_time, err := time.ParseDuration(config.Settings.WatchDelay)
if err != nil { if err != nil {
Fatal(err, Fatal(err,
"can't parse watch_delay setting: %s", "can't parse watch_delay setting: %s",
config.Settings.WatchDelay) config.Settings.WatchDelay)
} }
doit := time.NewTimer(wait_time) doit := time.NewTimer(wait_time)
doit.Stop() doit.Stop()
go func() { go func() {
for { for {
select { select {
case event, ok := <-watcher.Events: case event, ok := <-watcher.Events:
if !ok { if !ok {
return return
} }
if event.Has(fsnotify.Create) { if event.Has(fsnotify.Create) {
log.Println("---> CREATE IS:", event.Name) log.Println("---> CREATE IS:", event.Name)
AddWatchDir(watcher, event.Name) AddWatchDir(watcher, event.Name)
} else { } else {
log.Println("event: ", event) log.Println("event: ", event)
} }
if WatchMatches(event.Name) { if WatchMatches(event.Name) {
log.Println("modified file: ", event.Name) log.Println("modified file: ", event.Name)
doit.Reset(wait_time) doit.Reset(wait_time)
} }
case <-doit.C: case <-doit.C:
SyncStaticDir() SyncStaticDir()
RenderPages() RenderPages()
case err, ok := <-watcher.Errors: case err, ok := <-watcher.Errors:
if !ok { if !ok {
return return
} }
log.Println("error: ", err) log.Println("error: ", err)
} }
} }
}() }()
err = AddWatchDir(watcher, config.Settings.Views) err = AddWatchDir(watcher, config.Settings.Views)
if err != nil { if err != nil {
Fatal(err, "failed to watch %s", config.Settings.Views) Fatal(err, "failed to watch %s", config.Settings.Views)
} }
err = AddWatchDir(watcher, filepath.Dir(config.Settings.Layout)) err = AddWatchDir(watcher, filepath.Dir(config.Settings.Layout))
if err != nil { if err != nil {
Fatal(err, "failed to watch %s", filepath.Dir(config.Settings.Layout)) Fatal(err, "failed to watch %s", filepath.Dir(config.Settings.Layout))
} }
if config.Settings.SyncDir != "" { if config.Settings.SyncDir != "" {
err = AddWatchDir(watcher, config.Settings.SyncDir) err = AddWatchDir(watcher, config.Settings.SyncDir)
if err != nil { if err != nil {
Fatal(err, "failed to watch %s", config.Settings.SyncDir) Fatal(err, "failed to watch %s", config.Settings.SyncDir)
} }
} }
<-make(chan struct{}) <-make(chan struct{})
} }
func InitConfig(config_file string) { func InitConfig(config_file string) {
_, err := os.Stat(config_file) _, err := os.Stat(config_file)
if os.IsNotExist(err) { if os.IsNotExist(err) {
out, err := os.Create(config_file) out, err := os.Create(config_file)
if err != nil { if err != nil {
Fatal(err, "error opening %s", config_file) Fatal(err, "error opening %s", config_file)
} }
defer out.Close() defer out.Close()
out.WriteString(DEFAULT_CONFIG) out.WriteString(DEFAULT_CONFIG)
fmt.Println("new config written to:", config_file) fmt.Println("new config written to:", config_file)
} else { } else {
Fatal(err, "there's already a %s file here", config_file) Fatal(err, "there's already a %s file here", config_file)
} }
} }
func main() { func main() {
var config_file string var config_file string
flag.StringVar(&config_file, "config", ".ssgod.json", ".json config file to use") flag.StringVar(&config_file, "config", ".ssgod.json", ".json config file to use")
flag.Parse() flag.Parse()
command := flag.Arg(0) command := flag.Arg(0)
switch command { switch command {
case "watch": case "watch":
config.Load(config_file) config.Load(config_file)
SyncStaticDir() SyncStaticDir()
RenderPages() RenderPages()
WatchDir() WatchDir()
case "init": case "init":
InitConfig(config_file) InitConfig(config_file)
default: default:
config.Load(config_file) config.Load(config_file)
SyncStaticDir() SyncStaticDir()
RenderPages() RenderPages()
} }
} }

Write Preview
Loading…
Cancel
Save