remove concept of prod and dev assets

instead always do the "prod" thing, but use entr for restarting the
server for all assets

_do_build_server

@@ -1,17 +1,8 @@
 #!/bin/sh
 
 source ./_build_vars
-find server/assets/ \
-    -type f \
-    -exec go run \
-        cmd/gonicembed/main.go \
-        -out-path server/assets_bytes.go \
-        -tag-list embed \
-        -package-name server \
-        -assets-var-name AssetBytes \
-        -asset-path-prefix server/assets/ \
-        {} +
+./_do_gen_assets
 go build \
     -o gonic \
-    -tags "$(tr '\n' ' ' < _build_tags) embed" \
+    -tags "$(tr '\n' ' ' < _build_tags)" \
     cmd/gonic/main.go

_do_gen_assets

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+find server/assets/ \
+    -type f \
+    -exec go run \
+        cmd/gonicembed/main.go \
+        -out-path server/assets_bytes.go \
+        -package-name server \
+        -assets-var-name assetBytes \
+        -asset-path-prefix server/assets/ \
+        {} +

_do_run_server

@@ -1,6 +1,7 @@
 #!/bin/sh
 
 source ./_build_vars
+./_do_gen_assets
 go run \
     -tags "$(tr '\n' ' ' < _build_tags)" \
     cmd/gonic/main.go \

_do_run_server_live

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+find server/assets/ | entr -r ./_do_run_server $@

cmd/gonic/main.go

