cmd/scriggo: add LiveReload for automatic page reloads

This change adds LiveReload functionality, enabling automatic page
reloads in the browser whenever the template code changes.

The 'scriggo serve' command now injects JavaScript into the generated
page. Using Server-Side Events (SSE), it triggers a page reload whenever
the page’s template files change.

LiveReload can be disabled with the --disable-livereload flag.

Author: gazerro

cmd/scriggo/escapers.go

@@ -0,0 +1,85 @@
+// Copyright 2019 The Scriggo Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"io"
+)
+
+// jsStringEscapes contains the runes that must be escaped when placed within
+// a JavaScript and JSON string with single or double quotes, in addition to
+// the runes U+2028 and U+2029.
+var jsStringEscapes = [...]string{
+	0:    `\u0000`,
+	1:    `\u0001`,
+	2:    `\u0002`,
+	3:    `\u0003`,
+	4:    `\u0004`,
+	5:    `\u0005`,
+	6:    `\u0006`,
+	7:    `\u0007`,
+	'\b': `\b`,
+	'\t': `\t`,
+	'\n': `\n`,
+	'\v': `\u000b`,
+	'\f': `\f`,
+	'\r': `\r`,
+	14:   `\u000e`,
+	15:   `\u000f`,
+	16:   `\u0010`,
+	17:   `\u0011`,
+	18:   `\u0012`,
+	19:   `\u0013`,
+	20:   `\u0014`,
+	21:   `\u0015`,
+	22:   `\u0016`,
+	23:   `\u0017`,
+	24:   `\u0018`,
+	25:   `\u0019`,
+	26:   `\u001a`,
+	27:   `\u001b`,
+	28:   `\u001c`,
+	29:   `\u001d`,
+	30:   `\u001e`,
+	31:   `\u001f`,
+	'"':  `\"`,
+	'&':  `\u0026`,
+	'\'': `\u0027`,
+	'<':  `\u003c`,
+	'>':  `\u003e`,
+	'\\': `\\`,
+}
+
+// jsStringEscape escapes the string s so it can be placed within a JavaScript
+// and JSON string with single or double quotes, and write it to w.
+func jsStringEscape(w io.Writer, s string) {
+	last := 0
+	for i, c := range s {
+		var esc string
+		switch {
+		case int(c) < len(jsStringEscapes):
+			esc = jsStringEscapes[c]
+		case c == '\u2028':
+			esc = `\u2028`
+		case c == '\u2029':
+			esc = `\u2029`
+		}
+		if esc == "" {
+			continue
+		}
+		if last != i {
+			_, _ = io.WriteString(w, s[last:i])
+		}
+		_, _ = io.WriteString(w, esc)
+		if c == '\u2028' || c == '\u2029' {
+			last = i + 3
+		} else {
+			last = i + 1
+		}
+	}
+	if last != len(s) {
+		_, _ = io.WriteString(w, s[last:])
+	}
+}

cmd/scriggo/help.go

@@ -195,7 +195,7 @@ Examples:
 `
 
 const helpServe = `
-usage: scriggo serve [-S n] [--metrics]
+usage: scriggo serve [-S n] [--metrics] [--disable-livereload]
 
 Serve runs a web server and serves the template rooted at the current
 directory. It is useful to learn Scriggo templates.
@@ -218,7 +218,8 @@ it renders 'blog/index.html' or 'blog/index.md'.
 Markdown is converted to HTML with the Goldmark parser with the options
 html.WithUnsafe, parser.WithAutoHeadingID and extension.GFM.
 
-Templates are automatically rebuilt when a file changes.
+When a file is modified, the server automatically rebuilds templates, and the
+browser reloads the page.
 
 The -S flag prints the assembly code of the served file and n determines the
 maximum length, in runes, of disassembled Text instructions
@@ -228,6 +229,9 @@ maximum length, in runes, of disassembled Text instructions
     n < 0: all text
 
 The --metrics flags prints metrics about execution time.
