148 lines
2.9 KiB
Go
148 lines
2.9 KiB
Go
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)
|
|
}
|
|
}
|