@@ -54,7 +54,6 @@ func main() {
 		db,
 		*musicPath,
 		*listenAddr,
-		"server/assets/",
 	)
 	err = s.SetupAdmin()
 	if err != nil {

cmd/gonicembed/main.go

@@ -21,7 +21,7 @@ const (
 	fileHeader = `// file generated with embed tool
 // do not edit
 
-// +build %s
+// %s
 
 package %s
 import "time"
@@ -82,6 +82,9 @@ func processAssets(c *config, files []string) error {
 	if err != nil {
 		return errors.Wrap(err, "creating out path")
 	}
+	if c.tagList != "" {
+		c.tagList = fmt.Sprintf("+build %s", c.tagList)
+	}
 	outWriter.Write([]byte(fmt.Sprintf(fileHeader,
 		c.tagList,
 		c.packageName,

server/assets_getters.go

@@ -0,0 +1,27 @@
+package server
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"time"
+)
+
+var errAssetNotFound = errors.New("asset not found")
+
+func findAsset(path string) (time.Time, io.ReadSeeker, error) {
+	asset, ok := assetBytes[path]
+	if !ok {
+		return time.Time{}, nil, errAssetNotFound
+	}
+	reader := bytes.NewReader(asset.Bytes)
+	return asset.ModTime, reader, nil
+}
+
+func findAssetBytes(path string) (time.Time, []byte, error) {
+	asset, ok := assetBytes[path]
+	if !ok {
+		return time.Time{}, nil, errAssetNotFound
+	}
+	return asset.ModTime, asset.Bytes, nil
+}

server/assets_getters_dev.go

@@ -1,39 +0,0 @@
-// +build !embed
-
-package server
-
-import (
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/pkg/errors"
-)
-
-func (a *Assets) Find(path string) (time.Time, io.ReadSeeker, error) {
-	fullPath := filepath.Join(a.BasePath, path)
-	info, err := os.Stat(fullPath)
-	if err != nil {
-		return time.Time{}, nil, errors.Wrap(err, "statting asset")
-	}
-	file, err := os.Open(fullPath)
-	if err != nil {
-		return time.Time{}, nil, errors.Wrapf(ErrAssetNotFound, "%v", err)
-	}
-	return info.ModTime(), file, nil
-}
-
-func (a *Assets) FindBytes(path string) (time.Time, []byte, error) {
-	fullPath := filepath.Join(a.BasePath, path)
-	info, err := os.Stat(fullPath)
-	if err != nil {
-		return time.Time{}, nil, errors.Wrap(err, "statting asset")
-	}
-	file, err := ioutil.ReadFile(fullPath)
-	if err != nil {
-		return time.Time{}, nil, errors.Wrapf(ErrAssetNotFound, "%v", err)
-	}
-	return info.ModTime(), file, nil
-}

server/assets_getters_prod.go

@@ -1,26 +0,0 @@
-// +build embed
-
-package server
-
-import (
-	"bytes"
-	"io"
-	"time"
-)
-
-func (_ *Assets) Find(path string) (time.Time, io.ReadSeeker, error) {
-	asset, ok := AssetBytes[path]
-	if !ok {
-		return time.Time{}, nil, ErrAssetNotFound
-	}
-	reader := bytes.NewReader(asset.Bytes)
-	return asset.ModTime, reader, nil
-}
-
-func (_ *Assets) FindBytes(path string) (time.Time, []byte, error) {
-	asset, ok := AssetBytes[path]
-	if !ok {
-		return time.Time{}, nil, ErrAssetNotFound
-	}
-	return asset.ModTime, asset.Bytes, nil
-}

server/server.go

@@ -1,7 +1,6 @@
 package server
 
 import (
-	"errors"
 	"net/http"
 	"time"
 
@@ -10,8 +9,7 @@ import (
 )
 
 type Server struct {
-	mux    *http.ServeMux
-	assets *Assets
+	mux *http.ServeMux
 	*handler.Controller
 	*http.Server
 }
@@ -20,7 +18,6 @@ func New(
 	db *db.DB,
 	musicPath string,
 	listenAddr string,
-	assetPath string,
 ) *Server {
 	mux := http.NewServeMux()
 	server := &http.Server{
@@ -34,23 +31,13 @@ func New(
 		DB:        db,
 		MusicPath: musicPath,
 	}
-	assets := &Assets{
-		BasePath: assetPath,
-	}
 	return &Server{
 		mux:        mux,
-		assets:     assets,
 		Server:     server,
 		Controller: controller,
 	}
 }
 
-var ErrAssetNotFound = errors.New("asset not found")
-
-type Assets struct {
-	BasePath string
-}
-
 type middleware func(next http.HandlerFunc) http.HandlerFunc
 
 func newChain(wares ...middleware) middleware {

server/server_admin.go

@@ -44,21 +44,20 @@ var (
 
 type templateMap map[string]*template.Template
 
-func parseFromPaths(assets *Assets, base *template.Template,
-	paths []string, destination templateMap) error {
+func parseFromPaths(base *template.Template, paths []string, dest templateMap) error {
 	for _, path := range paths {
-		_, tmplBytes, err := assets.FindBytes(path)
+		_, tmplBytes, err := findAssetBytes(path)
 		if err != nil {
 			return errors.Wrapf(err, "getting template %q from assets", path)
 		}
 		tmplStr := string(tmplBytes)
-		if destination != nil {
+		if dest != nil {
 			// we have a destination. meaning this template is a page.
 			// instead of parsing as usual, we need to clone and add to the
 			// template map
 			clone := template.Must(base.Clone())
 			tmplKey := filepath.Base(path)
-			destination[tmplKey] = template.Must(clone.Parse(tmplStr))
+			dest[tmplKey] = template.Must(clone.Parse(tmplStr))
 			continue
 		}
 		_ = template.Must(base.Parse(tmplStr))
@@ -66,9 +65,9 @@ func parseFromPaths(assets *Assets, base *template.Template,
 	return nil
 }
 
-func staticHandler(assets *Assets, path string) http.HandlerFunc {
+func staticHandler(path string) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		modTime, reader, err := assets.Find(path)
+		modTime, reader, err := findAsset(path)
 		if err != nil {
 			log.Printf("error getting file %q from assets: %v\n", path, err)
 			http.Redirect(w, r, "/", http.StatusSeeOther)
@@ -94,17 +93,14 @@ func (s *Server) SetupAdmin() error {
 		Funcs(template.FuncMap{
 			"humanDate": humanize.Time,
 		})
-	if err := parseFromPaths(
-		s.assets, tmplBase, partialsPaths, nil); err != nil {
+	if err := parseFromPaths(tmplBase, partialsPaths, nil); err != nil {
 		return errors.Wrap(err, "parsing template partials")
 	}
-	if err := parseFromPaths(
-		s.assets, tmplBase, layoutPaths, nil); err != nil {
+	if err := parseFromPaths(tmplBase, layoutPaths, nil); err != nil {
 		return errors.Wrap(err, "parsing template layouts")
 	}
 	s.Templates = make(templateMap)
-	if err := parseFromPaths(
-		s.assets, tmplBase, pagePaths, s.Templates); err != nil {
+	if err := parseFromPaths(tmplBase, pagePaths, s.Templates); err != nil {
 		return errors.Wrap(err, "parsing template pages for destination")
 	}
 	//
@@ -123,7 +119,7 @@ func (s *Server) SetupAdmin() error {
 	// begin static server
 	for _, path := range append(imagePaths, stylesheetPaths...) {
 		fullPath := filepath.Join("/admin/static", path)
-		s.mux.HandleFunc(fullPath, staticHandler(s.assets, path))
+		s.mux.HandleFunc(fullPath, staticHandler(path))
 	}
 	// begin public routes (creates new session)
 	s.mux.HandleFunc("/admin/login", withPublicWare(s.ServeLogin))