all: rewrite to use the watcher

Now that we have the watcher which task are to watch the asciidoc
files and template files, we can use it in server to minimize duplicate
code.

This changes refactoring the htmlGenerator to initialize the HTML
template from internal or memfs, so the caller did not need to check by
itself.

1 files changed, 21 insertions, 158 deletions

diff --git a/server.go b/server.go
index 89cc856..01a1c0b 100644
--- a/server.go
+++ b/server.go
@@ -8,29 +8,23 @@ import (
 	"bytes"
 	"fmt"
 	"html/template"
-	"io/ioutil"
 	"log"
 	"net/http"
-	"path"
-	"path/filepath"
 	"strings"
-	"time"
 
 	"github.com/shuLhan/share/lib/debug"
 	libhttp "github.com/shuLhan/share/lib/http"
-	libio "github.com/shuLhan/share/lib/io"
 	"github.com/shuLhan/share/lib/memfs"
 )
 
 //
-// server contains the HTTP server.
+// server contains the HTTP server that serve the generated HTML files.
 //
 type server struct {
-	http        *libhttp.Server
-	opts        *libhttp.ServerOptions
-	htmlg       *htmlGenerator
-	fileMarkups []*fileMarkup
-	dw          *libio.DirWatcher
+	http    *libhttp.Server
+	opts    *libhttp.ServerOptions
+	htmlg   *htmlGenerator
+	watcher *watcher
 }
 
 //
@@ -73,173 +67,42 @@ func newServer(mfs *memfs.MemFS, root, address, htmlTemplate string) (srv *serve
 		log.Fatal("ciigo: " + err.Error())
 	}
 
-	srv.initHTMLGenerator(htmlTemplate)
-
-	if srv.opts.Development {
-		srv.fileMarkups = listFileMarkups(root)
-		srv.htmlg.convertFileMarkups(srv.fileMarkups, false)
-	}
-
-	return srv
-}
-
-//
-// start the web server.
-//
-func (srv *server) start() {
-	if srv.opts.Development {
-		srv.autoGenerate()
-	}
-
-	fmt.Printf("ciigo: starting HTTP server at %q for %q\n",
-		srv.opts.Address, srv.opts.Root)
-
-	err := srv.http.Start()
-	if err != nil {
-		log.Fatal("web: Start: " + err.Error())
-	}
-}
-
-func (srv *server) autoGenerate() {
-	srv.dw = &libio.DirWatcher{
-		Options: memfs.Options{
-			Root: srv.opts.Root,
-			Includes: []string{
-				`.*\.adoc$`,
-				`.*\.md$`,
-			},
-			Excludes: []string{
-				`assets/.*`,
-				`.*\.html$`,
-				`^\..*`,
-			},
-		},
-		Delay:    time.Second,
-		Callback: srv.onChangeFileMarkup,
-	}
-
-	err := srv.dw.Start()
+	srv.htmlg, err = newHTMLGenerator(mfs, htmlTemplate, srv.opts.Development)
 	if err != nil {
-		log.Fatal("ciigo: autoGenerate: " + err.Error())
-	}
-
-	if len(srv.htmlg.path) > 0 {
-		_, err = libio.NewWatcher(srv.htmlg.path, 0, srv.onChangeHTMLTemplate)
-		if err != nil {
-			log.Fatal("ciigo: autoGenerate: " + err.Error())
-		}
-	}
-}
-
-func (srv *server) initHTMLGenerator(htmlTemplate string) {
-	if len(htmlTemplate) == 0 {
-		srv.htmlg = newHTMLGenerator("", templateIndexHTML)
-		return
+		log.Fatal("ciigo: " + err.Error())
 	}
 
-	var (
-		bhtml       []byte
-		err         error
-		htmlContent string
-	)
-
-	htmlTemplate = filepath.Clean(htmlTemplate)
-
 	if srv.opts.Development {
-		bhtml, err = ioutil.ReadFile(htmlTemplate)
+		srv.watcher, err = newWatcher(srv.htmlg, root)
 		if err != nil {
-			log.Fatal("server.initHTMLGenerator: " + err.Error())
-		}
-	} else {
-		tmplNode, err := srv.http.Memfs.Get(internalTemplatePath)
-		if err != nil {
-			log.Fatalf("server.initHTMLGenerator: Memfs.Get %s: %s",
-				htmlTemplate, err.Error())
-		}
-		bhtml, err = tmplNode.Decode()
-		if err != nil {
-			log.Fatal("server.initHTMLGenerator: " + err.Error())
+			log.Fatal("ciigo: " + err.Error())
 		}
 
-		// Set to empty value to prevent watcher running on template
-		// file.
-		htmlTemplate = ""
+		srv.watcher.fileMarkups = listFileMarkups(root)
+		srv.htmlg.convertFileMarkups(srv.watcher.fileMarkups)
 	}
 
-	htmlContent = string(bhtml)
-	srv.htmlg = newHTMLGenerator(htmlTemplate, htmlContent)
+	return srv
 }
 
 //
