go
/
bindata
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Removes output of both debug and release code. There really 

is no point to this.

All output (including TOC) is now written to a single output file.
This allows us to have different output file names to be specified.
Each for a different version generated code with its own build tags.
Consequently offering much greater flexibility in the way generated
code is to be used in a host application.

Fixes test outputs to match all these changes.
pull/4/head
Jim Teeuwen 2013-10-30 14:45:04 +01:00
parent 12a480432a
commit cca9f8e6b7
19 changed files with 219 additions and 499 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
asset.go
View File

@ -4,7 +4,7 @@
package bindata
// File is an asset entry for the table of contents.
// Asset holds information about a single asset to be processed.
type Asset struct {
Path string // Full file path.
Name string // Key used in TOC -- name by which asset is referenced.

65
config.go
View File

@ -4,6 +4,12 @@
package bindata
import (
"fmt"
"os"
"path/filepath"
)
// Config defines a set of options for the asset conversion.
type Config struct {
// Name of the package to use. Defaults to 'main'.
@ -20,7 +26,9 @@ type Config struct {
// conversion.
Input string
// Output defines the output directory for the generated code.
// Output defines the output file for the generated code.
// If left empty, this defaults to 'bindata.go' in the current
// working directory.
Output string
/*
@ -87,11 +95,22 @@ type Config struct {
NoMemCopy bool
/*
Compress means the assets are GZIP compressed before being turned
NoCompress means the assets are /not/ GZIP compressed before being turned
into Go code. The generated function will automatically unzip
the file data when called. Defaults to true.
*/
Compress bool
NoCompress bool
// Perform a debug build. This generates an asset file, which
// loads the asset contents directly from disk at their original
// location, instead of embedding the contents in the code.
//
// This is mostly useful if you anticipate that the assets are
// going to change during your development cycle. You will always
// want your code to access the latest version of the asset.
// Only in release mode, will the assets actually be embedded
// in the code. The default behaviour is Release mode.
Debug bool
}
// NewConfig returns a default configuration struct.
@ -99,6 +118,44 @@ func NewConfig() *Config {
c := new(Config)
c.Package = "main"
c.NoMemCopy = false
c.Compress = true
c.NoCompress = false
c.Debug = false
return c
}
// validate ensures the config has sane values.
// Part of which means checking if certain file/directory paths exist.
func (c *Config) validate() error {
if len(c.Package) == 0 {
return fmt.Errorf("Missing package name")
}
stat, err := os.Lstat(c.Input)
if err != nil {
return fmt.Errorf("Input path: %v", err)
}
if !stat.IsDir() {
return fmt.Errorf("Input path is not a directory.")
}
if len(c.Output) == 0 {
cwd, err := os.Getwd()
if err != nil {
return fmt.Errorf("Unable to determine current working directory.")
}
c.Output = filepath.Join(cwd, "bindata.go")
}
stat, err = os.Lstat(c.Output)
if err != nil && !os.IsNotExist(err) {
return fmt.Errorf("Output path: %v", err)
}
if stat != nil && stat.IsDir() {
return fmt.Errorf("Output path is a directory.")
}
return nil
}

53
convert.go
View File

@ -13,38 +13,59 @@ import (
"unicode"
)
// ProgressFunc is a callback handler which is fired whenever
// bindata begins translating a new file.
//
// It takes the file path and the current and total file counts.
// This can be used to indicate progress of the conversion.
//
// If this handler returns true, the processing is stopped and
// Translate() returns immediately.
type ProgressFunc func(file string, current, total int) bool
// Translate reads assets from an input directory, converts them
// to Go code and writes new files to the output directory specified
// to Go code and writes new files to the output file specified
// in the given configuration.
func Translate(c *Config, pf ProgressFunc) error {
func Translate(c *Config) error {
var toc []Asset
err := findFiles(c.Input, c.Prefix, &toc)
// Ensure our configuration has sane values.
err := c.validate()
if err != nil {
return err
}
err = writeDebug(c, toc)
// Locate all the assets.
err = findFiles(c.Input, c.Prefix, &toc)
if err != nil {
return err
}
err = writeRelease(c, toc)
// Create output file.
fd, err := os.Create(c.Output)
if err != nil {
return err
}
return writeTOC(c, toc)
defer fd.Close()
// Write build tags, if applicable.
if len(c.Tags) > 0 {
_, err = fmt.Fprintf(fd, "// +build %s\n\n", c.Tags)
if err != nil {
return err
}
}
// Write package declaration.
_, err = fmt.Fprintf(fd, "package %s\n\n", c.Package)
if err != nil {
return err
}
// Write assets.
if c.Debug {
err = writeDebug(fd, toc)
} else {
err = writeRelease(fd, c, toc)
}
if err != nil {
return err
}
// Write table of contents
return writeTOC(fd, toc)
}
// fillTOC recursively finds all the file paths in the given directory tree.

51
debug.go
View File

@ -7,26 +7,17 @@ package bindata
import (
"fmt"
"io"
"os"
"path/filepath"
)
// writeDebug writes the debug code file.
func writeDebug(c *Config, toc []Asset) error {
fd, err := os.Create(filepath.Join(c.Output, "bindata_debug.go"))
if err != nil {
return err
}
defer fd.Close()
err = writeDebugHeader(fd, c)
func writeDebug(w io.Writer, toc []Asset) error {
err := writeDebugHeader(w)
if err != nil {
return err
}
for i := range toc {
err = writeDebugAsset(fd, c, &toc[i])
err = writeDebugAsset(w, &toc[i])
if err != nil {
return err
}
@ -37,30 +28,8 @@ func writeDebug(c *Config, toc []Asset) error {
// writeDebugHeader writes output file headers.
// This targets debug builds.
func writeDebugHeader(w io.Writer, c *Config) error {
var err error
// Write build tags, if applicable.
if len(c.Tags) > 0 {
_, err = fmt.Fprintf(w, "// +build !release %s\n\n", c.Tags)
} else {
_, err = fmt.Fprintf(w, "// +build !release\n\n")
}
if err != nil {
return err
}
// Write package declaration
_, err = fmt.Fprintf(w, "package %s\n\n", c.Package)
if err != nil {
return err
}
// Define packages we need to import.
// And add the asset_read function. This is called
// from asset-specific functions.
_, err = fmt.Fprintf(w, `import (
func writeDebugHeader(w io.Writer) error {
_, err := fmt.Fprintf(w, `import (
"bytes"
"io"
"log"
@ -93,14 +62,16 @@ func bindata_read(path, name string) []byte {
// writeDebugAsset write a debug entry for the given asset.
// A debug entry is simply a function which reads the asset from
// the original file (e.g.: from disk).
func writeDebugAsset(w io.Writer, c *Config, asset *Asset) error {
_, err := fmt.Fprintf(w, `func %s() []byte {
func writeDebugAsset(w io.Writer, asset *Asset) error {
_, err := fmt.Fprintf(w, `
// %s reads file data from disk.
// It panics if something went wrong in the process.
func %s() []byte {
return bindata_read(
%q,
%q,
)
}
`, asset.Func, asset.Path, asset.Name)
`, asset.Func, asset.Func, asset.Path, asset.Name)
return err
}

73
go-bindata/main.go
View File

@ -13,11 +13,11 @@ import (
)
func main() {
cfg, status := parseArgs()
err := bindata.Translate(cfg, status)
cfg := parseArgs()
err := bindata.Translate(cfg)
if err != nil {
fmt.Fprintf(os.Stderr, "bindata: %v", err)
fmt.Fprintf(os.Stderr, "bindata: %v\n", err)
}
}
@ -26,23 +26,23 @@ func main() {
//
// This function exits the program with an error, if
// any of the command line options are incorrect.
func parseArgs() (*bindata.Config, bindata.ProgressFunc) {
var version, quiet bool
func parseArgs() *bindata.Config {
var version bool
c := bindata.NewConfig()
flag.Usage = func() {
fmt.Printf("Usage: %s [options] <input> [<output>]\n\n", os.Args[0])
fmt.Printf("Usage: %s [options] <input dir> [<output file>]\n\n", os.Args[0])
flag.PrintDefaults()
}
flag.StringVar(&c.Tags, "tags", c.Tags, "Comma-separated list of build tags to include.")
flag.StringVar(&c.Prefix, "prefix", c.Prefix, "Optional path prefix to strip off map keys and function names.")
flag.BoolVar(&c.Debug, "debug", c.Debug, "Do not embed the assets, but provide the embedding API. Contents will still be loaded from disk.")
flag.StringVar(&c.Tags, "tags", c.Tags, "Optional set of uild tags to include.")
flag.StringVar(&c.Prefix, "prefix", c.Prefix, "Optional path prefix to strip off asset names.")
flag.StringVar(&c.Package, "pkg", c.Package, "Package name to use in the generated code.")
flag.BoolVar(&c.NoMemCopy, "nomemcopy", c.NoMemCopy, "Use a .rodata hack to get rid of unnecessary memcopies. Refer to the documentation to see what implications this carries.")
flag.BoolVar(&c.Compress, "nocompress", !c.Compress, "Assets will /not/ be GZIP compressed when this flag is specified.")
flag.BoolVar(&c.NoCompress, "nocompress", c.NoCompress, "Assets will *not* be GZIP compressed when this flag is specified.")
flag.BoolVar(&version, "version", false, "Displays version information.")
flag.BoolVar(&quiet, "quiet", false, "Do not print conversion status.")
flag.Parse()
if version {
@ -52,64 +52,15 @@ func parseArgs() (*bindata.Config, bindata.ProgressFunc) {
// Make sure we have in/output paths.
if flag.NArg() == 0 {
fmt.Fprintf(os.Stderr, "Missing asset directory.\n")
fmt.Fprintf(os.Stderr, "Missing input path.\n")
os.Exit(1)
}
// Test validity of input path.
c.Input = filepath.Clean(flag.Arg(0))
stat, err := os.Lstat(c.Input)
if err != nil {
fmt.Fprintf(os.Stderr, "Input path: %v.\n", err)
os.Exit(1)
}
if !stat.IsDir() {
fmt.Fprintf(os.Stderr, "Input path is not a directory.\n")
os.Exit(1)
}
// Find and test validity of output path.
if flag.NArg() > 1 {
c.Output = filepath.Clean(flag.Arg(1))
stat, err := os.Lstat(c.Output)
if err != nil {
if !os.IsNotExist(err) {
fmt.Fprintf(os.Stderr, "Output path: %v.\n", err)
os.Exit(1)
}
// Create output directory
err = os.MkdirAll(c.Output, 0744)
if err != nil {
fmt.Fprintf(os.Stderr, "Create Output directory: %v.\n", err)
os.Exit(1)
}
} else if !stat.IsDir() {
fmt.Fprintf(os.Stderr, "Output path is not a directory.\n")
os.Exit(1)
}
} else {
// If no output path is specified, use the current directory.
c.Output, err = os.Getwd()
if err != nil {
fmt.Fprintf(os.Stderr, "Unable to determine current working directory: %v\n", err)
os.Exit(1)
}
}
// The command line flag supplies the inversion of this value.
c.Compress = !c.Compress
if quiet {
return c, nil
}
return c, func(file string, current, total int) bool {
fmt.Printf("[%d/%d] %s\n", current, total, file)
return false
}
return c
}

70
release.go
View File

@ -9,25 +9,17 @@ import (
"fmt"
"io"
"os"
"path/filepath"
)
// writeRelease writes the release code file.
func writeRelease(c *Config, toc []Asset) error {
fd, err := os.Create(filepath.Join(c.Output, "bindata_release.go"))
if err != nil {
return err
}
defer fd.Close()
err = writeReleaseHeader(fd, c)
func writeRelease(w io.Writer, c *Config, toc []Asset) error {
err := writeReleaseHeader(w, c)
if err != nil {
return err
}
for i := range toc {
err = writeReleaseAsset(fd, c, &toc[i])
err = writeReleaseAsset(w, c, &toc[i])
if err != nil {
return err
}
@ -39,37 +31,18 @@ func writeRelease(c *Config, toc []Asset) error {
// writeReleaseHeader writes output file headers.
// This targets release builds.
func writeReleaseHeader(w io.Writer, c *Config) error {
var err error
// Write build tags, if applicable.
if len(c.Tags) > 0 {
_, err = fmt.Fprintf(w, "// +build release %s\n\n", c.Tags)
} else {
_, err = fmt.Fprintf(w, "// +build release\n\n")
}
if err != nil {
return err
}
// Write package declaration
_, err = fmt.Fprintf(w, "package %s\n\n", c.Package)
if err != nil {
return err
}
if c.Compress {
if c.NoMemCopy {
return header_compressed_nomemcopy(w)
} else {
return header_compressed_memcopy(w)
}
} else {
if c.NoCompress {
if c.NoMemCopy {
return header_uncompressed_nomemcopy(w)
} else {
return header_uncompressed_memcopy(w)
}
} else {
if c.NoMemCopy {
return header_compressed_nomemcopy(w)
} else {
return header_compressed_memcopy(w)
}
}
}
@ -84,26 +57,25 @@ func writeReleaseAsset(w io.Writer, c *Config, asset *Asset) error {
defer fd.Close()
if c.Compress {
if c.NoMemCopy {
return compressed_nomemcopy(w, asset, fd)
} else {
return compressed_memcopy(w, asset, fd)
}
} else {
if c.NoCompress {
if c.NoMemCopy {
return uncompressed_nomemcopy(w, asset, fd)
} else {
return uncompressed_memcopy(w, asset, fd)
}
} else {
if c.NoMemCopy {
return compressed_nomemcopy(w, asset, fd)
} else {
return compressed_memcopy(w, asset, fd)
}
}
return nil
}
func header_compressed_nomemcopy(w io.Writer) error {
_, err := fmt.Fprintf(w, `
import (
_, err := fmt.Fprintf(w, `import (
"bytes"
"compress/gzip"
"io"
@ -142,8 +114,7 @@ func bindata_read(data, name string) []byte {
}
func header_compressed_memcopy(w io.Writer) error {
_, err := fmt.Fprintf(w, `
import (
_, err := fmt.Fprintf(w, `import (
"bytes"
"compress/gzip"
"io"
@ -172,8 +143,7 @@ func bindata_read(data []byte, name string) []byte {
}
func header_uncompressed_nomemcopy(w io.Writer) error {
_, err := fmt.Fprintf(w, `
import (
_, err := fmt.Fprintf(w, `import (
"reflect"
"unsafe"
)

19
testdata/out/compress-memcpy/bindata_release.go → testdata/out/compress-memcopy.go vendored
View File

@ -1,5 +1,3 @@
// +build release
package main
import (
@ -69,3 +67,20 @@ func in_c_test_asset() []byte {
"in/c/test.asset",
)
}
// Asset loads and returns the asset for the given name.
// This returns nil of the asset could not be found.
func Asset(name string) []byte {
if f, ok := _bindata[name]; ok {
return f()
}
return nil
}
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() []byte{
"in/b/test.asset": in_b_test_asset,
"in/test.asset": in_test_asset,
"in/a/test.asset": in_a_test_asset,
"in/c/test.asset": in_c_test_asset,
}

18
testdata/out/compress-memcpy/bindata.go vendored
View File

@ -1,18 +0,0 @@
package main
// Asset loads and returns the asset for the given name.
// This returns nil of the asset could not be found.
func Asset(name string) []byte {
if f, ok := _bindata[name]; ok {
return f()
}
return nil
}
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() []byte{
"in/b/test.asset": in_b_test_asset,
"in/test.asset": in_test_asset,
"in/a/test.asset": in_a_test_asset,
"in/c/test.asset": in_c_test_asset,
}

57
testdata/out/compress-memcpy/bindata_debug.go vendored
View File

@ -1,57 +0,0 @@
// +build !release
package main
import (
"bytes"
"io"
"log"
"os"
)
// bindata_read reads the given file from disk.
// It panics if anything went wrong.
func bindata_read(path, name string) []byte {
fd, err := os.Open(path)
if err != nil {
log.Fatalf("Read %s: %v", name, err)
}
defer fd.Close()
var buf bytes.Buffer
_, err = io.Copy(&buf, fd)
if err != nil {
log.Fatalf("Read %s: %v", name, err)
}
return buf.Bytes()
}
func in_b_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/b/test.asset",
"in/b/test.asset",
)
}
func in_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/test.asset",
"in/test.asset",
)
}
func in_a_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/a/test.asset",
"in/a/test.asset",
)
}
func in_c_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/c/test.asset",
"in/c/test.asset",
)
}

19
testdata/out/compress-nomemcpy/bindata_release.go → testdata/out/compress-nomemcopy.go vendored
View File

@ -1,5 +1,3 @@
// +build release
package main
import (
@ -71,3 +69,20 @@ func in_c_test_asset() []byte {
"in/c/test.asset",
)
}
// Asset loads and returns the asset for the given name.
// This returns nil of the asset could not be found.
func Asset(name string) []byte {
if f, ok := _bindata[name]; ok {
return f()
}
return nil
}
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() []byte{
"in/b/test.asset": in_b_test_asset,
"in/test.asset": in_test_asset,
"in/a/test.asset": in_a_test_asset,
"in/c/test.asset": in_c_test_asset,
}

18
testdata/out/compress-nomemcpy/bindata.go vendored
View File

@ -1,18 +0,0 @@
package main
// Asset loads and returns the asset for the given name.
// This returns nil of the asset could not be found.
func Asset(name string) []byte {
if f, ok := _bindata[name]; ok {
return f()
}
return nil
}
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() []byte{
"in/b/test.asset": in_b_test_asset,
"in/test.asset": in_test_asset,
"in/a/test.asset": in_a_test_asset,
"in/c/test.asset": in_c_test_asset,
}

57
testdata/out/compress-nomemcpy/bindata_debug.go vendored
View File

@ -1,57 +0,0 @@
// +build !release
package main
import (
"bytes"
"io"
"log"
"os"
)
// bindata_read reads the given file from disk.
// It panics if anything went wrong.
func bindata_read(path, name string) []byte {
fd, err := os.Open(path)
if err != nil {
log.Fatalf("Read %s: %v", name, err)
}
defer fd.Close()
var buf bytes.Buffer
_, err = io.Copy(&buf, fd)
if err != nil {
log.Fatalf("Read %s: %v", name, err)
}
return buf.Bytes()
}
func in_b_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/b/test.asset",
"in/b/test.asset",
)
}
func in_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/test.asset",
"in/test.asset",
)
}
func in_a_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/a/test.asset",
"in/a/test.asset",
)
}
func in_c_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/c/test.asset",
"in/c/test.asset",
)
}

19
testdata/out/nocompress-memcpy/bindata_release.go → testdata/out/nocompress-memcopy.go vendored
View File

@ -1,5 +1,3 @@
// +build release
package main
func in_b_test_asset() []byte {
@ -29,3 +27,20 @@ func in_c_test_asset() []byte {
0x6c, 0x65, 0x0a,
}
}
// Asset loads and returns the asset for the given name.
// This returns nil of the asset could not be found.
func Asset(name string) []byte {
if f, ok := _bindata[name]; ok {
return f()
}
return nil
}
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() []byte{
"in/b/test.asset": in_b_test_asset,
"in/test.asset": in_test_asset,
"in/a/test.asset": in_a_test_asset,
"in/c/test.asset": in_c_test_asset,
}

18
testdata/out/nocompress-memcpy/bindata.go vendored
View File

@ -1,18 +0,0 @@
package main
// Asset loads and returns the asset for the given name.
// This returns nil of the asset could not be found.
func Asset(name string) []byte {
if f, ok := _bindata[name]; ok {
return f()
}
return nil
}
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() []byte{
"in/b/test.asset": in_b_test_asset,
"in/test.asset": in_test_asset,
"in/a/test.asset": in_a_test_asset,
"in/c/test.asset": in_c_test_asset,
}

57
testdata/out/nocompress-memcpy/bindata_debug.go vendored
View File

@ -1,57 +0,0 @@
// +build !release
package main
import (
"bytes"
"io"
"log"
"os"
)
// bindata_read reads the given file from disk.
// It panics if anything went wrong.
func bindata_read(path, name string) []byte {
fd, err := os.Open(path)
if err != nil {
log.Fatalf("Read %s: %v", name, err)
}
defer fd.Close()
var buf bytes.Buffer
_, err = io.Copy(&buf, fd)
if err != nil {
log.Fatalf("Read %s: %v", name, err)
}
return buf.Bytes()
}
func in_b_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/b/test.asset",
"in/b/test.asset",
)
}
func in_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/test.asset",
"in/test.asset",
)
}
func in_a_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/a/test.asset",
"in/a/test.asset",
)
}
func in_c_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/c/test.asset",
"in/c/test.asset",
)
}

19
testdata/out/nocompress-nomemcpy/bindata_release.go → testdata/out/nocompress-nomemcopy.go vendored
View File

@ -1,5 +1,3 @@
// +build release
package main
import (
@ -53,3 +51,20 @@ func in_c_test_asset() []byte {
"in/c/test.asset",
)
}
// Asset loads and returns the asset for the given name.
// This returns nil of the asset could not be found.
func Asset(name string) []byte {
if f, ok := _bindata[name]; ok {
return f()
}
return nil
}
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() []byte{
"in/b/test.asset": in_b_test_asset,
"in/test.asset": in_test_asset,
"in/a/test.asset": in_a_test_asset,
"in/c/test.asset": in_c_test_asset,
}

18
testdata/out/nocompress-nomemcpy/bindata.go vendored
View File

@ -1,18 +0,0 @@
package main
// Asset loads and returns the asset for the given name.
// This returns nil of the asset could not be found.
func Asset(name string) []byte {
if f, ok := _bindata[name]; ok {
return f()
}
return nil
}
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() []byte{
"in/b/test.asset": in_b_test_asset,
"in/test.asset": in_test_asset,
"in/a/test.asset": in_a_test_asset,
"in/c/test.asset": in_c_test_asset,
}

57
testdata/out/nocompress-nomemcpy/bindata_debug.go vendored
View File

@ -1,57 +0,0 @@
// +build !release
package main
import (
"bytes"
"io"
"log"
"os"
)
// bindata_read reads the given file from disk.
// It panics if anything went wrong.
func bindata_read(path, name string) []byte {
fd, err := os.Open(path)
if err != nil {
log.Fatalf("Read %s: %v", name, err)
}
defer fd.Close()
var buf bytes.Buffer
_, err = io.Copy(&buf, fd)
if err != nil {
log.Fatalf("Read %s: %v", name, err)
}
return buf.Bytes()
}
func in_b_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/b/test.asset",
"in/b/test.asset",
)
}
func in_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/test.asset",
"in/test.asset",
)
}
func in_a_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/a/test.asset",
"in/a/test.asset",
)
}
func in_c_test_asset() []byte {
return bindata_read(
"/a/code/go/src/github.com/jteeuwen/go-bindata/testdata/in/c/test.asset",
"in/c/test.asset",
)
}

