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

Now a simplistic sitemap/metapage feature works. Only has the URL for the page but more can come later.

Browse Source
master
Zed A. Shaw 3 days ago
parent 3f50254403
commit e10cc57bec
2 changed files with 314 additions and 302 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. 2
      example/pages/sitemap.html
  2. 614
      main.go

2
example/pages/sitemap.html
Unescape View File

@ -2,7 +2,7 @@
<ul> <ul>
{{range $index, $page := .Pages}} {{range $index, $page := .Pages}}
<li><b>{{$index}}:</b> {{$page}}</li> <li><a href="{{$page}}">{{$page}}</a></li>
{{ else }} {{ else }}
Nothing Here Nothing Here
{{end}} {{end}}

614
main.go
Unescape View File

@ -1,402 +1,414 @@
package main package main
import ( import (
"bytes" "bytes"
"flag" "flag"
"fmt" "fmt"
"github.com/fsnotify/fsnotify" "github.com/fsnotify/fsnotify"
"github.com/yuin/goldmark" "github.com/yuin/goldmark"
"io" "io"
"io/fs" "io/fs"
"lcthw.dev/go/ssgod/config" "lcthw.dev/go/ssgod/config"
"log" "log"
"os" "os"
"path/filepath" "path/filepath"
"strings" "strings"
"text/template" "text/template"
"time" "time"
_ "embed" _ "embed"
) )
//go:embed example/.ssgod.json //go:embed example/.ssgod.json
var DEFAULT_CONFIG string var DEFAULT_CONFIG string
type PageMetaData struct {
pages []string
}
func (meta *PageMetaData) AddPage(path string) {
path = RePrefixPath(path, "/")
path = filepath.ToSlash(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)
log.Fatalf(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)
log.Printf(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 { Fatal(err, "error in your template") }
out := bytes.NewBuffer(make([]byte, 0, 100)) out := bytes.NewBuffer(make([]byte, 0, 100))
tmpl.Execute(out, variables) tmpl.Execute(out, variables)
return out.String() 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(pages []string) { func RenderMetaFiles(meta *PageMetaData) {
fmt.Println("PAGES: ", 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": pages}) map[string]any{"Pages": meta.pages})
} else { } else if ext == ".html" {
RenderHTML(path, target_path, RenderHTML(path, target_path,
map[string]any{"Pages": 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 {
path = filepath.ToSlash(path)
// WARN: have to use strings.Split because fsnotify uses /, even on windows
return strings.Split(path, "/")[1:]
} }
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 := 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 := strings.Split(path, string(os.PathSeparator))[1:] split_path := UnfuckedPathSplit(path)
prefixed_path := append([]string{new_prefix}, split_path...) prefixed_path := append([]string{new_prefix}, split_path...)
return filepath.Join(prefixed_path...)
res := filepath.Join(prefixed_path...)
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, err error) error { func ProcessDirEntry(path string, d fs.DirEntry, meta *PageMetaData) error {
settings := config.Settings settings := config.Settings
var err error = nil
if !d.IsDir() && !SamePath(path, config.Settings.Layout) {
source_name, ext, found := SplitPathExt(path)
if !d.IsDir() && !SamePath(path, config.Settings.Layout) { if found && path != settings.Layout {
if err != nil { target_path := RePrefixPath(path, settings.Target)
return Fail(err, "path: %s", path)
}
source_name, ext, found := SplitPathExt(path) err = MkdirPath(target_path)
if err != nil {
return Fail(err, "making target path: %s", target_path)
}
if found && path != settings.Layout { // generate a data-testid for all pages based on template name
target_path := RePrefixPath(path, settings.Target) page_id := strings.ReplaceAll(source_name, "/", "-") + "-page"
err = MkdirPath(target_path) if ext == ".html" {
if err != nil { err = RenderHTML(path, target_path,
return Fail(err, "making target path: %s", target_path) map[string]any{"PageId": page_id})
}
// generate a data-testid for all pages based on template name if err != nil {
page_id := strings.ReplaceAll(source_name, "/", "-") + "-page" return Fail(err, "failed to render %s", path)
}
// BUG: make it so we can have a list of extensions meta.AddPage(target_path)
if ext == ".html" || ext == ".xml" || ext == ".rss" { } else if ext == ".md" {
err = RenderHTML(path, target_path, // need to strip the .md and replace with .html
map[string]any{"PageId": page_id}) html_name, _ := strings.CutSuffix(target_path, ext)
html_name = fmt.Sprintf("%s.html", html_name)
if err != nil { RenderMarkdown(path, html_name,
return Fail(err, "failed to render %s", path) map[string]any{"PageId": page_id})
}
} else if ext == ".md" {
// 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, if err != nil {
map[string]any{"PageId": page_id}) return Fail(err, "failed to render markdown %s", path)
}
if err != nil { meta.AddPage(html_name)
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 == "" { 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() {
pages := make([]string, 0, 100) 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 }
create an exclusion/inclusion system that knows if a file err = ProcessDirEntry(path, d, meta)
is a target, and only process it and add to pages if it matches if err != nil { return Fail(err, "failed to process %s", path) }
err = ProcessDirEntry(path, d, err) return err
if err == nil { })
// no errors, add to the list
pages = append(pages, path)
}
return err
})
if err != nil { if err != nil {
Fatal(err, "can't walk content") Fatal(err, "can't walk content")
} }
RenderMetaFiles(pages) 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