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

Quick fix to ssgod skipping new directories.

Browse Source
master
Zed A. Shaw 4 days ago
parent a8da5849bd
commit 0a386e03cf
2 changed files with 267 additions and 220 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. 1
      example/ssgod.toml
  2. 486
      main.go

1
example/ssgod.toml
Unescape View File

@ -1,4 +1,3 @@
views = "pages" views = "pages"
layout = "pages/layouts/main.html" layout = "pages/layouts/main.html"
target = "public" target = "public"

486
main.go
Unescape View File

@ -1,20 +1,20 @@
package main package main
import ( import (
"log" "bytes"
"fmt" "flag"
"bytes" "fmt"
"strings" "github.com/fsnotify/fsnotify"
"io/fs" "github.com/yuin/goldmark"
"io" "io"
"path/filepath" "io/fs"
"os" "lcthw.dev/go/ssgod/config"
"flag" "log"
"time" "os"
"text/template" "path/filepath"
"lcthw.dev/go/ssgod/config" "strings"
"github.com/yuin/goldmark" "text/template"
"github.com/fsnotify/fsnotify" "time"
) )
var DEFAULT_CONFIG = ` var DEFAULT_CONFIG = `
@ -27,289 +27,337 @@ watch_delay = "500ms"
` `
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)
log.Fatalf(err_format, v...) log.Fatalf(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)
log.Printf(err_format, v...) log.Printf(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 { return embed }, "embed": func() string { return embed },
} }
tmpl.Funcs(callbacks) tmpl.Funcs(callbacks)
tmpl, err = tmpl.Parse(string(layout_main)) tmpl, err = tmpl.Parse(string(layout_main))
if err != nil { return Fail(err, "can't parse %s", layout_path) } if err != nil {
return Fail(err, "can't parse %s", layout_path)
}
err = tmpl.Execute(out, variables) err = tmpl.Execute(out, variables)
return err return err
} }
func RenderMarkdown(path string, target_path string, page_id string) error { func RenderMarkdown(path string, target_path string, page_id string) error {
log.Printf("MARKDOWN: %s -> %s", path, target_path) log.Printf("MARKDOWN: %s -> %s", path, target_path)
out, err := os.OpenFile(target_path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644) out, err := os.OpenFile(target_path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
defer out.Close() defer out.Close()
if err != nil { return Fail(err, "writing file %s", target_path) } if err != nil {
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 { return Fail(err, "failed converting markdown %s", path) } if err != nil {
return Fail(err, "failed converting markdown %s", path)
}
err = RenderTemplate(out, md_out.String(), err = RenderTemplate(out, md_out.String(),
map[string]string{"PageId": page_id}) map[string]string{"PageId": page_id})
if err != nil { return Fail(err, "failed to render template %s->%s", path, target_path) } if err != nil {
return Fail(err, "failed to render template %s->%s", path, target_path)
}
return err; return err
} }
func RenderHTML(source_path string, target_path string, page_id string) error { func RenderHTML(source_path string, target_path string, page_id string) error {
log.Printf("RENDER: %s -> %s", source_path, target_path) log.Printf("RENDER: %s -> %s", source_path, target_path)
out, err := os.OpenFile(target_path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644) out, err := os.OpenFile(target_path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
defer out.Close() defer out.Close()
html_content, err := os.ReadFile(source_path) html_content, err := os.ReadFile(source_path)
if err != nil { return Fail(err, "cannot open html input %s", source_path) } if err != nil {
return Fail(err, "cannot open html input %s", source_path)
}
err = RenderTemplate(out, string(html_content), err = RenderTemplate(out, string(html_content),
map[string]string{"PageId": page_id}) map[string]string{"PageId": page_id})
if err != nil { return Fail(err, "writing file %s", target_path) } if err != nil {
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 { return Fail(err, "making path to %s", target_dir); } if err != nil {
} return Fail(err, "making path to %s", target_dir)
}
}
return nil; return nil
} }
func SplitPathExt(path string) (string, string, bool) { func SplitPathExt(path string) (string, string, bool) {
split_path := strings.Split(path, string(os.PathSeparator))[1:] split_path := strings.Split(path, string(os.PathSeparator))[1:]
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 := strings.Split(path, string(os.PathSeparator))[1:] split_path := strings.Split(path, string(os.PathSeparator))[1:]
prefixed_path := append([]string{new_prefix}, split_path...) prefixed_path := append([]string{new_prefix}, split_path...)
return filepath.Join(prefixed_path...) return filepath.Join(prefixed_path...)
} }
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, err error) error { func ProcessDirEntry(path string, d fs.DirEntry, err error) error {
settings := config.Settings settings := config.Settings
if !d.IsDir() && !SamePath(path, config.Settings.Layout) { if !d.IsDir() && !SamePath(path, config.Settings.Layout) {
if err != nil { return Fail(err, "path: %s", path); } if err != nil {
return Fail(err, "path: %s", path)
}
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 { return Fail(err, "making target path: %s", target_path) } if err != nil {
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, page_id) err = RenderHTML(path, target_path, page_id)
if err != nil { return Fail(err, "failed to render %s", path) } if err != nil {
} else if ext == ".md" { return Fail(err, "failed to render %s", path)
// need to strip the .md and replace with .html }
html_name, _ := strings.CutSuffix(target_path, ext) } else if ext == ".md" {
html_name = fmt.Sprintf("%s.html", html_name) // need to strip the .md and replace with .html
html_name, _ := strings.CutSuffix(target_path, ext)
html_name = fmt.Sprintf("%s.html", html_name)
RenderMarkdown(path, html_name, page_id) RenderMarkdown(path, html_name, page_id)
if err != nil { return Fail(err, "failed to render markdown %s", path) } if err != nil {
} return Fail(err, "failed to render markdown %s", path)
} }
} }
}
}
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 == "" { return } if sync_dir == "" {
return
log.Printf("removing target directory: %s", target) }
err := os.RemoveAll(target) log.Printf("removing target directory: %s", target)
if err != nil {
Fatal(err, "can't remove target directory: %s", target) err := os.RemoveAll(target)
} if err != nil {
Fatal(err, "can't remove target directory: %s", target)
err = os.MkdirAll(target, 0750) }
if err != nil {
Fatal(err, "can't recreate target directory: %s", target) err = os.MkdirAll(target, 0750)
} if err != nil {
Fatal(err, "can't recreate target directory: %s", target)
source := os.DirFS(sync_dir) }
log.Printf("SYNC %s -> %s", sync_dir, target) source := os.DirFS(sync_dir)
err = os.CopyFS(target, source)
if err != nil { log.Printf("SYNC %s -> %s", sync_dir, target)
Fatal(err, "can't sync %s to target directory: %s", sync_dir, target) err = os.CopyFS(target, source)
} if err != nil {
Fatal(err, "can't sync %s to target directory: %s", sync_dir, target)
}
} }
func RenderPages() { func RenderPages() {
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 {
return ProcessDirEntry(path, d, err) return ProcessDirEntry(path, d, err)
}) })
if err != nil { log.Fatalf("can't walk content") } if err != nil {
log.Fatalf("can't walk content")
}
} }
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 { log.Fatalf("WATCH ERROR! path=%s: err=%v", path, err) } if err != nil {
log.Printf("WATCH ERROR! walking=%s path=%s: err=%v", name, path, err)
if d.IsDir() { return err
log.Println("WATCHING: ", path) }
err = watcher.Add(path)
if err != nil { return Fail(err, "failed to watch %s", path) } if d.IsDir() {
} log.Println("WATCHING: ", path)
err = watcher.Add(path)
return nil if err != nil {
}) log.Printf("failed to watch %s", path)
return err
}
}
return nil
})
} }
func WatchDir() { func WatchDir() {
watcher, err := fsnotify.NewWatcher() watcher, err := fsnotify.NewWatcher()
if err != nil { log.Fatal(err) } if err != nil {
log.Fatal(err)
defer watcher.Close() }
wait_time, err := time.ParseDuration(config.Settings.WatchDelay) defer watcher.Close()
if err != nil { log.Fatal(err) }
wait_time, err := time.ParseDuration(config.Settings.WatchDelay)
doit := time.NewTimer(wait_time) if err != nil {
doit.Stop() log.Fatal(err)
}
go func() {
for { doit := time.NewTimer(wait_time)
select { doit.Stop()
case event, ok := <-watcher.Events:
if !ok { return } go func() {
log.Println("event: ", event) for {
select {
if WatchMatches(event.Name) { case event, ok := <-watcher.Events:
log.Println("modified file: ", event.Name) if !ok {
doit.Reset(wait_time) return
} }
case <-doit.C:
SyncStaticDir() if event.Has(fsnotify.Create) {
RenderPages() log.Println("---> CREATE IS:", event.Name)
case err, ok := <-watcher.Errors: AddWatchDir(watcher, event.Name)
if !ok { return } } else {
log.Println("error: ", err) log.Println("event: ", event)
} }
}
}() if WatchMatches(event.Name) {
log.Println("modified file: ", event.Name)
err = AddWatchDir(watcher, config.Settings.Views) doit.Reset(wait_time)
if err != nil { }
Fatal(err, "failed to watch %s", config.Settings.Views) case <-doit.C:
} SyncStaticDir()
RenderPages()
err = AddWatchDir(watcher, filepath.Dir(config.Settings.Layout)) case err, ok := <-watcher.Errors:
if err != nil { if !ok {
Fatal(err, "failed to watch %s", filepath.Dir(config.Settings.Layout)) return
} }
log.Println("error: ", err)
err = AddWatchDir(watcher, config.Settings.SyncDir) }
if err != nil { }
Fatal(err, "failed to watch %s", config.Settings.SyncDir) }()
}
err = AddWatchDir(watcher, config.Settings.Views)
<-make(chan struct{}) if err != nil {
Fatal(err, "failed to watch %s", config.Settings.Views)
}
err = AddWatchDir(watcher, filepath.Dir(config.Settings.Layout))
if err != nil {
Fatal(err, "failed to watch %s", filepath.Dir(config.Settings.Layout))
}
if config.Settings.SyncDir != "" {
err = AddWatchDir(watcher, config.Settings.SyncDir)
if err != nil {
Fatal(err, "failed to watch %s", config.Settings.SyncDir)
}
}
<-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.OpenFile(config_file, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644) out, err := os.OpenFile(config_file, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
if err != nil { log.Fatalf("error opening %s", config_file) } if err != nil {
defer out.Close() log.Fatalf("error opening %s", config_file)
}
out.WriteString(DEFAULT_CONFIG) defer out.Close()
} else {
log.Fatalf("there's already a %s file here", config_file); out.WriteString(DEFAULT_CONFIG)
} } else {
log.Fatalf("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.toml", ".toml config file to use") flag.StringVar(&config_file, "config", "ssgod.toml", ".toml 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