+
+The --disable-livereload flag disables LiveReload, preventing automatic page
+reloads in the browser.
 `
 
 const helpScriggofile = `

cmd/scriggo/main.go

@@ -238,6 +238,7 @@ var commands = map[string]func(){
 		flag.Usage = commandsHelp["serve"]
 		s := flag.Int("S", 0, "print assembly listing. n determines the length of Text instructions.")
 		metrics := flag.Bool("metrics", false, "print metrics about file executions.")
+		disableLiveReload := flag.Bool("disable-livereload", false, "disable LiveReload.")
 		flag.Parse()
 		asm := -2 // -2: no assembler
 		flag.Visit(func(f *flag.Flag) {
@@ -248,7 +249,7 @@ var commands = map[string]func(){
 				}
 			}
 		})
-		err := serve(asm, *metrics)
+		err := serve(asm, *metrics, *disableLiveReload)
 		if err != nil {
 			exitError("%s", err)
 		}

cmd/scriggo/serve.go

@@ -30,12 +30,12 @@ import (
 // directory. metrics reports whether print the metrics. If asm is -1 or
 // greater, serve prints the assembly code of the served file and the value of
 // asm determines the maximum length, in runes, of disassembled Text
-// instructions
+// instructions. If disableLiveReload is true, it disables LiveReload.
 //
 //	asm > 0: at most asm runes; leading and trailing white space are removed
 //	asm == 0: no text
 //	asm == -1: all text
-func serve(asm int, metrics bool) error {
+func serve(asm int, metrics bool, disableLiveReload bool) error {
 
 	fsys, err := newTemplateFS(".")
 	if err != nil {
@@ -59,6 +59,9 @@ func serve(asm int, metrics bool) error {
 		templatesDependencies: map[string]map[string]struct{}{},
 		asm:                   asm,
 	}
+	if !disableLiveReload {
+		srv.liveReloads = map[*liveReload]struct{}{}
+	}
 	if metrics {
 		srv.metrics.active = true
 		srv.metrics.header = true
@@ -68,27 +71,35 @@ func serve(asm int, metrics bool) error {
 			select {
 			case name := <-fsys.Changed():
 				srv.Lock()
+				invalidated := map[string]bool{}
 				if _, ok := srv.templates[name]; ok {
 					delete(srv.templates, name)
 					for _, dependents := range srv.templatesDependencies {
 						delete(dependents, name)
 					}
+					invalidated[name] = true
 				} else {
-					var invalidatedFiles []string
 					for dependency, dependents := range srv.templatesDependencies {
 						if dependency == name {
 							for d := range dependents {
 								delete(srv.templates, d)
-								invalidatedFiles = append(invalidatedFiles, d)
+								invalidated[d] = true
 							}
 						}
 					}
-					for _, invalidated := range invalidatedFiles {
+					for invalidated := range invalidated {
 						for _, dependents := range srv.templatesDependencies {
 							delete(dependents, invalidated)
 						}
 					}
 				}
+				if len(invalidated) > 0 {
+					for r := range srv.liveReloads {
+						if invalidated[r.file+".html"] || invalidated[r.file+".md"] {
+							go func() { r.reload() }()
+						}
+					}
+				}
 				srv.Unlock()
 			case err := <-fsys.Errors:
 				srv.logf("%v", err)
@@ -120,13 +131,83 @@ type server struct {
 	sync.Mutex
 	templates             map[string]*scriggo.Template
 	templatesDependencies map[string]map[string]struct{}
+	liveReloads           map[*liveReload]struct{}
 	metrics               struct {
 		active bool
 		header bool
 	}
 }
 
 func (srv *server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	if r.Header.Get("Accept") == "text/event-stream" {
+		srv.serveLiveReload(w, r)
+		return
+	}
+	srv.serveTemplate(w, r)
+}
+
+type liveReload struct {
+	file string // file path without extension
+
+	sync.Mutex
+	w io.Writer
+}
+
+var reload = []byte("data: reload\n\n")
+
+func (lr *liveReload) reload() {
+	lr.Lock()
+	_, _ = lr.w.Write(reload)
+	lr.w.(http.Flusher).Flush()
+	lr.Unlock()
+}
+
+func (srv *server) serveLiveReload(w http.ResponseWriter, r *http.Request) {
+
+	if _, ok := w.(http.Flusher); !ok || srv.liveReloads == nil {
+		http.Error(w, "Live reload is not supported", http.StatusUnsupportedMediaType)
+		return
+	}
+
+	file := r.URL.Path[1:]
+	if file == "" || strings.HasSuffix(file, "/") {
+		file += "index"
+	}
+	if ext := path.Ext(file); ext != "" {
+		file = file[:len(file)-len(ext)]
+	}
+
+	lr := &liveReload{
+		file: file,
+		w:    w,
+	}
+
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+	w.WriteHeader(200)
+
+	srv.Lock()
+	srv.liveReloads[lr] = struct{}{}
+	_, ok := srv.templates[file+".html"]
+	if !ok {
+		_, ok = srv.templates[file+".md"]
+	}
+	srv.Unlock()
+
+	if !ok {
+		lr.reload()
+	}
+
+	<-r.Context().Done()
+
+	srv.Lock()
+	delete(srv.liveReloads, lr)
+	srv.Unlock()
+
+}
+
+func (srv *server) serveTemplate(w http.ResponseWriter, r *http.Request) {
 
 	name := r.URL.Path[1:]
 	if name == "" || strings.HasSuffix(name, "/") {
@@ -221,10 +302,32 @@ func (srv *server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	}
 	runTime := time.Since(start)
 
+	s := b.Bytes()
+	i := indexEndBody(s)
+	if i == -1 {
+		i = len(s)
+	}
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	_, err = b.WriteTo(w)
-	if err != nil {
-		srv.logf("%s", err)
+	if srv.liveReloads == nil {
+		_, _ = w.Write(s)
+	} else {
+		_, _ = w.Write(s[:i])
+		_, _ = io.WriteString(w, `<script>
+	// Scriggo 	LiveReload.
+	(function () {
+		if (typeof EventSource !== 'function') return;
+		const es = new EventSource('`)
+		jsStringEscape(w, r.URL.Path)
+		_, _ = io.WriteString(w, `');
+		es.onmessage = function(e) {
+			if (e.data === 'reload') {
+				es.close();
+				location.reload();
+			}
+		};
+	})();
+</script>`)
+		_, _ = w.Write(s[i:])
 	}
 
 	if srv.metrics.active {
@@ -269,3 +372,54 @@ func (srv *server) logf(format string, a ...interface{}) {
 	println()
 	srv.metrics.header = true
 }
+
+// indexEndBody locates the closing "</body>" tag in s, ignoring case and
+// permitting spaces before '>'. If the tag is found, the function returns its
+// index, unless the tag's line contains only whitespaces before it; in that
+// case, it returns the index of the newline ('\n') at the start of the line.
+// If no closing tag is found, it returns -1.
+func indexEndBody(s []byte) int {
+	for {
+		i := bytes.LastIndex(s, []byte("</"))
+		if i == -1 {
+			return -1
+		}
+		if isBodyTag(s[i+2:]) {
+			for j := i - 1; j >= 0; j-- {
+				switch s[j] {
+				case ' ', '\t', '\r':
+					continue
+				case '\n':
+					if j > 0 && s[j-1] == '\r' {
+						j--
+					}
+					return j
+				}
+				break
+			}
+			return i
+		}
+		s = s[:i]
+	}
+}
+
+// isBodyTag checks if s starts with "body>", ignoring case and allowing spaces
+// before '>'.
+func isBodyTag(s []byte) bool {
+	if len(s) < 5 {
+		return false
+	}
+	if !bytes.EqualFold(s[:4], []byte("body")) {
+		return false
+	}
+	for i := 4; i < len(s); i++ {
+		switch s[i] {
+		case '>':
+			return true
+		case ' ', '\t', '\n', '\r':
+			continue
+		}
+		break
+	}
+	return false
+}