28
toc.go
View File

@ -7,38 +7,28 @@ package bindata
import (
"fmt"
"io"
"os"
"path/filepath"
)
// writeTOC writes the table of contents file.
func writeTOC(c *Config, toc []Asset) error {
fd, err := os.Create(filepath.Join(c.Output, "bindata.go"))
if err != nil {
return err
}
defer fd.Close()
err = writeTOCHeader(fd, c)
func writeTOC(w io.Writer, toc []Asset) error {
err := writeTOCHeader(w)
if err != nil {
return err
}
for i := range toc {
err = writeTOCAsset(fd, c, &toc[i])
err = writeTOCAsset(w, &toc[i])
if err != nil {
return err
}
}
return writeTOCFooter(fd, c)
return writeTOCFooter(w)
}
// writeTOCHeader writes the table of contents file header.
func writeTOCHeader(w io.Writer, c *Config) error {
_, err := fmt.Fprintf(w, `package %s
func writeTOCHeader(w io.Writer) error {
_, err := fmt.Fprintf(w, `
// Asset loads and returns the asset for the given name.
// This returns nil of the asset could not be found.
func Asset(name string) []byte {
@ -50,18 +40,18 @@ func Asset(name string) []byte {
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string] func() []byte {
`, c.Package)
`)
return err
}
// writeTOCAsset write a TOC entry for the given asset.
func writeTOCAsset(w io.Writer, c *Config, asset *Asset) error {
func writeTOCAsset(w io.Writer, asset *Asset) error {
_, err := fmt.Fprintf(w, "\t%q: %s,\n", asset.Name, asset.Func)
return err
}
// writeTOCFooter writes the table of contents file footer.
func writeTOCFooter(w io.Writer, c *Config) error {
func writeTOCFooter(w io.Writer) error {
_, err := fmt.Fprintf(w, `
}
`)