-// onChangeFileMarkup watch the markup files inside the "content" directory,
-// and re-generate them into HTML file when changed.
+// start the web server.
 //
-func (srv *server) onChangeFileMarkup(ns *libio.NodeState) {
-	if ns.State == libio.FileStateDeleted {
-		fmt.Printf("ciigo: onChangeFileMarkup: %q deleted\n", ns.Node.SysPath)
-		return
-	}
-
-	ext := strings.ToLower(path.Ext(ns.Node.SysPath))
-	if !isExtensionMarkup(ext) {
-		return
-	}
-
-	fmt.Println("ciigo: onChangeFileMarkup: " + ns.Node.SysPath)
-
-	var (
-		fmarkup *fileMarkup
-		err     error
-	)
-
-	switch ns.State {
-	case libio.FileStateCreated:
-		fmarkup, err = newFileMarkup(ns.Node.SysPath, nil)
+func (srv *server) start() {
+	if srv.opts.Development {
+		err := srv.watcher.start()
 		if err != nil {
-			log.Println(err)
-			return
-		}
-
-		srv.fileMarkups = append(srv.fileMarkups, fmarkup)
-
-	case libio.FileStateModified:
-		for x := 0; x < len(srv.fileMarkups); x++ {
-			if srv.fileMarkups[x].path == ns.Node.SysPath {
-				fmarkup = srv.fileMarkups[x]
-				break
-			}
+			log.Fatal("ciigo: " + err.Error())
 		}
-		if fmarkup == nil {
-			fmarkup, err = newFileMarkup(ns.Node.SysPath, nil)
-			if err != nil {
-				log.Println(err)
-				return
-			}
-
-			srv.fileMarkups = append(srv.fileMarkups, fmarkup)
-		}
-	}
-
-	srv.htmlg.convert(fmarkup, true)
-}
-
-func (srv *server) onChangeHTMLTemplate(ns *libio.NodeState) {
-	if ns.State == libio.FileStateDeleted {
-		fmt.Printf("watchHTMLTemplate: file %q deleted\n", ns.Node.SysPath)
-		return
 	}
 
-	fmt.Println("web: recompiling HTML template  ...")
+	fmt.Printf("ciigo: starting HTTP server at %q for %q\n",
+		srv.opts.Address, srv.opts.Root)
 
-	err := srv.htmlg.reloadTemplate()
+	err := srv.http.Start()
 	if err != nil {
-		log.Println("watchHTMLTemplate: loadTemplate: " + err.Error())
-		return
+		log.Fatal("ciigo: " + err.Error())
 	}
-
-	fmt.Println("web: regenerate all markup files ... ")
-
-	srv.htmlg.convertFileMarkups(srv.fileMarkups, true)
 }
 
 func (srv *server) onSearch(res http.ResponseWriter, req *http.Request, reqBody []byte) (