all: return error instead of call log.Fatal on non main packages

The library, non-main packages, should never call Fatal or panic,
its up to the main package or the caller on how to handle it.

While at it, fix the returned error to use log prefix and the error
value, remove the "ciigo: " prefix.

8 files changed, 103 insertions, 50 deletions

diff --git a/ciigo.go b/ciigo.go
index b95a926..4bec612 100644
--- a/ciigo.go
+++ b/ciigo.go
@@ -13,7 +13,6 @@ package ciigo
 
 import (
 	"fmt"
-	"log"
 	"os"
 	"path/filepath"
 	"strings"
@@ -46,19 +45,26 @@ var (
 // If htmlTemplate is empty it will default to use embedded HTML template.
 // See template_index_html.go for template format.
 //
-func Convert(dir, htmlTemplate string) {
+func Convert(dir, htmlTemplate string) (err error) {
+	logp := "Convert"
+
 	if len(dir) == 0 {
 		dir = "."
 	}
 
 	htmlg, err := newHTMLGenerator(nil, htmlTemplate, true)
 	if err != nil {
-		log.Fatalf("Convert: %s", err)
+		return fmt.Errorf("%s: %w", logp, err)
 	}
 
-	fileMarkups := listFileMarkups(dir)
+	fileMarkups, err := listFileMarkups(dir)
+	if err != nil {
+		return fmt.Errorf("%s: %w", logp, err)
+	}
 
 	htmlg.convertFileMarkups(fileMarkups)
+
+	return nil
 }
 
 //
@@ -71,7 +77,9 @@ func Convert(dir, htmlTemplate string) {
 // If htmlTemplate is empty it will default to use embedded HTML template.
 // See template_index_html.go for template format.
 //
-func Generate(opts *GenerateOptions) {
+func Generate(opts *GenerateOptions) (err error) {
+	logp := "Generate"
+
 	if opts == nil {
 		opts = &GenerateOptions{}
 	}
@@ -79,10 +87,13 @@ func Generate(opts *GenerateOptions) {
 
 	htmlg, err := newHTMLGenerator(nil, opts.HTMLTemplate, true)
 	if err != nil {
-		log.Fatal("ciigo.Generate: " + err.Error())
+		return fmt.Errorf("%s: %w", logp, err)
 	}
 
-	fileMarkups := listFileMarkups(opts.Root)
+	fileMarkups, err := listFileMarkups(opts.Root)
+	if err != nil {
+		return fmt.Errorf("%s: %w", logp, err)
+	}
 
 	htmlg.convertFileMarkups(fileMarkups)
 
@@ -92,37 +103,45 @@ func Generate(opts *GenerateOptions) {
 	}
 	mfs, err := memfs.New(memfsOpts)
 	if err != nil {
-		log.Fatal("ciigo.Generate: " + err.Error())
+		return fmt.Errorf("%s: %w", logp, err)
 	}
 
 	if len(opts.HTMLTemplate) > 0 {
 		_, err = mfs.AddFile(internalTemplatePath, opts.HTMLTemplate)
 		if err != nil {
-			log.Fatalf("ciigo.Generate: AddFile %s: %s",
-				opts.HTMLTemplate, err.Error())
+			return fmt.Errorf("%s: %w", logp, err)
 		}
 	}
 
 	err = mfs.GoGenerate(opts.GenPackageName, opts.GenVarName,
 		opts.GenGoFileName, memfs.EncodingGzip)
 	if err != nil {
-		log.Fatal("ciigo.Generate: " + err.Error())
+		return fmt.Errorf("%s: %w", logp, err)
 	}
+
+	return nil
 }
 
 //
 // Serve the content at directory "dir" using HTTP server at specific
 // "address".
 //
-func Serve(mfs *memfs.MemFS, dir, address, htmlTemplate string) {
+func Serve(mfs *memfs.MemFS, dir, address, htmlTemplate string) (err error) {
 	if len(dir) == 0 {
 		dir = defDir
 	}
 	if len(address) == 0 {
 		address = defAddress
 	}
-	srv := newServer(mfs, dir, address, htmlTemplate)
-	srv.start()
+	srv, err := newServer(mfs, dir, address, htmlTemplate)
+	if err != nil {
+		return fmt.Errorf("Serve: %w", err)
+	}
+	err = srv.start()
+	if err != nil {
+		return fmt.Errorf("Serve: %w", err)
+	}
+	return nil
 }
 
 //
@@ -162,15 +181,17 @@ func isExtensionMarkup(ext string) bool {
 // listFileMarkups find any markup files inside the content directory,
 // recursively.
 //
-func listFileMarkups(dir string) (fileMarkups map[string]*fileMarkup) {
+func listFileMarkups(dir string) (fileMarkups map[string]*fileMarkup, err error) {
+	logp := "listFileMarkups"
+
 	d, err := os.Open(dir)
 	if err != nil {
-		log.Fatal("ciigo: listFileMarkups: os.Open: ", err)
+		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
 	fis, err := d.Readdir(0)
 	if err != nil {
-		log.Fatal("generate: " + err.Error())
+		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
 	fileMarkups = make(map[string]*fileMarkup)
@@ -180,7 +201,11 @@ func listFileMarkups(dir string) (fileMarkups map[string]*fileMarkup) {
 
 		if fi.IsDir() && name[0] != '.' {
 			newdir := filepath.Join(dir, fi.Name())
-			for k, v := range listFileMarkups(newdir) {
+			fmarkups, err := listFileMarkups(newdir)
+			if err != nil {
+				return nil, fmt.Errorf("%s: %w", logp, err)
+			}
+			for k, v := range fmarkups {
 				fileMarkups[k] = v
 			}
 			continue
@@ -208,5 +233,5 @@ func listFileMarkups(dir string) (fileMarkups map[string]*fileMarkup) {
 		fileMarkups[filePath] = fmarkup
 	}
 
-	return fileMarkups
+	return fileMarkups, nil
 }
diff --git a/cmd/ciigo-example/main.go b/cmd/ciigo-example/main.go
index fba1e8b..3ad8a93 100644
--- a/cmd/ciigo-example/main.go
+++ b/cmd/ciigo-example/main.go
@@ -9,6 +9,8 @@
 package main
 
 import (
+	"log"
+
 	"github.com/shuLhan/share/lib/memfs"
 
 	"git.sr.ht/~shulhan/ciigo"
@@ -17,5 +19,8 @@ import (
 var ciigoFS *memfs.MemFS
 
 func main() {
-	ciigo.Serve(ciigoFS, "_example", ":8080", "_example/html.tmpl")
+	err := ciigo.Serve(ciigoFS, "_example", ":8080", "_example/html.tmpl")
+	if err != nil {
+		log.Fatal(err)
+	}
 }
diff --git a/cmd/ciigo/main.go b/cmd/ciigo/main.go
index 51166f4..a86ac91 100644
--- a/cmd/ciigo/main.go
+++ b/cmd/ciigo/main.go
@@ -34,6 +34,7 @@ package main
 import (
 	"flag"
 	"fmt"
+	"log"
 	"os"
 	"strings"
 
@@ -68,24 +69,29 @@ func main() {
 		dir = ciigo.DefaultRoot
 	}
 
+	var err error
 	command = strings.ToLower(command)
+
 	switch command {
 	case "convert":
-		ciigo.Convert(dir, *htmlTemplate)
+		err = ciigo.Convert(dir, *htmlTemplate)
 	case "generate":
 		genOpts := ciigo.GenerateOptions{
 			Root:          dir,
 			HTMLTemplate:  *htmlTemplate,
 			GenGoFileName: *outputFile,
 		}
-		ciigo.Generate(&genOpts)
+		err = ciigo.Generate(&genOpts)
 	case "serve":
 		debug.Value = 1
-		ciigo.Serve(nil, dir, *address, *htmlTemplate)
+		err = ciigo.Serve(nil, dir, *address, *htmlTemplate)
 	default:
 		usage()
 		os.Exit(1)
 	}
+	if err != nil {
+		log.Fatal(err)
+	}
 }
 
 func usage() {
diff --git a/filemarkup.go b/filemarkup.go
index c4a8ede..b53862c 100644
--- a/filemarkup.go
+++ b/filemarkup.go
@@ -19,13 +19,14 @@ type fileMarkup struct {
 }
 
 func newFileMarkup(filePath string, fi os.FileInfo) (fmarkup *fileMarkup, err error) {
+	logp := "newFileMarkup"
 	if len(filePath) == 0 {
-		return nil, fmt.Errorf("ciigo: newFileMarkup: empty path")
+		return nil, fmt.Errorf("%s: empty path", logp)
 	}
 	if fi == nil {
 		fi, err = os.Stat(filePath)
 		if err != nil {
-			return nil, fmt.Errorf("newFileMarkup: " + err.Error())
+			return nil, fmt.Errorf("%s: %w", logp, err)
 		}
 	}
 
diff --git a/htmlgenerator.go b/htmlgenerator.go
index 0dd819a..ab90b94 100644
--- a/htmlgenerator.go
+++ b/htmlgenerator.go
@@ -101,8 +101,9 @@ func (htmlg *htmlGenerator) convert(fmarkup *fileMarkup) (err error) {
 // convertFileMarkups convert markup files into HTML.
 //
 func (htmlg *htmlGenerator) convertFileMarkups(fileMarkups map[string]*fileMarkup) {
+	logp := "convertFileMarkups"
 	for _, fmarkup := range fileMarkups {
-		fmt.Printf("ciigo: converting %q to %q => ", fmarkup.path,
+		fmt.Printf("%s: converting %q to %q => ", logp, fmarkup.path,
 			fmarkup.fhtml.path)
 
 		err := htmlg.convert(fmarkup)
diff --git a/internal/cmd/generate/main.go b/internal/cmd/generate/main.go
index 3e9dd8d..914e9a1 100644
--- a/internal/cmd/generate/main.go
+++ b/internal/cmd/generate/main.go
@@ -6,7 +6,11 @@
 
 package main
 
-import "git.sr.ht/~shulhan/ciigo"
+import (
+	"log"
+
+	"git.sr.ht/~shulhan/ciigo"
+)
 
 func main() {
 	opts := ciigo.GenerateOptions{
@@ -16,5 +20,8 @@ func main() {
 		GenVarName:     "ciigoFS",
 		GenGoFileName:  "cmd/ciigo-example/static.go",
 	}
-	ciigo.Generate(&opts)
+	err := ciigo.Generate(&opts)
+	if err != nil {
+		log.Fatal(err)
+	}
 }
diff --git a/server.go b/server.go
index 01a1c0b..3855eed 100644
--- a/server.go
+++ b/server.go
@@ -8,7 +8,6 @@ import (
 	"bytes"
 	"fmt"
 	"html/template"
-	"log"
 	"net/http"
 	"strings"
 
@@ -34,8 +33,8 @@ type server struct {
 // The htmlTemplate parameter is optional, if not set its default to
 // embedded HTML template.
 //
-func newServer(mfs *memfs.MemFS, root, address, htmlTemplate string) (srv *server) {
-	var err error
+func newServer(mfs *memfs.MemFS, root, address, htmlTemplate string) (srv *server, err error) {
+	logp := "newServer"
 
 	srv = &server{
 		opts: &libhttp.ServerOptions{
@@ -51,7 +50,7 @@ func newServer(mfs *memfs.MemFS, root, address, htmlTemplate string) (srv *serve
 
 	srv.http, err = libhttp.NewServer(srv.opts)
 	if err != nil {
-		log.Fatal("ciigo: libhttp.NewServer: " + err.Error())
+		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
 	epInSearch := &libhttp.Endpoint{
@@ -64,58 +63,67 @@ func newServer(mfs *memfs.MemFS, root, address, htmlTemplate string) (srv *serve
 
 	err = srv.http.RegisterEndpoint(epInSearch)
 	if err != nil {
-		log.Fatal("ciigo: " + err.Error())
+		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
 	srv.htmlg, err = newHTMLGenerator(mfs, htmlTemplate, srv.opts.Development)
 	if err != nil {
-		log.Fatal("ciigo: " + err.Error())
+		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
 	if srv.opts.Development {
 		srv.watcher, err = newWatcher(srv.htmlg, root)
 		if err != nil {
-			log.Fatal("ciigo: " + err.Error())
+			return nil, fmt.Errorf("%s: %w", logp, err)
+		}
+
+		srv.watcher.fileMarkups, err = listFileMarkups(root)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", logp, err)
 		}
 
-		srv.watcher.fileMarkups = listFileMarkups(root)
 		srv.htmlg.convertFileMarkups(srv.watcher.fileMarkups)
 	}
 
-	return srv
+	return srv, nil
 }
 
 //
 // start the web server.
 //
-func (srv *server) start() {
+func (srv *server) start() (err error) {
+	logp := "start"
+
 	if srv.opts.Development {
 		err := srv.watcher.start()
 		if err != nil {
-			log.Fatal("ciigo: " + err.Error())
+			return fmt.Errorf("%s: %w", logp, err)
 		}
 	}
 
 	fmt.Printf("ciigo: starting HTTP server at %q for %q\n",
 		srv.opts.Address, srv.opts.Root)
 
-	err := srv.http.Start()
+	err = srv.http.Start()
 	if err != nil {
-		log.Fatal("ciigo: " + err.Error())
+		return fmt.Errorf("%s: %w", logp, err)
 	}
+
+	return nil
 }
 
 func (srv *server) onSearch(res http.ResponseWriter, req *http.Request, reqBody []byte) (
 	resBody []byte, err error,
 ) {
 	var bufSearch, buf bytes.Buffer
+	logp := "onSearch"
 
 	q := req.Form.Get("q")
 	results := srv.http.Memfs.Search(strings.Fields(q), 0)
 
 	err = srv.htmlg.tmplSearch.Execute(&bufSearch, results)
 	if err != nil {
-		return nil, fmt.Errorf("ciigo.onSearch: " + err.Error())
+		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
 	fhtml := &fileHTML{
@@ -124,7 +132,7 @@ func (srv *server) onSearch(res http.ResponseWriter, req *http.Request, reqBody
 
 	err = srv.htmlg.tmpl.Execute(&buf, fhtml)
 	if err != nil {
-		return nil, fmt.Errorf("ciigo.onSearch: " + err.Error())
+		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
 	resBody = buf.Bytes()
diff --git a/watcher.go b/watcher.go
index a619095..a9b2428 100644
--- a/watcher.go
+++ b/watcher.go
@@ -80,7 +80,7 @@ func (w *watcher) onChangeFileMarkup(ns *libio.NodeState) {
 	}
 
 	if ns.State == libio.FileStateDeleted {
-		fmt.Printf("ciigo: %s: %q deleted\n", logp, ns.Node.SysPath)
+		fmt.Printf("%s: %q deleted\n", logp, ns.Node.SysPath)
 		fmarkup, ok := w.fileMarkups[ns.Node.SysPath]
 		if ok {
 			delete(w.fileMarkups, ns.Node.SysPath)
@@ -91,7 +91,7 @@ func (w *watcher) onChangeFileMarkup(ns *libio.NodeState) {
 
 	fmarkup := w.fileMarkups[ns.Node.SysPath]
 	if fmarkup == nil {
-		fmt.Printf("ciigo: %s: %s created\n", logp, ns.Node.SysPath)
+		fmt.Printf("%s: %s created\n", logp, ns.Node.SysPath)
 		fmarkup, err = newFileMarkup(ns.Node.SysPath, nil)
 		if err != nil {
 			log.Printf("%s: %s\n", logp, err)
@@ -100,7 +100,7 @@ func (w *watcher) onChangeFileMarkup(ns *libio.NodeState) {
 
 		w.fileMarkups[ns.Node.SysPath] = fmarkup
 	} else {
-		fmt.Printf("ciigo: %s: %s updated\n", logp, ns.Node.SysPath)
+		fmt.Printf("%s: %s updated\n", logp, ns.Node.SysPath)
 	}
 
 	err = w.htmlg.convert(fmarkup)
@@ -120,11 +120,11 @@ func (w *watcher) onChangeHTMLTemplate(ns *libio.NodeState) {
 	logp := "onChangeHTMLTemplate"
 
 	if ns.State == libio.FileStateDeleted {
-		log.Printf("ciigo: HTML template file %q has been deleted\n",
-			ns.Node.SysPath)
+		log.Printf("%s: HTML template file %q has been deleted\n",
+			logp, ns.Node.SysPath)
 		err = w.htmlg.htmlTemplateUseInternal()
 	} else {
-		fmt.Printf("ciigo: recompiling HTML template %q ...\n",
+		fmt.Printf("%s: recompiling HTML template %q ...\n", logp,
 			ns.Node.SysPath)
 		err = w.htmlg.htmlTemplateReload()
 	}
@@ -133,7 +133,7 @@ func (w *watcher) onChangeHTMLTemplate(ns *libio.NodeState) {
 		return
 	}
 
-	fmt.Printf("ciigo: regenerate all markup files ...\n")
+	fmt.Printf("%s: regenerate all markup files ...\n", logp)
 	w.htmlg.convertFileMarkups(w.fileMarkups)
 }