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.

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"
@@ -134,12 +137,13 @@ func Render(r io.Reader, config configuration.Configuration) (
 
 // Entry contains all context information about a single page.
 type Entry struct {
-	Metadata                      // metadata
-	PathSource      string        // path to source AsciiDoc
-	PathDestination string        // path to destination HTML
-	mtime           time.Time     // modification time
-	Content         template.HTML // inner document with expanded LinkWords
-	backlinks       []string      // what documents link back here
+	Metadata                        // metadata
+	PathSource      string          // path to source AsciiDoc
+	PathDestination string          // path to destination HTML
+	mtime           time.Time       // modification time
+	raw             []byte          // raw inner document
+	Content         template.HTML   // inner document with expanded LinkWords
+	backlinks       map[string]bool // what documents link back here
 	Backlinks       []template.HTML
 }
 
@@ -156,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, "")
@@ -171,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`)
@@ -180,132 +192,96 @@ func expand(m *map[string]*Entry, name string, chunk []byte) []byte {
 	return linkWordRE.ReplaceAllFunc(chunk, func(match []byte) []byte {
 		if link, ok := (*m)[string(match)]; ok && string(match) != name &&
 			!link.IsDraft() {
-			link.backlinks = append(link.backlinks, name)
+			link.backlinks[name] = true
 			return []byte(makeLink(m, string(match)))
 		}
 		return match
 	})
 }
 
-func singleFile() {
-	html, meta, err := Render(os.Stdin, configuration.NewConfiguration())
+var tagRE = regexp.MustCompile(`<[^<>]+>`)
+
+func renderEntry(name string, e *Entry) error {
+	f, err := os.Open(e.PathSource)
 	if err != nil {
-		log.Println(err)
-	} else if meta.Title != "" {
-		_, _ = os.Stdout.WriteString("<h1>")
-		_ = xml.EscapeText(os.Stdout, []byte(meta.Title))
-		_, _ = os.Stdout.WriteString("</h1>\n")
+		return err
 	}
-	_, _ = io.Copy(os.Stdout, html)
+
+	if i, err := f.Stat(); err != nil {
+		return err
+	} else {
+		e.mtime = i.ModTime()
+	}
+
+	var html *bytes.Buffer
+	if html, e.Metadata, err = Render(f, configuration.NewConfiguration(
+		configuration.WithFilename(e.PathSource),
+		configuration.WithLastUpdated(e.mtime),
+	)); err != nil {
+		return err
+	}
+
+	// Every page needs to have a title.
+	if e.Title == "" {
+		e.Title = name
+	}
+
+	e.raw = html.Bytes()
+	return nil
 }
 
-func main() {
-	if len(os.Args) < 2 {
-		singleFile()
-		return
-	}
-	if len(os.Args) < 3 {
-		log.Fatalf("usage: %s TEMPLATE GLOB...\n", os.Args[0])
+func makeEntry(path string) *Entry {
+	return &Entry{
+		PathSource:      path,
+		PathDestination: resultPath(path),
 	}
+}
 
-	// Read the common page header.
-	header, err := ioutil.ReadFile(os.Args[1])
-	if err != nil {
-		log.Fatalln(err)
-	}
-
-	t, err := template.New("page").Parse(string(header))
-	if err != nil {
-		log.Fatalln(err)
-	}
-
-	// Create a map from document names to their page entries.
+// 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 os.Args[2:] {
-		matches, err := filepath.Glob(glob)
+	for _, glob := range globs {
+		matches, err := filepath.Glob(filepath.Join(dirname, glob))
 		if err != nil {
-			log.Fatalf("%s: %s\n", glob, err)
+			return nil, fmt.Errorf("%s: %s", dirname, err)
 		}
 		for _, path := range matches {
-			name := stripExtension(filepath.Base(path))
+			name := pathToName(path)
 			if conflict, ok := entries[name]; ok {
-				log.Fatalf("%s: conflicts with %s\n", name, conflict.PathSource)
-			}
-			entries[name] = &Entry{
-				PathSource:      path,
-				PathDestination: resultPath(path),
+				return nil, fmt.Errorf("%s: conflicts with %s",
+					name, conflict.PathSource)
 			}
+			entries[name] = makeEntry(path)
 		}
 	}
+	return entries, nil
+}
 
-	tagRE := regexp.MustCompile(`<[^<>]+>`)
-	for name, e := range entries {
-		f, err := os.Open(e.PathSource)
-		if err != nil {
-			log.Fatalln(err)
-		}
-
-		if i, err := f.Stat(); err != nil {
-			log.Fatalln(err)
-		} else {
-			e.mtime = i.ModTime()
-		}
-
-		var html *bytes.Buffer
-		if html, e.Metadata, err = Render(f, configuration.NewConfiguration(
-			configuration.WithFilename(e.PathSource),
-			configuration.WithLastUpdated(e.mtime),
-		)); err != nil {
-			log.Fatalln(err)
-		}
-
-		// Every page needs to have a title.
-		if e.Title == "" {
-			e.Title = name
-		}
-
-		// Expand LinkWords anywhere between <tags>.
-		// We want something like the inverse of Regexp.ReplaceAllStringFunc.
-		raw, last, expanded := html.Bytes(), 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 writeEntry(e *Entry, t *template.Template,
+	entries *map[string]*Entry) error {
+	f, err := os.Create(e.PathDestination)
+	if err != nil {
+		return err
 	}
 
-	for _, e := range entries {
-		sort.Strings(e.backlinks)
-
-		last, uniq := "", []string{}
-		for _, name := range e.backlinks {
-			if name != last {
-				uniq = append(uniq, name)
-			}
-			last = name
-		}
-		e.backlinks = uniq
+	backlinks := []string{}
+	for name := range e.backlinks {
+		backlinks = append(backlinks, name)
+	}
+	sort.Strings(backlinks)
+	for _, name := range backlinks {
+		e.Backlinks =
+			append(e.Backlinks, template.HTML(makeLink(entries, name)))
 	}
 
-	for _, e := range entries {
-		f, err := os.Create(e.PathDestination)
-		if err != nil {
-			log.Fatalln(err)
-		}
-		for _, name := range e.backlinks {
-			e.Backlinks = append(e.Backlinks,
-				template.HTML(makeLink(&entries, name)))
-		}
-		if err = t.Execute(f, e); err != nil {
-			log.Fatalln(err)
-		}
-	}
+	return t.Execute(f, e)
+}
 
+func writeIndex(path string, t *template.Template,
+	entries *map[string]*Entry) error {
 	// Reorder entries reversely, primarily by date, secondarily by filename.
 	ordered := []*Entry{}
-	for _, e := range entries {
+	for _, e := range *entries {
 		ordered = append(ordered, e)
 	}
 
@@ -327,15 +303,226 @@ func main() {
 		return p2.Before(*p1)
 	})
 
-	// Execute a template from the standard input.
-	var input []byte
-	if input, err = ioutil.ReadAll(os.Stdin); err != nil {
+	f, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+
+	// 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 {
+		log.Println(err)
+	} else if meta.Title != "" {
+		_, _ = os.Stdout.WriteString("<h1>")
+		_ = xml.EscapeText(os.Stdout, []byte(meta.Title))
+		_, _ = os.Stdout.WriteString("</h1>\n")
+	}
+	_, _ = io.Copy(os.Stdout, html)
+}
+
+func main() {
+	if len(os.Args) < 2 {
+		singleFile()
+		return
+	}
+	if len(os.Args) != 4 {
+		log.Fatalf("usage: %s TEMPLATE INDEX DIRECTORY\n", os.Args[0])
+	}
+
+	argTemplate, argIndex, argDirectory := os.Args[1], os.Args[2], os.Args[3]
+
+	// Read a template for entries.
+	header, err := ioutil.ReadFile(argTemplate)
+	if err != nil {
+		log.Fatalln(err)
+	}
+	tmplEntry, err := template.New("entry").Parse(string(header))
+	if err != nil {
 		log.Fatalln(err)
 	}
 
-	// TODO(p): Splitting content to categories would be nice.
-	t, err = template.New("-").Parse(string(input))
-	if err = t.Execute(os.Stdout, ordered); err != nil {
+	// Read a template for the index from the standard input.
+	index, err := ioutil.ReadAll(os.Stdin)
+	if err != nil {
 		log.Fatalln(err)
 	}
+	tmplIndex, err := template.New("index").Parse(string(index))
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	// 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)
+	}
+
+	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)
+			}
+
+			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")
+		}
+	}
 }