refactor asset with embed tool

cmd/gonic/main.go

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

cmd/gonicembed/main.go

@@ -0,0 +1,147 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/peterbourgon/ff"
+	"github.com/pkg/errors"
+)
+
+const (
+	programName = "gonicembed"
+	byteCols    = 24
+
+	// begin file template
+	fileHeader = `// file generated with embed tool
+// do not edit
+
+// +build %s
+
+package %s
+import "time"
+type EmbeddedAsset struct {
+	ModTime time.Time
+	Bytes []byte
+}
+var %s = map[string]*EmbeddedAsset{`
+	fileFooter = `
+}`
+
+	// begin asset template
+	assetHeader = `
+%q: &EmbeddedAsset{
+	ModTime: time.Unix(%d, 0),
+	Bytes: []byte{
+`
+	assetFooter = `}},`
+)
+
+type config struct {
+	packageName     string
+	outPath         string
+	tagList         string
+	assetsVarName   string
+	assetPathPrefix string
+}
+
+type file struct {
+	data    io.ReadSeeker
+	path    string
+	modTime time.Time
+}
+
+func processAsset(c *config, f *file, out io.Writer) error {
+	out.Write([]byte(fmt.Sprintf(assetHeader,
+		strings.TrimPrefix(f.path, c.assetPathPrefix),
+		f.modTime.Unix(),
+	)))
+	defer out.Write([]byte(assetFooter))
+	buffer := make([]byte, byteCols)
+	for {
+		read, err := f.data.Read(buffer)
+		for i := 0; i < read; i++ {
+			fmt.Fprintf(out, "0x%02x,", buffer[i])
+		}
+		if err != nil {
+			break
+		}
+		fmt.Fprintln(out)
+	}
+	return nil
+}
+
+func processAssets(c *config, files []string) error {
+	outWriter, err := os.Create(c.outPath)
+	if err != nil {
+		return errors.Wrap(err, "creating out path")
+	}
+	outWriter.Write([]byte(fmt.Sprintf(fileHeader,
+		c.tagList,
+		c.packageName,
+		c.assetsVarName,
+	)))
+	defer outWriter.Write([]byte(fileFooter))
+	for _, path := range files {
+		info, err := os.Stat(path)
+		if err != nil {
+			return errors.Wrap(err, "stating asset")
+		}
+		if info.IsDir() {
+			continue
+		}
+		data, err := os.Open(path)
+		if err != nil {
+			return errors.Wrap(err, "opening asset")
+		}
+		f := &file{
+			data:    data,
+			path:    path,
+			modTime: info.ModTime(),
+		}
+		if err := processAsset(c, f, outWriter); err != nil {
+			return errors.Wrap(err, "processing asset")
+		}
+	}
+	return nil
+}
+
+func main() {
+	set := flag.NewFlagSet(programName, flag.ExitOnError)
+	outPath := set.String(
+		"out-path", "",
+		"generated file's path (required)")
+	pkgName := set.String(
+		"package-name", "assets",
+		"generated file's package name")
+	tagList := set.String(
+		"tag-list", "",
+		"generated file's build tag list")
+	assetsVarName := set.String(
+		"assets-var-name", "Assets",
+		"generated file's assets var name")
+	assetPathPrefix := set.String(
+		"asset-path-prefix", "",
+		"generated file's assets map key prefix to be stripped")
+	if err := ff.Parse(set, os.Args[1:]); err != nil {
+		log.Fatalf("error parsing args: %v\n", err)
+	}
+	if *outPath == "" {
+		log.Fatalln("invalid arguments. see -h")
+	}
+	c := &config{
+		packageName:     *pkgName,
+		outPath:         *outPath,
+		tagList:         *tagList,
+		assetsVarName:   *assetsVarName,
+		assetPathPrefix: *assetPathPrefix,
+	}
+	if err := processAssets(c, set.Args()); err != nil {
+		log.Fatalf("error processing files: %v\n", err)
+	}
+}

cmd/gonicscan/main.go

@@ -13,7 +13,7 @@ import (
 )
 
 const (
-	programName = "gonic"
+	programName = "gonicscan"
 )
 
 func main() {
@@ -24,8 +24,7 @@ func main() {
 	dbPath := set.String(
 		"db-path", "gonic.db",
 		"path to database (optional)")
-	err := ff.Parse(set, os.Args[1:])
-	if err != nil {
+	if err := ff.Parse(set, os.Args[1:]); err != nil {
 		log.Fatalf("error parsing args: %v\n", err)
 	}
 	if _, err := os.Stat(*musicPath); os.IsNotExist(err) {