hswg: use inotify to watch for changed documents
Now we force the glob to be *.adoc, as well as *.asciidoc, and there can only be one document directory. The previous single-run mode is no longer supported.
This commit is contained in:
parent
49a685c32e
commit
04e19f5186
GPG Key ID:
A0420B94F92B9493
250
hswg/main.go
250
hswg/main.go
|
|
@ -4,6 +4,7 @@ package main
|
|||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"html/template"
|
||||
|
|
@ -11,10 +12,12 @@ import (
|
|||
"io/ioutil"
|
||||
"log"
|
||||
"os"
|
||||
"os/signal"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
"unicode"
|
||||
"unicode/utf8"
|
||||
|
|
@ -157,7 +160,14 @@ func (e *Entry) Published() *time.Time {
|
|||
}
|
||||
}
|
||||
|
||||
var extRE = regexp.MustCompile(`\.[^/.]*$`)
|
||||
var (
|
||||
globs = []string{"*.adoc", "*.asciidoc"}
|
||||
extRE = regexp.MustCompile(`\.[^/.]*$`)
|
||||
)
|
||||
|
||||
func pathToName(path string) string {
|
||||
return stripExtension(filepath.Base(path))
|
||||
}
|
||||
|
||||
func stripExtension(path string) string {
|
||||
return extRE.ReplaceAllString(path, "")
|
||||
|
|
@ -172,7 +182,8 @@ func resultPath(path string) string {
|
|||
|
||||
func makeLink(m *map[string]*Entry, name string) string {
|
||||
e := (*m)[name]
|
||||
return fmt.Sprintf("<a href='%s'>%s</a>", e.PathDestination, name)
|
||||
return fmt.Sprintf("<a href='%s'>%s</a>",
|
||||
filepath.Clean(e.PathDestination), name)
|
||||
}
|
||||
|
||||
var linkWordRE = regexp.MustCompile(`\b\p{Lu}\p{L}*\b`)
|
||||
|
|
@ -219,31 +230,28 @@ func renderEntry(name string, e *Entry) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func loadEntries(globs []string) (map[string]*Entry, error) {
|
||||
// Create a map from document names to their page entries.
|
||||
entries := map[string]*Entry{}
|
||||
for _, glob := range globs {
|
||||
matches, err := filepath.Glob(glob)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("%s: %s\n", glob, err)
|
||||
}
|
||||
for _, path := range matches {
|
||||
name := stripExtension(filepath.Base(path))
|
||||
if conflict, ok := entries[name]; ok {
|
||||
return nil, fmt.Errorf("%s: conflicts with %s\n",
|
||||
name, conflict.PathSource)
|
||||
}
|
||||
entries[name] = &Entry{
|
||||
func makeEntry(path string) *Entry {
|
||||
return &Entry{
|
||||
PathSource: path,
|
||||
PathDestination: resultPath(path),
|
||||
backlinks: map[string]bool{},
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for name, e := range entries {
|
||||
if err := renderEntry(name, e); err != nil {
|
||||
return nil, err
|
||||
// loadEntries creates a map from document names to their page entries.
|
||||
func loadEntries(dirname string) (map[string]*Entry, error) {
|
||||
entries := map[string]*Entry{}
|
||||
for _, glob := range globs {
|
||||
matches, err := filepath.Glob(filepath.Join(dirname, glob))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("%s: %s", dirname, err)
|
||||
}
|
||||
for _, path := range matches {
|
||||
name := pathToName(path)
|
||||
if conflict, ok := entries[name]; ok {
|
||||
return nil, fmt.Errorf("%s: conflicts with %s",
|
||||
name, conflict.PathSource)
|
||||
}
|
||||
entries[name] = makeEntry(path)
|
||||
}
|
||||
}
|
||||
return entries, nil
|
||||
|
|
@ -269,21 +277,6 @@ func writeEntry(e *Entry, t *template.Template,
|
|||
return t.Execute(f, e)
|
||||
}
|
||||
|
||||
func finalizeEntries(entries *map[string]*Entry) {
|
||||
for name, e := range *entries {
|
||||
// Expand LinkWords anywhere between <tags>.
|
||||
// We want something like the inverse of Regexp.ReplaceAllStringFunc.
|
||||
raw, last, expanded := e.raw, 0, bytes.NewBuffer(nil)
|
||||
for _, where := range tagRE.FindAllIndex(raw, -1) {
|
||||
_, _ = expanded.Write(expand(entries, name, raw[last:where[0]]))
|
||||
_, _ = expanded.Write(raw[where[0]:where[1]])
|
||||
last = where[1]
|
||||
}
|
||||
_, _ = expanded.Write(expand(entries, name, raw[last:]))
|
||||
e.Content = template.HTML(expanded.String())
|
||||
}
|
||||
}
|
||||
|
||||
func writeIndex(path string, t *template.Template,
|
||||
entries *map[string]*Entry) error {
|
||||
// Reorder entries reversely, primarily by date, secondarily by filename.
|
||||
|
|
@ -315,10 +308,144 @@ func writeIndex(path string, t *template.Template,
|
|||
return err
|
||||
}
|
||||
|
||||
// TODO(p): Splitting content to categories would be nice.
|
||||
// TODO(p): Splitting content to categories would be nice. Or tags.
|
||||
return t.Execute(f, ordered)
|
||||
}
|
||||
|
||||
func finalizeEntries(entries *map[string]*Entry, t *template.Template,
|
||||
indexPath string, indexT *template.Template) {
|
||||
for name, e := range *entries {
|
||||
e.backlinks = map[string]bool{}
|
||||
if e.raw == nil {
|
||||
if err := renderEntry(name, e); err != nil {
|
||||
log.Printf("%s: %s\n", name, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
for name, e := range *entries {
|
||||
// Expand LinkWords anywhere between <tags>.
|
||||
// We want something like the inverse of Regexp.ReplaceAllStringFunc.
|
||||
raw, last, expanded := e.raw, 0, bytes.NewBuffer(nil)
|
||||
for _, where := range tagRE.FindAllIndex(raw, -1) {
|
||||
_, _ = expanded.Write(expand(entries, name, raw[last:where[0]]))
|
||||
_, _ = expanded.Write(raw[where[0]:where[1]])
|
||||
last = where[1]
|
||||
}
|
||||
_, _ = expanded.Write(expand(entries, name, raw[last:]))
|
||||
e.Content = template.HTML(expanded.String())
|
||||
}
|
||||
for name, e := range *entries {
|
||||
// Don't overwrite failed renders.
|
||||
if e.raw == nil {
|
||||
continue
|
||||
}
|
||||
if err := writeEntry(e, t, entries); err != nil {
|
||||
log.Printf("%s: %s\n", name, err)
|
||||
}
|
||||
}
|
||||
if err := writeIndex(indexPath, indexT, entries); err != nil {
|
||||
log.Printf("%s: %s\n", indexPath, err)
|
||||
}
|
||||
}
|
||||
|
||||
type watchEvent struct {
|
||||
path string // the path of the target
|
||||
present bool // if not, the file has been removed
|
||||
}
|
||||
|
||||
func dispatchEvents(dirname string, r io.Reader, ch chan<- *watchEvent) error {
|
||||
var e syscall.InotifyEvent
|
||||
for {
|
||||
// FIXME(p): This has to respect the machine's endianness.
|
||||
// Perhaps use the unsafe package.
|
||||
err := binary.Read(r, binary.LittleEndian, &e)
|
||||
if err == io.EOF {
|
||||
return nil
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
switch {
|
||||
case e.Mask&syscall.IN_IGNORED != 0:
|
||||
return fmt.Errorf("watch removed by kernel")
|
||||
case e.Mask&syscall.IN_Q_OVERFLOW != 0:
|
||||
log.Println("inotify: queue overflowed")
|
||||
ch <- nil
|
||||
continue
|
||||
case e.Len == 0:
|
||||
continue
|
||||
}
|
||||
|
||||
base := make([]byte, e.Len)
|
||||
if n, err := r.Read(base); err != nil {
|
||||
return err
|
||||
} else if n < int(e.Len) {
|
||||
return fmt.Errorf("short read")
|
||||
}
|
||||
|
||||
basename, interesting := string(base[:bytes.IndexByte(base, 0)]), false
|
||||
for _, glob := range globs {
|
||||
if matches, _ := filepath.Match(glob, basename); matches {
|
||||
interesting = true
|
||||
}
|
||||
}
|
||||
if !interesting {
|
||||
continue
|
||||
}
|
||||
|
||||
event := &watchEvent{path: filepath.Join(dirname, basename)}
|
||||
if e.Mask&syscall.IN_MODIFY != 0 || e.Mask&syscall.IN_MOVED_TO != 0 ||
|
||||
e.Mask&syscall.IN_CLOSE_WRITE != 0 {
|
||||
event.present = true
|
||||
ch <- event
|
||||
}
|
||||
if e.Mask&syscall.IN_DELETE != 0 || e.Mask&syscall.IN_MOVED_FROM != 0 {
|
||||
event.present = false
|
||||
ch <- event
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func watchDirectory(dirname string) (<-chan *watchEvent, error) {
|
||||
inotifyFD, err := syscall.InotifyInit1(0)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// We're ignoring IN_CREATE, as it doesn't seem to be useful,
|
||||
// and we're leaving out IN_MODIFY since VIM always triggers IN_CLOSE_WRITE,
|
||||
// saving us from having to coalesce plentiful similar events.
|
||||
_, err = syscall.InotifyAddWatch(inotifyFD, dirname, syscall.IN_ONLYDIR|
|
||||
syscall.IN_MOVE|syscall.IN_DELETE|syscall.IN_CLOSE_WRITE)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
inotifyFile := os.NewFile(uintptr(inotifyFD), "inotify")
|
||||
buf := make([]byte, syscall.SizeofInotifyEvent+syscall.PathMax+1)
|
||||
ch := make(chan *watchEvent)
|
||||
go func() {
|
||||
// Trigger an initial rendering run.
|
||||
ch <- nil
|
||||
|
||||
defer close(ch)
|
||||
for {
|
||||
n, err := inotifyFile.Read(buf)
|
||||
if err != nil {
|
||||
log.Println(err)
|
||||
return
|
||||
}
|
||||
err = dispatchEvents(dirname, bytes.NewReader(buf[:n]), ch)
|
||||
if err != nil {
|
||||
log.Printf("inotify: %s\n", err)
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
return ch, nil
|
||||
}
|
||||
|
||||
func singleFile() {
|
||||
html, meta, err := Render(os.Stdin, configuration.NewConfiguration())
|
||||
if err != nil {
|
||||
|
|
@ -336,11 +463,11 @@ func main() {
|
|||
singleFile()
|
||||
return
|
||||
}
|
||||
if len(os.Args) < 4 {
|
||||
log.Fatalf("usage: %s TEMPLATE INDEX GLOB...\n", os.Args[0])
|
||||
if len(os.Args) != 4 {
|
||||
log.Fatalf("usage: %s TEMPLATE INDEX DIRECTORY\n", os.Args[0])
|
||||
}
|
||||
|
||||
argTemplate, argIndex, argGlobs := os.Args[1], os.Args[2], os.Args[3:]
|
||||
argTemplate, argIndex, argDirectory := os.Args[1], os.Args[2], os.Args[3]
|
||||
|
||||
// Read a template for entries.
|
||||
header, err := ioutil.ReadFile(argTemplate)
|
||||
|
|
@ -362,21 +489,40 @@ func main() {
|
|||
log.Fatalln(err)
|
||||
}
|
||||
|
||||
// Process all entries.
|
||||
entries, err := loadEntries(argGlobs)
|
||||
// Re-render as needed, avoid having to trigger anything manually.
|
||||
var entries map[string]*Entry
|
||||
directoryWatch, err := watchDirectory(argDirectory)
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
|
||||
finalizeEntries(&entries)
|
||||
for _, e := range entries {
|
||||
if err := writeEntry(e, tmplEntry, &entries); err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
signals := make(chan os.Signal)
|
||||
signal.Notify(signals, syscall.SIGINT, syscall.SIGHUP, syscall.SIGTERM)
|
||||
for {
|
||||
select {
|
||||
case <-signals:
|
||||
os.Exit(0)
|
||||
case event, ok := <-directoryWatch:
|
||||
if !ok {
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Write an index.
|
||||
if err := writeIndex(argIndex, tmplIndex, &entries); err != nil {
|
||||
log.Fatalln(err)
|
||||
if event == nil {
|
||||
log.Println("reloading all files")
|
||||
if entries, err = loadEntries(argDirectory); err != nil {
|
||||
log.Println(err)
|
||||
}
|
||||
} else if event.present {
|
||||
log.Printf("updating %s\n", event.path)
|
||||
entries[pathToName(event.path)] = makeEntry(event.path)
|
||||
} else {
|
||||
log.Printf("removing %s\n", event.path)
|
||||
delete(entries, pathToName(event.path))
|
||||
os.Remove(resultPath(event.path))
|
||||
}
|
||||
|
||||
finalizeEntries(&entries, tmplEntry, argIndex, tmplIndex)
|
||||
log.Println("done")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue