Update package paths and README

Fix go format of generated code

CONTRIBUTING.md

@@ -0,0 +1,79 @@
+## Contribution guidelines.
+
+So you wish to contribute to this project? Fantastic!
+Here are a few guidelines to help you do this in a
+streamlined fashion.
+
+
+## Bug reports
+
+When supplying a bug report, please consider the following guidelines.
+These serve to make it easier for us to address the issue and find a solution.
+Most of these are pretty self-evident, but sometimes it is still necessary
+to reiterate them.
+
+* Be clear in the way you express the problem. Use simple language and
+  just enough of it to clearly define the issue. Not everyone is a native
+  English speaker. And while most can handle themselves pretty well,
+  it helps to stay away from more esoteric vocabulary.
+  
+  Be patient with non-native English speakers. If their bug reports
+  or comments are hard to understand, just ask for clarification.
+  Do not start guessing at their meaning, as this may just lead to
+  more confusion and misunderstandings.
+* Clearly define any information which is relevant to the problem.
+  This includes library versions, operating system and any other
+  external dependencies which may be needed.
+* Where applicable, provide a step-by-step listing of the way to
+  reproduce the problem. Make sure this is the simplest possible
+  way to do so. Omit any and all unneccesary steps, because they may
+  just complicate our understanding of the real problem.
+  If need be, create a whole new code project on your local machine,
+  which specifically tries to create the problem you are running into;
+  nothing more, nothing less.
+  
+  Include this program in the bug report. It often suffices to paste
+  the code in a [Gist](https://gist.github.com) or on the
+  [Go playground](http://play.golang.org).
+* If possible, provide us with a listing of the steps you have already
+  undertaken to solve the problem. This can save us a great deal of
+  wasted time, trying out solutions you have already covered.
+
+
+## Pull requests
+
+Bug reports are great. Supplying fixes to bugs is even better.
+When submitting a pull request, the following guidelines are
+good to keep in mind:
+
+* `go fmt`: **Always** run your code through `go fmt`, before
+  committing it. Code has to be readable by many different
+  people. And the only way this will be as painless as possible,
+  is if we all stick to the same code style.
+  
+  Some of our projects may have automated build-servers hooked up
+  to commit hooks. These will vet any submitted code and determine
+  if it meets a set of properties. One of which is code formatting.
+  These servers will outright deny a submission which has not been
+  run through `go fmt`, even if the code itself is correct.
+  
+  We try to maintain a zero-tolerance policy on this matter,
+  because consistently formatted code makes life a great deal
+  easier for everyone involved.
+* Commit log messages: When committing changes, do so often and
+  clearly -- Even if you have changed only 1 character in a code
+  comment. This means that commit log messages should clearly state
+  exactly what the change does and why. If it fixes a known issue,
+  then mention the issue number in the commit log. E.g.:
+  
+  > Fixes return value for `foo/boo.Baz()` to be consistent with
+  > the rest of the API. This addresses issue #32
+  
+  Do not pile a lot of unrelated changes into a single commit.
+  Pick and choose only those changes for a single commit, which are
+  directly related. We would much rather see a hundred commits
+  saying nothing but `"Runs go fmt"` in between any real fixes
+  than have these style changes embedded in those real fixes.
+  It creates a lot of noise when trying to review code.
+
+

CONTRIBUTORS

@@ -1,10 +0,0 @@
-# This is the list of people who can contribute (or have contributed) to this
-# project. This includes code, documentation, testing, content creation and 
-# bugfixes.
-#
-# Names should be added to this file like so:
-#     Name [<email address>]
-#
-# Please keep the list sorted.
-
-Jim Teeuwen <jimteeuwen at gmail dot com>

Makefile

@@ -0,0 +1,2 @@
+all:
+	make -C testdata

README.md

@@ -1,47 +1,99 @@
+> **NOTICE:**
+>
+> This repository is a fork of <https://github.com/jteeuwen/go-bindata> which
+> itself was a fork of an original project that disappeared.
+>
+> I've cloned a copy for personal use at <https://git.kirsle.net/go/bindata> so
+> that I always have a version that won't disappear.
+>
+> [@kirsle](https://www.kirsle.net/)
+
 ## bindata
 
-This tool converts any file into managable Go source code. Useful for embedding
-binary data into a go program. The file data is optionally gzip compressed
-before being converted to a raw byte slice.
+This package converts any file into managable Go source code. Useful for
+embedding binary data into a go program. The file data is optionally gzip
+compressed before being converted to a raw byte slice.
+
+It comes with a command line tool in the `go-bindata` sub directory.
+This tool offers a set of command line options, used to customize the
+output being generated.
+
+
+### Installation
+
+To install the library and command line program, use the following:
+
+	go get -u git.kirsle.net/go/bindata/...
+
 
 ### Usage
 
-The simplest invocation is to pass it only the input file name.
-The output file and code settings are inferred from this automatically.
+Conversion is done on one or more sets of files. They are all embedded in a new
+Go source file, along with a table of contents and an `Asset` function,
+which allows quick access to the asset, based on its name.
 
-    $ go-bindata testdata/gophercolor.png
-    [w] No output file specified. Using 'testdata/gophercolor.png.go'.
-    [w] No package name specified. Using 'main'.
-    [w] No function name specified. Using 'testdata_gophercolor_png'.
+The simplest invocation generates a `bindata.go` file in the current
+working directory. It includes all assets from the `data` directory.
 
-This creates the `testdata/gophercolor.png.go` file which has a package
-declaration with name `main` and one function named `testdata_gophercolor_png` with
-the following signature:
+	$ go-bindata data/
 
-```go
-func testdata_gophercolor_png() []byte
-```
+To include all input sub-directories recursively, use the elipsis postfix
+as defined for Go import paths. Otherwise it will only consider assets in the
+input directory itself.
 
-You can now simply include the new .go file in your program and call
-`testdata_gophercolor_png()` to get the (uncompressed) image data. The function panics
-if something went wrong during decompression. See the testdata directory for
-example input and output files for various modes.
+	$ go-bindata data/...
 
-Aternatively, you can pipe the input file data into stdin. `go-bindata` will
-then spit out the generated Go code to stdout. This does require explicitly
-naming the desired function name, as it can not be inferred from the
-input data. The package name will still default to 'main'.
+To specify the name of the output file being generated, we use the following:
 
-     $ cat testdata/gophercolor.png | go-bindata -f gophercolor_png | gofmt
+	$ go-bindata -o myfile.go data/
 
-Invoke the program with the `-h` flag for more options.
+Multiple input directories can be specified if necessary.
 
-In order to strip off a part of the generated function name, we can use the `-prefix` flag.
-In the above example, the input file `testdata/gophercolor.png` yields a function named
-`testdata_gophercolor_png`. If we want the `testdata` component to be left out, we invoke
-the program as follows:
+	$ go-bindata dir1/... /path/to/dir2/... dir3
 
-    $ go-bindata -prefix "testdata/" testdata/gophercolor.png
+
+The following paragraphs detail some of the command line options which can be
+supplied to `go-bindata`. Refer to the `testdata/out` directory for various
+output examples from the assets in `testdata/in`. Each example uses different
+command line options.
+
+To ignore files, pass in regexes using -ignore, for example:
+
+    $ go-bindata -ignore=\\.gitignore data/...
+
+### Accessing an asset
+
+To access asset data, we use the `Asset(string) ([]byte, error)` function which
+is included in the generated output.
+
+	data, err := Asset("pub/style/foo.css")
+	if err != nil {
+		// Asset was not found.
+	}
+
+	// use asset data
+
+
+### Debug vs Release builds
+
+When invoking the program with the `-debug` flag, the generated code does
+not actually include the asset data. Instead, it generates function stubs
+which load the data from the original file on disk. The asset API remains
+identical between debug and release builds, so your code will not have to
+change.
+
+This is useful during development when you expect the assets to change often.
+The host application using these assets uses the same API in both cases and
+will not have to care where the actual data comes from.
+
+An example is a Go webserver with some embedded, static web content like
+HTML, JS and CSS files. While developing it, you do not want to rebuild the
+whole server and restart it every time you make a change to a bit of
+javascript. You just want to build and launch the server once. Then just press
+refresh in the browser to see those changes. Embedding the assets with the
+`debug` flag allows you to do just that. When you are finished developing and
+ready for deployment, just re-invoke `go-bindata` without the `-debug` flag.
+It will now embed the latest version of the assets.
 
 
 ### Lower memory footprint
@@ -97,9 +149,9 @@ func myfile() []byte {
 
 ### Optional compression
 
-When the `-uncompressed` flag is given, the supplied resource is *not* GZIP compressed
-before being turned into Go code. The data should still be accessed through
-a function call, so nothing changes in the usage of the generated file.
+When the `-nocompress` flag is given, the supplied resource is *not* GZIP
+compressed before being turned into Go code. The data should still be accessed
+through a function call, so nothing changes in the usage of the generated file.
 
 This feature is useful if you do not care for compression, or the supplied
 resource is already compressed. Doing it again would not add any value and may
@@ -108,66 +160,39 @@ even increase the size of the data.
 The default behaviour of the program is to use compression.
 
 
-### Table of Contents
+### Path prefix stripping
 
-With the `-toc` flag, we can have `go-bindata` create a table of contents for all the files
-which have been generated by the tool. It does this by first generating a new file named
-`bindata-toc.go`. This contains a global map of type `map[string] func() []byte`. It uses the
-input filename as the key and the data function as the value. We can use this
-to fetch all data for our files, matching a given pattern.
-
-It then appands an `init` function to each generated file, which simply makes the data
-function append itself to the global `bindata` map.
-
-Once you have compiled your program with all these new files and run it, the map will
-be populated by all generated data files.
-
-**Note**: The `bindata-toc.go` file will not be created when we run in `pipe` mode.
-The reason being, that the tool does not write any files at all, as it has no idea
-where to save them. The data file is written to `stdout` instead after all.
-
-
-#### Table of Contents keys
-
-The keys used in the `go_bindata` map, are the same as the input file name passed to `go-bindata`.
-This includes the fully qualified (absolute) path. In most cases, this is not desireable, as it
-puts potentially sensitive information in your code base. For this purpose, the tool supplies
-another command line flag `-prefix`. This accepts a portion of a path name, which should be
-stripped off from the map keys and function names.
+The keys used in the `_bindata` map, are the same as the input file name
+passed to `go-bindata`. This includes the path. In most cases, this is not
+desireable, as it puts potentially sensitive information in your code base.
+For this purpose, the tool supplies another command line flag `-prefix`.
+This accepts a portion of a path name, which should be stripped off from
+the map keys and function names.
 
 For example, running without the `-prefix` flag, we get:
 
-	$ go-bindata /path/to/templates/foo.html
-    
-	go_bindata["/path/to/templates/foo.html"] = path_to_templates_foo_html
+	$ go-bindata /path/to/templates/
+
+	_bindata["/path/to/templates/foo.html"] = path_to_templates_foo_html
 
 Running with the `-prefix` flag, we get:
 
-	$ go-bindata -prefix "/path/to/" /path/to/templates/foo.html
-    
-	go_bindata["templates/foo.html"] = templates_foo_html
+	$ go-bindata -prefix "/path/to/" /path/to/templates/
+
+	_bindata["templates/foo.html"] = templates_foo_html
 
 
-#### bindata-toc.go
+### Build tags
 
-The `bindata-toc.go` file is very simple and looks as follows:
-
-```go
-package $PACKAGENAME
-
-// Global Table of Contents map. Generated by go-bindata.
-// After startup of the program, all generated data files will
-// put themselves in this map. The key is the full filename, as
-// supplied to go-bindata.
-var go_bindata = make(map[string] func() []byte)
-```
-
-#### Build tags
-
-With the optional -tags flag, you can specify any go build tags that
+With the optional `-tags` flag, you can specify any go build tags that
 must be fulfilled for the output file to be included in a build. This
-is useful for including binary data in multiple formats, where the desired
-format is specified at build time with the appropriate tag(s).
+is useful when including binary data in multiple formats, where the desired
+format is specified at build time with the appropriate tags.
 
 The tags are appended to a `// +build` line in the beginning of the output file
 and must follow the build tags syntax specified by the go tool.
+
+### Related projects
+
+[go-bindata-assetfs](https://github.com/elazarl/go-bindata-assetfs#readme) -
+implements `http.FileSystem` interface. Allows you to serve assets with `net/http`.

asset.go

@@ -0,0 +1,12 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+// 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.
+	Func string // Function name for the procedure returning the asset contents.
+}

bytewriter.go

@@ -9,7 +9,11 @@ import (
 	"io"
 )
 
-var newline = []byte{'\n'}
+var (
+	newline    = []byte{'\n'}
+	dataindent = []byte{'\t', '\t'}
+	space      = []byte{' '}
+)
 
 type ByteWriter struct {
 	io.Writer
@@ -24,7 +28,10 @@ func (w *ByteWriter) Write(p []byte) (n int, err error) {
 	for n = range p {
 		if w.c%12 == 0 {
 			w.Writer.Write(newline)
+			w.Writer.Write(dataindent)
 			w.c = 0
+		} else {
+			w.Writer.Write(space)
 		}
 
 		fmt.Fprintf(w.Writer, "0x%02x,", p[n])

config.go

@@ -0,0 +1,203 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+)
+
+// InputConfig defines options on a asset directory to be convert.
+type InputConfig struct {
+	// Path defines a directory containing asset files to be included
+	// in the generated output.
+	Path string
+
+	// Recusive defines whether subdirectories of Path
+	// should be recursively included in the conversion.
+	Recursive bool
+}
+
+// Config defines a set of options for the asset conversion.
+type Config struct {
+	// Name of the package to use. Defaults to 'main'.
+	Package string
+
+	// Tags specify a set of optional build tags, which should be
+	// included in the generated output. The tags are appended to a
+	// `// +build` line in the beginning of the output file
+	// and must follow the build tags syntax specified by the go tool.
+	Tags string
+
+	// Input defines the directory path, containing all asset files as
+	// well as whether to recursively process assets in any sub directories.
+	Input []InputConfig
+
+	// Output defines the output file for the generated code.
+	// If left empty, this defaults to 'bindata.go' in the current
+	// working directory.
+	Output string
+
+	// Prefix defines a path prefix which should be stripped from all
+	// file names when generating the keys in the table of contents.
+	// For example, running without the `-prefix` flag, we get:
+	//
+	// 	$ go-bindata /path/to/templates
+	// 	go_bindata["/path/to/templates/foo.html"] = _path_to_templates_foo_html
+	//
+	// Running with the `-prefix` flag, we get:
+	//
+	// 	$ go-bindata -prefix "/path/to/" /path/to/templates/foo.html
+	// 	go_bindata["templates/foo.html"] = templates_foo_html
+	Prefix string
+
+	// NoMemCopy will alter the way the output file is generated.
+	//
+	// It will employ a hack that allows us to read the file data directly from
+	// the compiled program's `.rodata` section. This ensures that when we call
+	// call our generated function, we omit unnecessary mem copies.
+	//
+	// The downside of this, is that it requires dependencies on the `reflect` and
+	// `unsafe` packages. These may be restricted on platforms like AppEngine and
+	// thus prevent you from using this mode.
+	//
+	// Another disadvantage is that the byte slice we create, is strictly read-only.
+	// For most use-cases this is not a problem, but if you ever try to alter the
+	// returned byte slice, a runtime panic is thrown. Use this mode only on target
+	// platforms where memory constraints are an issue.
+	//
+	// The default behaviour is to use the old code generation method. This
+	// prevents the two previously mentioned issues, but will employ at least one
+	// extra memcopy and thus increase memory requirements.
+	//
+	// For instance, consider the following two examples:
+	//
+	// This would be the default mode, using an extra memcopy but gives a safe
+	// implementation without dependencies on `reflect` and `unsafe`:
+	//
+	// 	func myfile() []byte {
+	// 		return []byte{0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a}
+	// 	}
+	//
+	// Here is the same functionality, but uses the `.rodata` hack.
+	// The byte slice returned from this example can not be written to without
+	// generating a runtime error.
+	//
+	// 	var _myfile = "\x89\x50\x4e\x47\x0d\x0a\x1a"
+	//
+	// 	func myfile() []byte {
+	// 		var empty [0]byte
+	// 		sx := (*reflect.StringHeader)(unsafe.Pointer(&_myfile))
+	// 		b := empty[:]
+	// 		bx := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	// 		bx.Data = sx.Data
+	// 		bx.Len = len(_myfile)
+	// 		bx.Cap = bx.Len
+	// 		return b
+	// 	}
+	NoMemCopy bool
+
+	// 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 false.
+	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
+
+	// Perform a dev build, which is nearly identical to the debug option. The
+	// only difference is that instead of absolute file paths in generated code,
+	// it expects a variable, `rootDir`, to be set in the generated code's
+	// package (the author needs to do this manually), which it then prepends to
+	// an asset's name to construct the file path on disk.
+	//
+	// This is mainly so you can push the generated code file to a shared
+	// repository.
+	Dev bool
+
+	// When true, size, mode and modtime are not preserved from files
+	NoMetadata bool
+	// When nonzero, use this as mode for all files.
+	Mode uint
+	// When nonzero, use this as unix timestamp for all files.
+	ModTime int64
+
+	// Ignores any filenames matching the regex pattern specified, e.g.
+	// path/to/file.ext will ignore only that file, or \\.gitignore
+	// will match any .gitignore file.
+	//
+	// This parameter can be provided multiple times.
+	Ignore []*regexp.Regexp
+}
+
+// NewConfig returns a default configuration struct.
+func NewConfig() *Config {
+	c := new(Config)
+	c.Package = "main"
+	c.NoMemCopy = false
+	c.NoCompress = false
+	c.Debug = false
+	c.Output = "./bindata.go"
+	c.Ignore = make([]*regexp.Regexp, 0)
+	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")
+	}
+
+	for _, input := range c.Input {
+		_, err := os.Lstat(input.Path)
+		if err != nil {
+			return fmt.Errorf("Failed to stat input path '%s': %v", input.Path, err)
+		}
+	}
+
+	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 {
+		if !os.IsNotExist(err) {
+			return fmt.Errorf("Output path: %v", err)
+		}
+
+		// File does not exist. This is fine, just make
+		// sure the directory it is to be in exists.
+		dir, _ := filepath.Split(c.Output)
+		if dir != "" {
+			err = os.MkdirAll(dir, 0744)
+
+			if err != nil {
+				return fmt.Errorf("Create output directory: %v", err)
+			}
+		}
+	}
+
+	if stat != nil && stat.IsDir() {
+		return fmt.Errorf("Output path is a directory.")
+	}
+
+	return nil
+}

convert.go

@@ -0,0 +1,261 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"unicode"
+)
+
+// Translate reads assets from an input directory, converts them
+// to Go code and writes new files to the output specified
+// in the given configuration.
+func Translate(c *Config) error {
+	var toc []Asset
+
+	// Ensure our configuration has sane values.
+	err := c.validate()
+	if err != nil {
+		return err
+	}
+
+	var knownFuncs = make(map[string]int)
+	var visitedPaths = make(map[string]bool)
+	// Locate all the assets.
+	for _, input := range c.Input {
+		err = findFiles(input.Path, c.Prefix, input.Recursive, &toc, c.Ignore, knownFuncs, visitedPaths)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Create output file.
+	fd, err := os.Create(c.Output)
+	if err != nil {
+		return err
+	}
+
+	defer fd.Close()
+
+	// Create a buffered writer for better performance.
+	bfd := bufio.NewWriter(fd)
+	defer bfd.Flush()
+
+	// Write the header. This makes e.g. Github ignore diffs in generated files.
+	if _, err = fmt.Fprint(bfd, "// Code generated by go-bindata.\n"); err != nil {
+		return err
+	}
+	if _, err = fmt.Fprint(bfd, "// sources:\n"); err != nil {
+		return err
+	}
+
+	wd, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+
+	for _, asset := range toc {
+		relative, _ := filepath.Rel(wd, asset.Path)
+		if _, err = fmt.Fprintf(bfd, "// %s\n", filepath.ToSlash(relative)); err != nil {
+			return err
+		}
+	}
+	if _, err = fmt.Fprint(bfd, "// DO NOT EDIT!\n\n"); err != nil {
+		return err
+	}
+
+	// Write build tags, if applicable.
+	if len(c.Tags) > 0 {
+		if _, err = fmt.Fprintf(bfd, "// +build %s\n\n", c.Tags); err != nil {
+			return err
+		}
+	}
+
+	// Write package declaration.
+	_, err = fmt.Fprintf(bfd, "package %s\n\n", c.Package)
+	if err != nil {
+		return err
+	}
+
+	// Write assets.
+	if c.Debug || c.Dev {
+		err = writeDebug(bfd, c, toc)
+	} else {
+		err = writeRelease(bfd, c, toc)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	// Write table of contents
+	if err := writeTOC(bfd, toc); err != nil {
+		return err
+	}
+	// Write hierarchical tree of assets
+	if err := writeTOCTree(bfd, toc); err != nil {
+		return err
+	}
+
+	// Write restore procedure
+	return writeRestore(bfd)
+}
+
+// Implement sort.Interface for []os.FileInfo based on Name()
+type ByName []os.FileInfo
+
+func (v ByName) Len() int           { return len(v) }
+func (v ByName) Swap(i, j int)      { v[i], v[j] = v[j], v[i] }
+func (v ByName) Less(i, j int) bool { return v[i].Name() < v[j].Name() }
+
+// findFiles recursively finds all the file paths in the given directory tree.
+// They are added to the given map as keys. Values will be safe function names
+// for each file, which will be used when generating the output code.
+func findFiles(dir, prefix string, recursive bool, toc *[]Asset, ignore []*regexp.Regexp, knownFuncs map[string]int, visitedPaths map[string]bool) error {
+	dirpath := dir
+	if len(prefix) > 0 {
+		dirpath, _ = filepath.Abs(dirpath)
+		prefix, _ = filepath.Abs(prefix)
+		prefix = filepath.ToSlash(prefix)
+	}
+
+	fi, err := os.Stat(dirpath)
+	if err != nil {
+		return err
+	}
+
+	var list []os.FileInfo
+
+	if !fi.IsDir() {
+		dirpath = filepath.Dir(dirpath)
+		list = []os.FileInfo{fi}
+	} else {
+		visitedPaths[dirpath] = true
+		fd, err := os.Open(dirpath)
+		if err != nil {
+			return err
+		}
+
+		defer fd.Close()
+
+		list, err = fd.Readdir(0)
+		if err != nil {
+			return err
+		}
+
+		// Sort to make output stable between invocations
+		sort.Sort(ByName(list))
+	}
+
+	for _, file := range list {
+		var asset Asset
+		asset.Path = filepath.Join(dirpath, file.Name())
+		asset.Name = filepath.ToSlash(asset.Path)
+
+		ignoring := false
+		for _, re := range ignore {
+			if re.MatchString(asset.Path) {
+				ignoring = true
+				break
+			}
+		}
+		if ignoring {
+			continue
+		}
+
+		if file.IsDir() {
+			if recursive {
+				recursivePath := filepath.Join(dir, file.Name())
+				visitedPaths[asset.Path] = true
+				findFiles(recursivePath, prefix, recursive, toc, ignore, knownFuncs, visitedPaths)
+			}
+			continue
+		} else if file.Mode()&os.ModeSymlink == os.ModeSymlink {
+			var linkPath string
+			if linkPath, err = os.Readlink(asset.Path); err != nil {
+				return err
+			}
+			if !filepath.IsAbs(linkPath) {
+				if linkPath, err = filepath.Abs(dirpath + "/" + linkPath); err != nil {
+					return err
+				}
+			}
+			if _, ok := visitedPaths[linkPath]; !ok {
+				visitedPaths[linkPath] = true
+				findFiles(asset.Path, prefix, recursive, toc, ignore, knownFuncs, visitedPaths)
+			}
+			continue
+		}
+
+		if strings.HasPrefix(asset.Name, prefix) {
+			asset.Name = asset.Name[len(prefix):]
+		} else {
+			asset.Name = filepath.Join(dir, file.Name())
+		}
+
+		// If we have a leading slash, get rid of it.
+		if len(asset.Name) > 0 && asset.Name[0] == '/' {
+			asset.Name = asset.Name[1:]
+		}
+
+		// This shouldn't happen.
+		if len(asset.Name) == 0 {
+			return fmt.Errorf("Invalid file: %v", asset.Path)
+		}
+
+		asset.Func = safeFunctionName(asset.Name, knownFuncs)
+		asset.Path, _ = filepath.Abs(asset.Path)
+		*toc = append(*toc, asset)
+	}
+
+	return nil
+}
+
+var regFuncName = regexp.MustCompile(`[^a-zA-Z0-9_]`)
+
+// safeFunctionName converts the given name into a name
+// which qualifies as a valid function identifier. It
+// also compares against a known list of functions to
+// prevent conflict based on name translation.
+func safeFunctionName(name string, knownFuncs map[string]int) string {
+	var inBytes, outBytes []byte
+	var toUpper bool
+
+	name = strings.ToLower(name)
+	inBytes = []byte(name)
+
+	for i := 0; i < len(inBytes); i++ {
+		if regFuncName.Match([]byte{inBytes[i]}) {
+			toUpper = true
+		} else if toUpper {
+			outBytes = append(outBytes, []byte(strings.ToUpper(string(inBytes[i])))...)
+			toUpper = false
+		} else {
+			outBytes = append(outBytes, inBytes[i])
+		}
+	}
+
+	name = string(outBytes)
+
+	// Identifier can't start with a digit.
+	if unicode.IsDigit(rune(name[0])) {
+		name = "_" + name
+	}
+
+	if num, ok := knownFuncs[name]; ok {
+		knownFuncs[name] = num + 1
+		name = fmt.Sprintf("%s%d", name, num)
+	} else {
+		knownFuncs[name] = 2
+	}
+
+	return name
+}

convert_test.go

@@ -0,0 +1,90 @@
+package bindata
+
+import (
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestSafeFunctionName(t *testing.T) {
+	var knownFuncs = make(map[string]int)
+	name1 := safeFunctionName("foo/bar", knownFuncs)
+	name2 := safeFunctionName("foo_bar", knownFuncs)
+	if name1 == name2 {
+		t.Errorf("name collision")
+	}
+}
+
+func TestFindFiles(t *testing.T) {
+	var toc []Asset
+	var knownFuncs = make(map[string]int)
+	var visitedPaths = make(map[string]bool)
+	err := findFiles("testdata/dupname", "testdata/dupname", true, &toc, []*regexp.Regexp{}, knownFuncs, visitedPaths)
+	if err != nil {
+		t.Errorf("expected to be no error: %+v", err)
+	}
+	if toc[0].Func == toc[1].Func {
+		t.Errorf("name collision")
+	}
+}
+
+func TestFindFilesWithSymlinks(t *testing.T) {
+	var tocSrc []Asset
+	var tocTarget []Asset
+
+	var knownFuncs = make(map[string]int)
+	var visitedPaths = make(map[string]bool)
+	err := findFiles("testdata/symlinkSrc", "testdata/symlinkSrc", true, &tocSrc, []*regexp.Regexp{}, knownFuncs, visitedPaths)
+	if err != nil {
+		t.Errorf("expected to be no error: %+v", err)
+	}
+
+	knownFuncs = make(map[string]int)
+	visitedPaths = make(map[string]bool)
+	err = findFiles("testdata/symlinkParent", "testdata/symlinkParent", true, &tocTarget, []*regexp.Regexp{}, knownFuncs, visitedPaths)
+	if err != nil {
+		t.Errorf("expected to be no error: %+v", err)
+	}
+
+	if len(tocSrc) != len(tocTarget) {
+		t.Errorf("Symlink source and target should have the same number of assets.  Expected %d got %d", len(tocTarget), len(tocSrc))
+	} else {
+		for i, _ := range tocSrc {
+			targetFunc := strings.TrimPrefix(tocTarget[i].Func, "symlinktarget")
+			targetFunc = strings.ToLower(targetFunc[:1]) + targetFunc[1:]
+			if tocSrc[i].Func != targetFunc {
+				t.Errorf("Symlink source and target produced different function lists.  Expected %s to be %s", targetFunc, tocSrc[i].Func)
+			}
+		}
+	}
+}
+
+func TestFindFilesWithRecursiveSymlinks(t *testing.T) {
+	var toc []Asset
+
+	var knownFuncs = make(map[string]int)
+	var visitedPaths = make(map[string]bool)
+	err := findFiles("testdata/symlinkRecursiveParent", "testdata/symlinkRecursiveParent", true, &toc, []*regexp.Regexp{}, knownFuncs, visitedPaths)
+	if err != nil {
+		t.Errorf("expected to be no error: %+v", err)
+	}
+
+	if len(toc) != 1 {
+		t.Errorf("Only one asset should have been found.  Got %d: %v", len(toc), toc)
+	}
+}
+
+func TestFindFilesWithSymlinkedFile(t *testing.T) {
+	var toc []Asset
+
+	var knownFuncs = make(map[string]int)
+	var visitedPaths = make(map[string]bool)
+	err := findFiles("testdata/symlinkFile", "testdata/symlinkFile", true, &toc, []*regexp.Regexp{}, knownFuncs, visitedPaths)
+	if err != nil {
+		t.Errorf("expected to be no error: %+v", err)
+	}
+
+	if len(toc) != 1 {
+		t.Errorf("Only one asset should have been found.  Got %d: %v", len(toc), toc)
+	}
+}

debug.go

@@ -0,0 +1,87 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+import (
+	"fmt"
+	"io"
+)
+
+// writeDebug writes the debug code file.
+func writeDebug(w io.Writer, c *Config, toc []Asset) error {
+	err := writeDebugHeader(w)
+	if err != nil {
+		return err
+	}
+
+	for i := range toc {
+		err = writeDebugAsset(w, c, &toc[i])
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// writeDebugHeader writes output file headers.
+// This targets debug builds.
+func writeDebugHeader(w io.Writer) error {
+	_, err := fmt.Fprintf(w, `import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// bindataRead reads the given file from disk. It returns an error on failure.
+func bindataRead(path, name string) ([]byte, error) {
+	buf, err := ioutil.ReadFile(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset %%s at %%s: %%v", name, path, err)
+	}
+	return buf, err
+}
+
+type asset struct {
+	bytes []byte
+	info  os.FileInfo
+}
+
+`)
+	return err
+}
+
+// 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 {
+	pathExpr := fmt.Sprintf("%q", asset.Path)
+	if c.Dev {
+		pathExpr = fmt.Sprintf("filepath.Join(rootDir, %q)", asset.Name)
+	}
+
+	_, err := fmt.Fprintf(w, `// %s reads file data from disk. It returns an error on failure.
+func %s() (*asset, error) {
+	path := %s
+	name := %q
+	bytes, err := bindataRead(path, name)
+	if err != nil {
+		return nil, err
+	}
+
+	fi, err := os.Stat(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset info %%s at %%s: %%v", name, path, err)
+	}
+
+	a := &asset{bytes: bytes, info: fi}
+	return a, err
+}
+
+`, asset.Func, asset.Func, pathExpr, asset.Name)
+	return err
+}

doc.go

@@ -0,0 +1,129 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+/*
+bindata converts any file into managable Go source code. Useful for
+embedding binary data into a go program. The file data is optionally gzip
+compressed before being converted to a raw byte slice.
+
+The following paragraphs cover some of the customization options
+which can be specified in the Config struct, which must be passed into
+the Translate() call.
+
+
+Debug vs Release builds
+
+When used with the `Debug` option, the generated code does not actually include
+the asset data. Instead, it generates function stubs which load the data from
+the original file on disk. The asset API remains identical between debug and
+release builds, so your code will not have to change.
+
+This is useful during development when you expect the assets to change often.
+The host application using these assets uses the same API in both cases and
+will not have to care where the actual data comes from.
+
+An example is a Go webserver with some embedded, static web content like
+HTML, JS and CSS files. While developing it, you do not want to rebuild the
+whole server and restart it every time you make a change to a bit of
+javascript. You just want to build and launch the server once. Then just press
+refresh in the browser to see those changes. Embedding the assets with the
+`debug` flag allows you to do just that. When you are finished developing and
+ready for deployment, just re-invoke `go-bindata` without the `-debug` flag.
+It will now embed the latest version of the assets.
+
+
+Lower memory footprint
+
+The `NoMemCopy` option will alter the way the output file is generated.
+It will employ a hack that allows us to read the file data directly from
+the compiled program's `.rodata` section. This ensures that when we call
+call our generated function, we omit unnecessary memcopies.
+
+The downside of this, is that it requires dependencies on the `reflect` and
+`unsafe` packages. These may be restricted on platforms like AppEngine and
+thus prevent you from using this mode.
+
+Another disadvantage is that the byte slice we create, is strictly read-only.
+For most use-cases this is not a problem, but if you ever try to alter the
+returned byte slice, a runtime panic is thrown. Use this mode only on target
+platforms where memory constraints are an issue.
+
+The default behaviour is to use the old code generation method. This
+prevents the two previously mentioned issues, but will employ at least one
+extra memcopy and thus increase memory requirements.
+
+For instance, consider the following two examples:
+
+This would be the default mode, using an extra memcopy but gives a safe
+implementation without dependencies on `reflect` and `unsafe`:
+
+	func myfile() []byte {
+		return []byte{0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a}
+	}
+
+Here is the same functionality, but uses the `.rodata` hack.
+The byte slice returned from this example can not be written to without
+generating a runtime error.
+
+	var _myfile = "\x89\x50\x4e\x47\x0d\x0a\x1a"
+
+	func myfile() []byte {
+		var empty [0]byte
+		sx := (*reflect.StringHeader)(unsafe.Pointer(&_myfile))
+		b := empty[:]
+		bx := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+		bx.Data = sx.Data
+		bx.Len = len(_myfile)
+		bx.Cap = bx.Len
+		return b
+	}
+
+
+Optional compression
+
+The NoCompress option indicates that the supplied assets are *not* GZIP
+compressed before being turned into Go code. The data should still be accessed
+through a function call, so nothing changes in the API.
+
+This feature is useful if you do not care for compression, or the supplied
+resource is already compressed. Doing it again would not add any value and may
+even increase the size of the data.
+
+The default behaviour of the program is to use compression.
+
+
+Path prefix stripping
+
+The keys used in the `_bindata` map are the same as the input file name
+passed to `go-bindata`. This includes the path. In most cases, this is not
+desireable, as it puts potentially sensitive information in your code base.
+For this purpose, the tool supplies another command line flag `-prefix`.
+This accepts a portion of a path name, which should be stripped off from
+the map keys and function names.
+
+For example, running without the `-prefix` flag, we get:
+
+	$ go-bindata /path/to/templates/
+
+	_bindata["/path/to/templates/foo.html"] = path_to_templates_foo_html
+
+Running with the `-prefix` flag, we get:
+
+	$ go-bindata -prefix "/path/to/" /path/to/templates/
+
+	_bindata["templates/foo.html"] = templates_foo_html
+
+
+Build tags
+
+With the optional Tags field, you can specify any go build tags that
+must be fulfilled for the output file to be included in a build. This
+is useful when including binary data in multiple formats, where the desired
+format is specified at build time with the appropriate tags.
+
+The tags are appended to a `// +build` line in the beginning of the output file
+and must follow the build tags syntax specified by the go tool.
+
+*/
+package bindata

go-bindata/AppendSliceValue.go

@@ -0,0 +1,22 @@
+package main
+
+import "strings"
+
+// borrowed from https://github.com/hashicorp/serf/blob/master/command/agent/flag_slice_value.go
+
+// AppendSliceValue implements the flag.Value interface and allows multiple
+// calls to the same variable to append a list.
+type AppendSliceValue []string
+
+func (s *AppendSliceValue) String() string {
+	return strings.Join(*s, ",")
+}
+
+func (s *AppendSliceValue) Set(value string) error {
+	if *s == nil {
+		*s = make([]string, 0, 1)
+	}
+
+	*s = append(*s, value)
+	return nil
+}

go-bindata/main.go

@@ -0,0 +1,107 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"git.kirsle.net/go/bindata"
+)
+
+func main() {
+	cfg := parseArgs()
+	err := bindata.Translate(cfg)
+
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "bindata: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+// parseArgs create s a new, filled configuration instance
+// by reading and parsing command line options.
+//
+// This function exits the program with an error, if
+// any of the command line options are incorrect.
+func parseArgs() *bindata.Config {
+	var version bool
+
+	c := bindata.NewConfig()
+
+	flag.Usage = func() {
+		fmt.Printf("Usage: %s [options] <input directories>\n\n", os.Args[0])
+		flag.PrintDefaults()
+	}
+
+	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.BoolVar(&c.Dev, "dev", c.Dev, "Similar to debug, but does not emit absolute paths. Expects a rootDir variable to already exist in the generated code's package.")
+	flag.StringVar(&c.Tags, "tags", c.Tags, "Optional set of build 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.NoCompress, "nocompress", c.NoCompress, "Assets will *not* be GZIP compressed when this flag is specified.")
+	flag.BoolVar(&c.NoMetadata, "nometadata", c.NoMetadata, "Assets will not preserve size, mode, and modtime info.")
+	flag.UintVar(&c.Mode, "mode", c.Mode, "Optional file mode override for all files.")
+	flag.Int64Var(&c.ModTime, "modtime", c.ModTime, "Optional modification unix timestamp override for all files.")
+	flag.StringVar(&c.Output, "o", c.Output, "Optional name of the output file to be generated.")
+	flag.BoolVar(&version, "version", false, "Displays version information.")
+
+	ignore := make([]string, 0)
+	flag.Var((*AppendSliceValue)(&ignore), "ignore", "Regex pattern to ignore")
+
+	flag.Parse()
+
+	patterns := make([]*regexp.Regexp, 0)
+	for _, pattern := range ignore {
+		patterns = append(patterns, regexp.MustCompile(pattern))
+	}
+	c.Ignore = patterns
+
+	if version {
+		fmt.Printf("%s\n", Version())
+		os.Exit(0)
+	}
+
+	// Make sure we have input paths.
+	if flag.NArg() == 0 {
+		fmt.Fprintf(os.Stderr, "Missing <input dir>\n\n")
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	// Create input configurations.
+	c.Input = make([]bindata.InputConfig, flag.NArg())
+	for i := range c.Input {
+		c.Input[i] = parseInput(flag.Arg(i))
+	}
+
+	return c
+}
+
+// parseRecursive determines whether the given path has a recrusive indicator and
+// returns a new path with the recursive indicator chopped off if it does.
+//
+//  ex:
+//      /path/to/foo/...    -> (/path/to/foo, true)
+//      /path/to/bar        -> (/path/to/bar, false)
+func parseInput(path string) bindata.InputConfig {
+	if strings.HasSuffix(path, "/...") {
+		return bindata.InputConfig{
+			Path:      filepath.Clean(path[:len(path)-4]),
+			Recursive: true,
+		}
+	} else {
+		return bindata.InputConfig{
+			Path:      filepath.Clean(path),
+			Recursive: false,
+		}
+	}
+
+}

go-bindata/version.go

@@ -2,7 +2,7 @@
 // license. Its contents can be found at:
 // http://creativecommons.org/publicdomain/zero/1.0/
 
-package bindata
+package main
 
 import (
 	"fmt"
@@ -10,8 +10,8 @@ import (
 )
 
 const (
-	AppName         = "bindata"
-	AppVersionMajor = 2
+	AppName         = "go-bindata"
+	AppVersionMajor = 3
 	AppVersionMinor = 1
 )
 

lib/toc.go

@@ -1,39 +0,0 @@
-// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
-// license. Its contents can be found at:
-// http://creativecommons.org/publicdomain/zero/1.0/
-
-package bindata
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"path/filepath"
-	"strings"
-)
-
-// createTOC writes a table of contents file to the given location.
-func CreateTOC(dir, pkgname string) error {
-	file := filepath.Join(dir, "bindata-toc.go")
-	code := fmt.Sprintf(`package %s
-
-// Global Table of Contents map. Generated by go-bindata.
-// After startup of the program, all generated data files will
-// put themselves in this map. The key is the full filename, as
-// supplied to go-bindata.
-var go_bindata = make(map[string]func() []byte)`, pkgname)
-
-	return ioutil.WriteFile(file, []byte(code), 0600)
-}
-
-// WriteTOCInit writes the TOC init function for a given data file
-// replacing the prefix in the filename by "", funcname being the translated function name
-func WriteTOCInit(output io.Writer, filename, prefix, funcname string) {
-	filename = strings.Replace(filename, prefix, "", 1)
-	fmt.Fprintf(output, `
-
-func init() {
-	go_bindata[%q] = %s
-}
-`, filename, funcname)
-}

lib/translate.go

@@ -1,187 +0,0 @@
-// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
-// license. Its contents can be found at:
-// http://creativecommons.org/publicdomain/zero/1.0/
-
-package bindata
-
-import (
-	"compress/gzip"
-	"fmt"
-	"io"
-	"regexp"
-	"strings"
-	"unicode"
-)
-
-var regFuncName = regexp.MustCompile(`[^a-zA-Z0-9_]`)
-
-// translate translates the input file to go source code.
-func Translate(input io.Reader, output io.Writer, pkgname, funcname string, uncompressed, nomemcpy bool) {
-	if nomemcpy {
-		if uncompressed {
-			translate_nomemcpy_uncomp(input, output, pkgname, funcname)
-		} else {
-			translate_nomemcpy_comp(input, output, pkgname, funcname)
-		}
-	} else {
-		if uncompressed {
-			translate_memcpy_uncomp(input, output, pkgname, funcname)
-		} else {
-			translate_memcpy_comp(input, output, pkgname, funcname)
-		}
-	}
-}
-
-// input -> gzip -> gowriter -> output.
-func translate_memcpy_comp(input io.Reader, output io.Writer, pkgname, funcname string) {
-	fmt.Fprintf(output, `package %s
-
-import (
-	"bytes"
-	"compress/gzip"
-	"io"
-)
-
-// %s returns raw, uncompressed file data.
-func %s() []byte {
-	gz, err := gzip.NewReader(bytes.NewBuffer([]byte{`, pkgname, funcname, funcname)
-
-	gz := gzip.NewWriter(&ByteWriter{Writer: output})
-	io.Copy(gz, input)
-	gz.Close()
-
-	fmt.Fprint(output, `
-	}))
-
-	if err != nil {
-		panic("Decompression failed: " + err.Error())
-	}
-
-	var b bytes.Buffer
-	io.Copy(&b, gz)
-	gz.Close()
-
-	return b.Bytes()
-}`)
-}
-
-// input -> gzip -> gowriter -> output.
-func translate_memcpy_uncomp(input io.Reader, output io.Writer, pkgname, funcname string) {
-	fmt.Fprintf(output, `package %s
-
-// %s returns raw file data.
-func %s() []byte {
-	return []byte{`, pkgname, funcname, funcname)
-
-	io.Copy(&ByteWriter{Writer: output}, input)
-
-	fmt.Fprint(output, `
-	}
-}`)
-}
-
-// input -> gzip -> gowriter -> output.
-func translate_nomemcpy_comp(input io.Reader, output io.Writer, pkgname, funcname string) {
-	fmt.Fprintf(output, `package %s
-
-import (
-	"bytes"
-	"compress/gzip"
-	"io"
-	"reflect"
-	"unsafe"
-)
-
-var _%s = "`, pkgname, funcname)
-
-	gz := gzip.NewWriter(&StringWriter{Writer: output})
-	io.Copy(gz, input)
-	gz.Close()
-
-	fmt.Fprintf(output, `"
-
-// %s returns raw, uncompressed file data.
-func %s() []byte {
-	var empty [0]byte
-	sx := (*reflect.StringHeader)(unsafe.Pointer(&_%s))
-	b := empty[:]
-	bx := (*reflect.SliceHeader)(unsafe.Pointer(&b))
-	bx.Data = sx.Data
-	bx.Len = len(_%s)
-	bx.Cap = bx.Len
-
-	gz, err := gzip.NewReader(bytes.NewBuffer(b))
-
-	if err != nil {
-		panic("Decompression failed: " + err.Error())
-	}
-
-	var buf bytes.Buffer
-	io.Copy(&buf, gz)
-	gz.Close()
-
-	return buf.Bytes()
-}
-`, funcname, funcname, funcname, funcname)
-}
-
-// input -> gowriter -> output.
-func translate_nomemcpy_uncomp(input io.Reader, output io.Writer, pkgname, funcname string) {
-	fmt.Fprintf(output, `package %s
-
-import (
-	"reflect"
-	"unsafe"
-)
-
-var _%s = "`, pkgname, funcname)
-
-	io.Copy(&StringWriter{Writer: output}, input)
-
-	fmt.Fprintf(output, `"
-
-// %s returns raw file data.
-//
-// WARNING: The returned byte slice is READ-ONLY.
-// Attempting to alter the slice contents will yield a runtime panic.
-func %s() []byte {
-	var empty [0]byte
-	sx := (*reflect.StringHeader)(unsafe.Pointer(&_%s))
-	b := empty[:]
-	bx := (*reflect.SliceHeader)(unsafe.Pointer(&b))
-	bx.Data = sx.Data
-	bx.Len = len(_%s)
-	bx.Cap = bx.Len
-	return b
-}
-`, funcname, funcname, funcname, funcname)
-}
-
-// safeFuncname creates a safe function name from the input path.
-func SafeFuncname(in, prefix string) string {
-	name := strings.Replace(in, prefix, "", 1)
-
-	if len(name) == 0 {
-		name = in
-	}
-
-	name = strings.ToLower(name)
-	name = regFuncName.ReplaceAllString(name, "_")
-
-	if unicode.IsDigit(rune(name[0])) {
-		// Identifier can't start with a digit.
-		name = "_" + name
-	}
-
-	// Get rid of "__" instances for niceness.
-	for strings.Index(name, "__") > -1 {
-		name = strings.Replace(name, "__", "_", -1)
-	}
-
-	// Leading underscore is silly.
-	if name[0] == '_' {
-		name = name[1:]
-	}
-
-	return name
-}

main.go

@@ -1,157 +0,0 @@
-// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
-// license. Its contents can be found at:
-// http://creativecommons.org/publicdomain/zero/1.0/
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"github.com/jteeuwen/go-bindata/lib"
-	"os"
-	"path"
-	"path/filepath"
-	"unicode"
-)
-
-var (
-	pipe         = false
-	in           = ""
-	out          = flag.String("out", "", "Optional path and name of the output file.")
-	pkgname      = flag.String("pkg", "main", "Name of the package to generate.")
-	funcname     = flag.String("func", "", "Optional name of the function to generate.")
-	prefix       = flag.String("prefix", "", "Optional path prefix to strip off map keys and function names.")
-	uncompressed = flag.Bool("uncompressed", false, "The specified resource will /not/ be GZIP compressed when this flag is specified. This alters the generated output code.")
-	nomemcopy    = flag.Bool("nomemcopy", false, "Use a .rodata hack to get rid of unnecessary memcopies. Refer to the documentation to see what implications this carries.")
-	tags         = flag.String("tags", "", "Optional build tags")
-	toc          = flag.Bool("toc", false, "Generate a table of contents for this and other files. The input filepath becomes the map key. This option is only useable in non-pipe mode.")
-	version      = flag.Bool("version", false, "Display version information.")
-)
-
-func main() {
-	parseArgs()
-
-	if pipe {
-		bindata.Translate(os.Stdin, os.Stdout, *pkgname, *funcname, *uncompressed, *nomemcopy)
-		return
-	}
-
-	fs, err := os.Open(in)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "[e] %s\n", err)
-		return
-	}
-
-	defer fs.Close()
-
-	fd, err := os.Create(*out)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "[e] %s\n", err)
-		return
-	}
-
-	defer fd.Close()
-
-	if *tags != "" {
-		fmt.Fprintf(fd, "// +build %s\n\n", *tags)
-	}
-
-	// Translate binary to Go code.
-	bindata.Translate(fs, fd, *pkgname, *funcname, *uncompressed, *nomemcopy)
-
-	// Append the TOC init function to the end of the output file and
-	// write the `bindata-toc.go` file, if applicable.
-	if *toc {
-		dir, _ := filepath.Split(*out)
-		err := bindata.CreateTOC(dir, *pkgname)
-
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "[e] %s\n", err)
-			return
-		}
-
-		bindata.WriteTOCInit(fd, in, *prefix, *funcname)
-	}
-}
-
-// parseArgs processes and verifies commandline arguments.
-func parseArgs() {
-	flag.Usage = func() {
-		fmt.Printf("Usage: %s [options] <filename>\n\n", os.Args[0])
-		flag.PrintDefaults()
-	}
-	flag.Parse()
-
-	if *version {
-		fmt.Printf("%s\n", bindata.Version())
-		os.Exit(0)
-	}
-
-	pipe = flag.NArg() == 0
-
-	if !pipe {
-		*prefix, _ = filepath.Abs(filepath.Clean(*prefix))
-		in, _ = filepath.Abs(filepath.Clean(flag.Args()[0]))
-		*out = safeFilename(*out, in)
-	}
-
-	if len(*pkgname) == 0 {
-		fmt.Fprintln(os.Stderr, "[w] No package name specified. Using 'main'.")
-		*pkgname = "main"
-	} else {
-		if unicode.IsDigit(rune((*pkgname)[0])) {
-			// Identifier can't start with a digit.
-			*pkgname = "_" + *pkgname
-		}
-	}
-
-	if len(*funcname) == 0 {
-		if pipe {
-			// Can't infer from input file name in this mode.
-			fmt.Fprintln(os.Stderr, "[e] No function name specified.")
-			os.Exit(1)
-		}
-
-		*funcname = bindata.SafeFuncname(in, *prefix)
-		fmt.Fprintf(os.Stderr, "[w] No function name specified. Using %s.\n", *funcname)
-	}
-}
-
-// safeFilename creates a safe output filename from the given
-// output and input paths.
-func safeFilename(out, in string) string {
-	var filename string
-
-	if len(out) == 0 {
-		filename = in + ".go"
-
-		_, err := os.Lstat(filename)
-		if err == nil {
-			// File already exists. Pad name with a sequential number until we
-			// find a name that is available.
-			count := 0
-
-			for {
-				filename = path.Join(out, fmt.Sprintf("%s.%d.go", in, count))
-				_, err = os.Lstat(filename)
-
-				if err != nil {
-					break
-				}
-
-				count++
-			}
-		}
-	} else {
-		filename, _ = filepath.Abs(filepath.Clean(out))
-	}
-
-	// Ensure output directory exists while we're here.
-	dir, _ := filepath.Split(filename)
-	_, err := os.Lstat(dir)
-	if err != nil {
-		os.MkdirAll(dir, 0755)
-	}
-
-	return filename
-}

release.go

@@ -0,0 +1,387 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"unicode/utf8"
+)
+
+// writeRelease writes the release code file.
+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(w, c, &toc[i])
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// writeReleaseHeader writes output file headers.
+// This targets release builds.
+func writeReleaseHeader(w io.Writer, c *Config) error {
+	var err error
+	if c.NoCompress {
+		if c.NoMemCopy {
+			err = header_uncompressed_nomemcopy(w)
+		} else {
+			err = header_uncompressed_memcopy(w)
+		}
+	} else {
+		if c.NoMemCopy {
+			err = header_compressed_nomemcopy(w)
+		} else {
+			err = header_compressed_memcopy(w)
+		}
+	}
+	if err != nil {
+		return err
+	}
+	return header_release_common(w)
+}
+
+// writeReleaseAsset write a release entry for the given asset.
+// A release entry is a function which embeds and returns
+// the file's byte content.
+func writeReleaseAsset(w io.Writer, c *Config, asset *Asset) error {
+	fd, err := os.Open(asset.Path)
+	if err != nil {
+		return err
+	}
+
+	defer fd.Close()
+
+	if c.NoCompress {
+		if c.NoMemCopy {
+			err = uncompressed_nomemcopy(w, asset, fd)
+		} else {
+			err = uncompressed_memcopy(w, asset, fd)
+		}
+	} else {
+		if c.NoMemCopy {
+			err = compressed_nomemcopy(w, asset, fd)
+		} else {
+			err = compressed_memcopy(w, asset, fd)
+		}
+	}
+	if err != nil {
+		return err
+	}
+	return asset_release_common(w, c, asset)
+}
+
+// sanitize prepares a valid UTF-8 string as a raw string constant.
+// Based on https://code.google.com/p/go/source/browse/godoc/static/makestatic.go?repo=tools
+func sanitize(b []byte) []byte {
+	// Replace ` with `+"`"+`
+	b = bytes.Replace(b, []byte("`"), []byte("`+\"`\"+`"), -1)
+
+	// Replace BOM with `+"\xEF\xBB\xBF"+`
+	// (A BOM is valid UTF-8 but not permitted in Go source files.
+	// I wouldn't bother handling this, but for some insane reason
+	// jquery.js has a BOM somewhere in the middle.)
+	return bytes.Replace(b, []byte("\xEF\xBB\xBF"), []byte("`+\"\\xEF\\xBB\\xBF\"+`"), -1)
+}
+
+func header_compressed_nomemcopy(w io.Writer) error {
+	_, err := fmt.Fprintf(w, `import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+func bindataRead(data, name string) ([]byte, error) {
+	gz, err := gzip.NewReader(strings.NewReader(data))
+	if err != nil {
+		return nil, fmt.Errorf("Read %%q: %%v", name, err)
+	}
+
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, gz)
+	clErr := gz.Close()
+
+	if err != nil {
+		return nil, fmt.Errorf("Read %%q: %%v", name, err)
+	}
+	if clErr != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+`)
+	return err
+}
+
+func header_compressed_memcopy(w io.Writer) error {
+	_, err := fmt.Fprintf(w, `import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+func bindataRead(data []byte, name string) ([]byte, error) {
+	gz, err := gzip.NewReader(bytes.NewBuffer(data))
+	if err != nil {
+		return nil, fmt.Errorf("Read %%q: %%v", name, err)
+	}
+
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, gz)
+	clErr := gz.Close()
+
+	if err != nil {
+		return nil, fmt.Errorf("Read %%q: %%v", name, err)
+	}
+	if clErr != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+`)
+	return err
+}
+
+func header_uncompressed_nomemcopy(w io.Writer) error {
+	_, err := fmt.Fprintf(w, `import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"time"
+	"unsafe"
+)
+
+func bindataRead(data, name string) ([]byte, error) {
+	var empty [0]byte
+	sx := (*reflect.StringHeader)(unsafe.Pointer(&data))
+	b := empty[:]
+	bx := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	bx.Data = sx.Data
+	bx.Len = len(data)
+	bx.Cap = bx.Len
+	return b, nil
+}
+
+`)
+	return err
+}
+
+func header_uncompressed_memcopy(w io.Writer) error {
+	_, err := fmt.Fprintf(w, `import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+`)
+	return err
+}
+
+func header_release_common(w io.Writer) error {
+	_, err := fmt.Fprintf(w, `type asset struct {
+	bytes []byte
+	info  os.FileInfo
+}
+
+type bindataFileInfo struct {
+	name    string
+	size    int64
+	mode    os.FileMode
+	modTime time.Time
+}
+
+func (fi bindataFileInfo) Name() string {
+	return fi.name
+}
+func (fi bindataFileInfo) Size() int64 {
+	return fi.size
+}
+func (fi bindataFileInfo) Mode() os.FileMode {
+	return fi.mode
+}
+func (fi bindataFileInfo) ModTime() time.Time {
+	return fi.modTime
+}
+func (fi bindataFileInfo) IsDir() bool {
+	return false
+}
+func (fi bindataFileInfo) Sys() interface{} {
+	return nil
+}
+
+`)
+	return err
+}
+
+func compressed_nomemcopy(w io.Writer, asset *Asset, r io.Reader) error {
+	_, err := fmt.Fprintf(w, `var _%s = "`, asset.Func)
+	if err != nil {
+		return err
+	}
+
+	gz := gzip.NewWriter(&StringWriter{Writer: w})
+	_, err = io.Copy(gz, r)
+	gz.Close()
+
+	if err != nil {
+		return err
+	}
+
+	_, err = fmt.Fprintf(w, `"
+
+func %sBytes() ([]byte, error) {
+	return bindataRead(
+		_%s,
+		%q,
+	)
+}
+
+`, asset.Func, asset.Func, asset.Name)
+	return err
+}
+
+func compressed_memcopy(w io.Writer, asset *Asset, r io.Reader) error {
+	_, err := fmt.Fprintf(w, `var _%s = []byte("`, asset.Func)
+	if err != nil {
+		return err
+	}
+
+	gz := gzip.NewWriter(&StringWriter{Writer: w})
+	_, err = io.Copy(gz, r)
+	gz.Close()
+
+	if err != nil {
+		return err
+	}
+
+	_, err = fmt.Fprintf(w, `")
+
+func %sBytes() ([]byte, error) {
+	return bindataRead(
+		_%s,
+		%q,
+	)
+}
+
+`, asset.Func, asset.Func, asset.Name)
+	return err
+}
+
+func uncompressed_nomemcopy(w io.Writer, asset *Asset, r io.Reader) error {
+	_, err := fmt.Fprintf(w, `var _%s = "`, asset.Func)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(&StringWriter{Writer: w}, r)
+	if err != nil {
+		return err
+	}
+
+	_, err = fmt.Fprintf(w, `"
+
+func %sBytes() ([]byte, error) {
+	return bindataRead(
+		_%s,
+		%q,
+	)
+}
+
+`, asset.Func, asset.Func, asset.Name)
+	return err
+}
+
+func uncompressed_memcopy(w io.Writer, asset *Asset, r io.Reader) error {
+	_, err := fmt.Fprintf(w, `var _%s = []byte(`, asset.Func)
+	if err != nil {
+		return err
+	}
+
+	b, err := ioutil.ReadAll(r)
+	if err != nil {
+		return err
+	}
+	if utf8.Valid(b) && !bytes.Contains(b, []byte{0}) {
+		fmt.Fprintf(w, "`%s`", sanitize(b))
+	} else {
+		fmt.Fprintf(w, "%+q", b)
+	}
+
+	_, err = fmt.Fprintf(w, `)
+
+func %sBytes() ([]byte, error) {
+	return _%s, nil
+}
+
+`, asset.Func, asset.Func)
+	return err
+}
+
+func asset_release_common(w io.Writer, c *Config, asset *Asset) error {
+	fi, err := os.Stat(asset.Path)
+	if err != nil {
+		return err
+	}
+
+	mode := uint(fi.Mode())
+	modTime := fi.ModTime().Unix()
+	size := fi.Size()
+	if c.NoMetadata {
+		mode = 0
+		modTime = 0
+		size = 0
+	}
+	if c.Mode > 0 {
+		mode = uint(os.ModePerm) & c.Mode
+	}
+	if c.ModTime > 0 {
+		modTime = c.ModTime
+	}
+	_, err = fmt.Fprintf(w, `func %s() (*asset, error) {
+	bytes, err := %sBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: %q, size: %d, mode: os.FileMode(%d), modTime: time.Unix(%d, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+`, asset.Func, asset.Func, asset.Name, size, mode, modTime)
+	return err
+}

restore.go

@@ -0,0 +1,63 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+import (
+	"fmt"
+	"io"
+)
+
+func writeRestore(w io.Writer) error {
+	_, err := fmt.Fprintf(w, `
+// RestoreAsset restores an asset under the given directory
+func RestoreAsset(dir, name string) error {
+	data, err := Asset(name)
+	if err != nil {
+		return err
+	}
+	info, err := AssetInfo(name)
+	if err != nil {
+		return err
+	}
+	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
+	if err != nil {
+		return err
+	}
+	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// RestoreAssets restores an asset under the given directory recursively
+func RestoreAssets(dir, name string) error {
+	children, err := AssetDir(name)
+	// File
+	if err != nil {
+		return RestoreAsset(dir, name)
+	}
+	// Dir
+	for _, child := range children {
+		err = RestoreAssets(dir, filepath.Join(name, child))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func _filePath(dir, name string) string {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
+}
+
+`)
+	return err
+}

stringwriter.go

@@ -5,10 +5,11 @@
 package bindata
 
 import (
-	"fmt"
 	"io"
 )
 
+const lowerHex = "0123456789abcdef"
+
 type StringWriter struct {
 	io.Writer
 	c int
@@ -19,8 +20,13 @@ func (w *StringWriter) Write(p []byte) (n int, err error) {
 		return
 	}
 
-	for n = range p {
-		fmt.Fprintf(w.Writer, "\\x%02x", p[n])
+	buf := []byte(`\x00`)
+	var b byte
+
+	for n, b = range p {
+		buf[2] = lowerHex[b/16]
+		buf[3] = lowerHex[b%16]
+		w.Writer.Write(buf)
 		w.c++
 	}
 

testdata/Makefile

@@ -0,0 +1,37 @@
+FILES:=$(wildcard out/*.go)
+
+.PHONY: check
+check: errcheck vet golint $(FILES:.go=.checked)
+
+out/%.checked: out/%.go
+	errcheck $<
+	go tool vet --all $<
+	go tool vet --shadow $<
+	golint $<
+
+$(GOPATH)/bin/go-bindata: $(wildcard ../*.go) $(wildcard ../**/*.go)
+	go install ../...
+
+out/compress-memcopy.go: 		 $(wildcard in/**/*) $(GOPATH)/bin/go-bindata
+	$(GOPATH)/bin/go-bindata                        -o $@ in/...
+
+out/compress-nomemcopy.go: 	 $(wildcard in/**/*) $(GOPATH)/bin/go-bindata
+	$(GOPATH)/bin/go-bindata -nomemcopy             -o $@ in/...
+
+out/debug.go: 							 $(wildcard in/**/*) $(GOPATH)/bin/go-bindata
+	$(GOPATH)/bin/go-bindata -debug                 -o $@ in/...
+
+out/nocompress-memcopy.go:   $(wildcard in/**/*) $(GOPATH)/bin/go-bindata
+	$(GOPATH)/bin/go-bindata -nocompress            -o $@ in/...
+
+out/nocompress-nomemcopy.go: $(wildcard in/**/*) $(GOPATH)/bin/go-bindata
+	$(GOPATH)/bin/go-bindata -nocompress -nomemcopy -o $@ in/...
+
+errcheck:
+	go get github.com/kisielk/errcheck
+
+vet:
+	go get golang.org/x/tools/cmd/vet
+
+golint:
+	go get github.com/golang/lint/golint

testdata/bindata-toc.go

@@ -1,7 +0,0 @@
-package main
-
-// Global Table of Contents map. Generated by go-bindata.
-// After startup of the program, all generated data files will
-// put themselves in this map. The key is the full filename, as
-// supplied to go-bindata.
-var go_bindata = make(map[string]func() []byte)

testdata/dupname/foo/bar

@@ -0,0 +1 @@
+// sample file

testdata/dupname/foo_bar

@@ -0,0 +1 @@
+// sample file

testdata/in/a/test.asset

@@ -0,0 +1 @@
+// sample file

testdata/in/b/test.asset

@@ -0,0 +1 @@
+// sample file

testdata/in/c/test.asset

@@ -0,0 +1 @@
+// sample file

testdata/in/test.asset

@@ -0,0 +1 @@
+// sample file

testdata/out/compress-memcopy.go

@@ -0,0 +1,312 @@
+// Code generated by go-bindata.
+// sources:
+// in/a/test.asset
+// in/b/test.asset
+// in/c/test.asset
+// in/test.asset
+// DO NOT EDIT!
+
+package main
+
+import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+func bindataRead(data []byte, name string) ([]byte, error) {
+	gz, err := gzip.NewReader(bytes.NewBuffer(data))
+	if err != nil {
+		return nil, fmt.Errorf("Read %q: %v", name, err)
+	}
+
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, gz)
+	clErr := gz.Close()
+
+	if err != nil {
+		return nil, fmt.Errorf("Read %q: %v", name, err)
+	}
+	if clErr != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+type asset struct {
+	bytes []byte
+	info  os.FileInfo
+}
+
+type bindataFileInfo struct {
+	name    string
+	size    int64
+	mode    os.FileMode
+	modTime time.Time
+}
+
+func (fi bindataFileInfo) Name() string {
+	return fi.name
+}
+func (fi bindataFileInfo) Size() int64 {
+	return fi.size
+}
+func (fi bindataFileInfo) Mode() os.FileMode {
+	return fi.mode
+}
+func (fi bindataFileInfo) ModTime() time.Time {
+	return fi.modTime
+}
+func (fi bindataFileInfo) IsDir() bool {
+	return false
+}
+func (fi bindataFileInfo) Sys() interface{} {
+	return nil
+}
+
+var _inATestAsset = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xd2\xd7\x57\x28\x4e\xcc\x2d\xc8\x49\x55\x48\xcb\xcc\x49\xe5\x02\x04\x00\x00\xff\xff\x8a\x82\x8c\x85\x0f\x00\x00\x00")
+
+func inATestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inATestAsset,
+		"in/a/test.asset",
+	)
+}
+
+func inATestAsset() (*asset, error) {
+	bytes, err := inATestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/a/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inBTestAsset = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xd2\xd7\x57\x28\x4e\xcc\x2d\xc8\x49\x55\x48\xcb\xcc\x49\xe5\x02\x04\x00\x00\xff\xff\x8a\x82\x8c\x85\x0f\x00\x00\x00")
+
+func inBTestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inBTestAsset,
+		"in/b/test.asset",
+	)
+}
+
+func inBTestAsset() (*asset, error) {
+	bytes, err := inBTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/b/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inCTestAsset = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xd2\xd7\x57\x28\x4e\xcc\x2d\xc8\x49\x55\x48\xcb\xcc\x49\xe5\x02\x04\x00\x00\xff\xff\x8a\x82\x8c\x85\x0f\x00\x00\x00")
+
+func inCTestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inCTestAsset,
+		"in/c/test.asset",
+	)
+}
+
+func inCTestAsset() (*asset, error) {
+	bytes, err := inCTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/c/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inTestAsset = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xd2\xd7\x57\x28\x4e\xcc\x2d\xc8\x49\x55\x48\xcb\xcc\x49\xe5\x02\x04\x00\x00\xff\xff\x8a\x82\x8c\x85\x0f\x00\x00\x00")
+
+func inTestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inTestAsset,
+		"in/test.asset",
+	)
+}
+
+func inTestAsset() (*asset, error) {
+	bytes, err := inTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+// Asset loads and returns the asset for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func Asset(name string) ([]byte, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
+		}
+		return a.bytes, nil
+	}
+	return nil, fmt.Errorf("Asset %s not found", name)
+}
+
+// MustAsset is like Asset but panics when Asset would return an error.
+// It simplifies safe initialization of global variables.
+func MustAsset(name string) []byte {
+	a, err := Asset(name)
+	if err != nil {
+		panic("asset: Asset(" + name + "): " + err.Error())
+	}
+
+	return a
+}
+
+// AssetInfo loads and returns the asset info for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func AssetInfo(name string) (os.FileInfo, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
+		}
+		return a.info, nil
+	}
+	return nil, fmt.Errorf("AssetInfo %s not found", name)
+}
+
+// AssetNames returns the names of the assets.
+func AssetNames() []string {
+	names := make([]string, 0, len(_bindata))
+	for name := range _bindata {
+		names = append(names, name)
+	}
+	return names
+}
+
+// _bindata is a table, holding each asset generator, mapped to its name.
+var _bindata = map[string]func() (*asset, error){
+	"in/a/test.asset": inATestAsset,
+	"in/b/test.asset": inBTestAsset,
+	"in/c/test.asset": inCTestAsset,
+	"in/test.asset": inTestAsset,
+}
+
+// AssetDir returns the file names below a certain
+// directory embedded in the file by go-bindata.
+// For example if you run go-bindata on data/... and data contains the
+// following hierarchy:
+//     data/
+//       foo.txt
+//       img/
+//         a.png
+//         b.png
+// then AssetDir("data") would return []string{"foo.txt", "img"}
+// AssetDir("data/img") would return []string{"a.png", "b.png"}
+// AssetDir("foo.txt") and AssetDir("notexist") would return an error
+// AssetDir("") will return []string{"data"}.
+func AssetDir(name string) ([]string, error) {
+	node := _bintree
+	if len(name) != 0 {
+		cannonicalName := strings.Replace(name, "\\", "/", -1)
+		pathList := strings.Split(cannonicalName, "/")
+		for _, p := range pathList {
+			node = node.Children[p]
+			if node == nil {
+				return nil, fmt.Errorf("Asset %s not found", name)
+			}
+		}
+	}
+	if node.Func != nil {
+		return nil, fmt.Errorf("Asset %s not found", name)
+	}
+	rv := make([]string, 0, len(node.Children))
+	for childName := range node.Children {
+		rv = append(rv, childName)
+	}
+	return rv, nil
+}
+
+type bintree struct {
+	Func     func() (*asset, error)
+	Children map[string]*bintree
+}
+var _bintree = &bintree{nil, map[string]*bintree{
+	"in": &bintree{nil, map[string]*bintree{
+		"a": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inATestAsset, map[string]*bintree{}},
+		}},
+		"b": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inBTestAsset, map[string]*bintree{}},
+		}},
+		"c": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inCTestAsset, map[string]*bintree{}},
+		}},
+		"test.asset": &bintree{inTestAsset, map[string]*bintree{}},
+	}},
+}}
+
+// RestoreAsset restores an asset under the given directory
+func RestoreAsset(dir, name string) error {
+	data, err := Asset(name)
+	if err != nil {
+		return err
+	}
+	info, err := AssetInfo(name)
+	if err != nil {
+		return err
+	}
+	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
+	if err != nil {
+		return err
+	}
+	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// RestoreAssets restores an asset under the given directory recursively
+func RestoreAssets(dir, name string) error {
+	children, err := AssetDir(name)
+	// File
+	if err != nil {
+		return RestoreAsset(dir, name)
+	}
+	// Dir
+	for _, child := range children {
+		err = RestoreAssets(dir, filepath.Join(name, child))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func _filePath(dir, name string) string {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
+}
+

testdata/out/compress-nomemcopy.go

@@ -0,0 +1,312 @@
+// Code generated by go-bindata.
+// sources:
+// in/a/test.asset
+// in/b/test.asset
+// in/c/test.asset
+// in/test.asset
+// DO NOT EDIT!
+
+package main
+
+import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+func bindataRead(data, name string) ([]byte, error) {
+	gz, err := gzip.NewReader(strings.NewReader(data))
+	if err != nil {
+		return nil, fmt.Errorf("Read %q: %v", name, err)
+	}
+
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, gz)
+	clErr := gz.Close()
+
+	if err != nil {
+		return nil, fmt.Errorf("Read %q: %v", name, err)
+	}
+	if clErr != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+type asset struct {
+	bytes []byte
+	info  os.FileInfo
+}
+
+type bindataFileInfo struct {
+	name    string
+	size    int64
+	mode    os.FileMode
+	modTime time.Time
+}
+
+func (fi bindataFileInfo) Name() string {
+	return fi.name
+}
+func (fi bindataFileInfo) Size() int64 {
+	return fi.size
+}
+func (fi bindataFileInfo) Mode() os.FileMode {
+	return fi.mode
+}
+func (fi bindataFileInfo) ModTime() time.Time {
+	return fi.modTime
+}
+func (fi bindataFileInfo) IsDir() bool {
+	return false
+}
+func (fi bindataFileInfo) Sys() interface{} {
+	return nil
+}
+
+var _inATestAsset = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xd2\xd7\x57\x28\x4e\xcc\x2d\xc8\x49\x55\x48\xcb\xcc\x49\xe5\x02\x04\x00\x00\xff\xff\x8a\x82\x8c\x85\x0f\x00\x00\x00"
+
+func inATestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inATestAsset,
+		"in/a/test.asset",
+	)
+}
+
+func inATestAsset() (*asset, error) {
+	bytes, err := inATestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/a/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inBTestAsset = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xd2\xd7\x57\x28\x4e\xcc\x2d\xc8\x49\x55\x48\xcb\xcc\x49\xe5\x02\x04\x00\x00\xff\xff\x8a\x82\x8c\x85\x0f\x00\x00\x00"
+
+func inBTestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inBTestAsset,
+		"in/b/test.asset",
+	)
+}
+
+func inBTestAsset() (*asset, error) {
+	bytes, err := inBTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/b/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inCTestAsset = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xd2\xd7\x57\x28\x4e\xcc\x2d\xc8\x49\x55\x48\xcb\xcc\x49\xe5\x02\x04\x00\x00\xff\xff\x8a\x82\x8c\x85\x0f\x00\x00\x00"
+
+func inCTestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inCTestAsset,
+		"in/c/test.asset",
+	)
+}
+
+func inCTestAsset() (*asset, error) {
+	bytes, err := inCTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/c/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inTestAsset = "\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xd2\xd7\x57\x28\x4e\xcc\x2d\xc8\x49\x55\x48\xcb\xcc\x49\xe5\x02\x04\x00\x00\xff\xff\x8a\x82\x8c\x85\x0f\x00\x00\x00"
+
+func inTestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inTestAsset,
+		"in/test.asset",
+	)
+}
+
+func inTestAsset() (*asset, error) {
+	bytes, err := inTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+// Asset loads and returns the asset for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func Asset(name string) ([]byte, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
+		}
+		return a.bytes, nil
+	}
+	return nil, fmt.Errorf("Asset %s not found", name)
+}
+
+// MustAsset is like Asset but panics when Asset would return an error.
+// It simplifies safe initialization of global variables.
+func MustAsset(name string) []byte {
+	a, err := Asset(name)
+	if err != nil {
+		panic("asset: Asset(" + name + "): " + err.Error())
+	}
+
+	return a
+}
+
+// AssetInfo loads and returns the asset info for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func AssetInfo(name string) (os.FileInfo, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
+		}
+		return a.info, nil
+	}
+	return nil, fmt.Errorf("AssetInfo %s not found", name)
+}
+
+// AssetNames returns the names of the assets.
+func AssetNames() []string {
+	names := make([]string, 0, len(_bindata))
+	for name := range _bindata {
+		names = append(names, name)
+	}
+	return names
+}
+
+// _bindata is a table, holding each asset generator, mapped to its name.
+var _bindata = map[string]func() (*asset, error){
+	"in/a/test.asset": inATestAsset,
+	"in/b/test.asset": inBTestAsset,
+	"in/c/test.asset": inCTestAsset,
+	"in/test.asset": inTestAsset,
+}
+
+// AssetDir returns the file names below a certain
+// directory embedded in the file by go-bindata.
+// For example if you run go-bindata on data/... and data contains the
+// following hierarchy:
+//     data/
+//       foo.txt
+//       img/
+//         a.png
+//         b.png
+// then AssetDir("data") would return []string{"foo.txt", "img"}
+// AssetDir("data/img") would return []string{"a.png", "b.png"}
+// AssetDir("foo.txt") and AssetDir("notexist") would return an error
+// AssetDir("") will return []string{"data"}.
+func AssetDir(name string) ([]string, error) {
+	node := _bintree
+	if len(name) != 0 {
+		cannonicalName := strings.Replace(name, "\\", "/", -1)
+		pathList := strings.Split(cannonicalName, "/")
+		for _, p := range pathList {
+			node = node.Children[p]
+			if node == nil {
+				return nil, fmt.Errorf("Asset %s not found", name)
+			}
+		}
+	}
+	if node.Func != nil {
+		return nil, fmt.Errorf("Asset %s not found", name)
+	}
+	rv := make([]string, 0, len(node.Children))
+	for childName := range node.Children {
+		rv = append(rv, childName)
+	}
+	return rv, nil
+}
+
+type bintree struct {
+	Func     func() (*asset, error)
+	Children map[string]*bintree
+}
+var _bintree = &bintree{nil, map[string]*bintree{
+	"in": &bintree{nil, map[string]*bintree{
+		"a": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inATestAsset, map[string]*bintree{}},
+		}},
+		"b": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inBTestAsset, map[string]*bintree{}},
+		}},
+		"c": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inCTestAsset, map[string]*bintree{}},
+		}},
+		"test.asset": &bintree{inTestAsset, map[string]*bintree{}},
+	}},
+}}
+
+// RestoreAsset restores an asset under the given directory
+func RestoreAsset(dir, name string) error {
+	data, err := Asset(name)
+	if err != nil {
+		return err
+	}
+	info, err := AssetInfo(name)
+	if err != nil {
+		return err
+	}
+	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
+	if err != nil {
+		return err
+	}
+	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// RestoreAssets restores an asset under the given directory recursively
+func RestoreAssets(dir, name string) error {
+	children, err := AssetDir(name)
+	// File
+	if err != nil {
+		return RestoreAsset(dir, name)
+	}
+	// Dir
+	for _, child := range children {
+		err = RestoreAssets(dir, filepath.Join(name, child))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func _filePath(dir, name string) string {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
+}
+

testdata/out/debug.go

@@ -0,0 +1,263 @@
+// Code generated by go-bindata.
+// sources:
+// in/a/test.asset
+// in/b/test.asset
+// in/c/test.asset
+// in/test.asset
+// DO NOT EDIT!
+
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// bindataRead reads the given file from disk. It returns an error on failure.
+func bindataRead(path, name string) ([]byte, error) {
+	buf, err := ioutil.ReadFile(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset %s at %s: %v", name, path, err)
+	}
+	return buf, err
+}
+
+type asset struct {
+	bytes []byte
+	info  os.FileInfo
+}
+
+// inATestAsset reads file data from disk. It returns an error on failure.
+func inATestAsset() (*asset, error) {
+	path := "/home/ts/code/go/src/git.kirsle.net/go/bindata/testdata/in/a/test.asset"
+	name := "in/a/test.asset"
+	bytes, err := bindataRead(path, name)
+	if err != nil {
+		return nil, err
+	}
+
+	fi, err := os.Stat(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset info %s at %s: %v", name, path, err)
+	}
+
+	a := &asset{bytes: bytes, info: fi}
+	return a, err
+}
+
+// inBTestAsset reads file data from disk. It returns an error on failure.
+func inBTestAsset() (*asset, error) {
+	path := "/home/ts/code/go/src/git.kirsle.net/go/bindata/testdata/in/b/test.asset"
+	name := "in/b/test.asset"
+	bytes, err := bindataRead(path, name)
+	if err != nil {
+		return nil, err
+	}
+
+	fi, err := os.Stat(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset info %s at %s: %v", name, path, err)
+	}
+
+	a := &asset{bytes: bytes, info: fi}
+	return a, err
+}
+
+// inCTestAsset reads file data from disk. It returns an error on failure.
+func inCTestAsset() (*asset, error) {
+	path := "/home/ts/code/go/src/git.kirsle.net/go/bindata/testdata/in/c/test.asset"
+	name := "in/c/test.asset"
+	bytes, err := bindataRead(path, name)
+	if err != nil {
+		return nil, err
+	}
+
+	fi, err := os.Stat(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset info %s at %s: %v", name, path, err)
+	}
+
+	a := &asset{bytes: bytes, info: fi}
+	return a, err
+}
+
+// inTestAsset reads file data from disk. It returns an error on failure.
+func inTestAsset() (*asset, error) {
+	path := "/home/ts/code/go/src/git.kirsle.net/go/bindata/testdata/in/test.asset"
+	name := "in/test.asset"
+	bytes, err := bindataRead(path, name)
+	if err != nil {
+		return nil, err
+	}
+
+	fi, err := os.Stat(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset info %s at %s: %v", name, path, err)
+	}
+
+	a := &asset{bytes: bytes, info: fi}
+	return a, err
+}
+
+// Asset loads and returns the asset for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func Asset(name string) ([]byte, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
+		}
+		return a.bytes, nil
+	}
+	return nil, fmt.Errorf("Asset %s not found", name)
+}
+
+// MustAsset is like Asset but panics when Asset would return an error.
+// It simplifies safe initialization of global variables.
+func MustAsset(name string) []byte {
+	a, err := Asset(name)
+	if err != nil {
+		panic("asset: Asset(" + name + "): " + err.Error())
+	}
+
+	return a
+}
+
+// AssetInfo loads and returns the asset info for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func AssetInfo(name string) (os.FileInfo, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
+		}
+		return a.info, nil
+	}
+	return nil, fmt.Errorf("AssetInfo %s not found", name)
+}
+
+// AssetNames returns the names of the assets.
+func AssetNames() []string {
+	names := make([]string, 0, len(_bindata))
+	for name := range _bindata {
+		names = append(names, name)
+	}
+	return names
+}
+
+// _bindata is a table, holding each asset generator, mapped to its name.
+var _bindata = map[string]func() (*asset, error){
+	"in/a/test.asset": inATestAsset,
+	"in/b/test.asset": inBTestAsset,
+	"in/c/test.asset": inCTestAsset,
+	"in/test.asset": inTestAsset,
+}
+
+// AssetDir returns the file names below a certain
+// directory embedded in the file by go-bindata.
+// For example if you run go-bindata on data/... and data contains the
+// following hierarchy:
+//     data/
+//       foo.txt
+//       img/
+//         a.png
+//         b.png
+// then AssetDir("data") would return []string{"foo.txt", "img"}
+// AssetDir("data/img") would return []string{"a.png", "b.png"}
+// AssetDir("foo.txt") and AssetDir("notexist") would return an error
+// AssetDir("") will return []string{"data"}.
+func AssetDir(name string) ([]string, error) {
+	node := _bintree
+	if len(name) != 0 {
+		cannonicalName := strings.Replace(name, "\\", "/", -1)
+		pathList := strings.Split(cannonicalName, "/")
+		for _, p := range pathList {
+			node = node.Children[p]
+			if node == nil {
+				return nil, fmt.Errorf("Asset %s not found", name)
+			}
+		}
+	}
+	if node.Func != nil {
+		return nil, fmt.Errorf("Asset %s not found", name)
+	}
+	rv := make([]string, 0, len(node.Children))
+	for childName := range node.Children {
+		rv = append(rv, childName)
+	}
+	return rv, nil
+}
+
+type bintree struct {
+	Func     func() (*asset, error)
+	Children map[string]*bintree
+}
+var _bintree = &bintree{nil, map[string]*bintree{
+	"in": &bintree{nil, map[string]*bintree{
+		"a": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inATestAsset, map[string]*bintree{}},
+		}},
+		"b": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inBTestAsset, map[string]*bintree{}},
+		}},
+		"c": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inCTestAsset, map[string]*bintree{}},
+		}},
+		"test.asset": &bintree{inTestAsset, map[string]*bintree{}},
+	}},
+}}
+
+// RestoreAsset restores an asset under the given directory
+func RestoreAsset(dir, name string) error {
+	data, err := Asset(name)
+	if err != nil {
+		return err
+	}
+	info, err := AssetInfo(name)
+	if err != nil {
+		return err
+	}
+	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
+	if err != nil {
+		return err
+	}
+	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// RestoreAssets restores an asset under the given directory recursively
+func RestoreAssets(dir, name string) error {
+	children, err := AssetDir(name)
+	// File
+	if err != nil {
+		return RestoreAsset(dir, name)
+	}
+	// Dir
+	for _, child := range children {
+		err = RestoreAssets(dir, filepath.Join(name, child))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func _filePath(dir, name string) string {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
+}
+

testdata/out/debug.go-bindata

@@ -0,0 +1,259 @@
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"strings"
+	"os"
+	"path"
+	"path/filepath"
+)
+
+// bindata_read reads the given file from disk. It returns an error on failure.
+func bindata_read(path, name string) ([]byte, error) {
+	buf, err := ioutil.ReadFile(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset %s at %s: %v", name, path, err)
+	}
+	return buf, err
+}
+
+type asset struct {
+	bytes []byte
+	info  os.FileInfo
+}
+
+// in_a_test_asset reads file data from disk. It returns an error on failure.
+func in_a_test_asset() (*asset, error) {
+	path := "/Users/tamird/src/go/src/git.kirsle.net/go/bindata/testdata/in/a/test.asset"
+	name := "in/a/test.asset"
+	bytes, err := bindata_read(path, name)
+	if err != nil {
+		return nil, err
+	}
+
+	fi, err := os.Stat(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset info %s at %s: %v", name, path, err)
+	}
+
+	a := &asset{bytes: bytes, info: fi}
+	return a, err
+}
+
+// in_b_test_asset reads file data from disk. It returns an error on failure.
+func in_b_test_asset() (*asset, error) {
+	path := "/Users/tamird/src/go/src/git.kirsle.net/go/bindata/testdata/in/b/test.asset"
+	name := "in/b/test.asset"
+	bytes, err := bindata_read(path, name)
+	if err != nil {
+		return nil, err
+	}
+
+	fi, err := os.Stat(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset info %s at %s: %v", name, path, err)
+	}
+
+	a := &asset{bytes: bytes, info: fi}
+	return a, err
+}
+
+// in_c_test_asset reads file data from disk. It returns an error on failure.
+func in_c_test_asset() (*asset, error) {
+	path := "/Users/tamird/src/go/src/git.kirsle.net/go/bindata/testdata/in/c/test.asset"
+	name := "in/c/test.asset"
+	bytes, err := bindata_read(path, name)
+	if err != nil {
+		return nil, err
+	}
+
+	fi, err := os.Stat(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset info %s at %s: %v", name, path, err)
+	}
+
+	a := &asset{bytes: bytes, info: fi}
+	return a, err
+}
+
+// in_test_asset reads file data from disk. It returns an error on failure.
+func in_test_asset() (*asset, error) {
+	path := "/Users/tamird/src/go/src/git.kirsle.net/go/bindata/testdata/in/test.asset"
+	name := "in/test.asset"
+	bytes, err := bindata_read(path, name)
+	if err != nil {
+		return nil, err
+	}
+
+	fi, err := os.Stat(path)
+	if err != nil {
+		err = fmt.Errorf("Error reading asset info %s at %s: %v", name, path, err)
+	}
+
+	a := &asset{bytes: bytes, info: fi}
+	return a, err
+}
+
+// Asset loads and returns the asset for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func Asset(name string) ([]byte, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
+		}
+		return a.bytes, nil
+	}
+	return nil, fmt.Errorf("Asset %s not found", name)
+}
+
+// MustAsset is like Asset but panics when Asset would return an error.
+// It simplifies safe initialization of global variables.
+func MustAsset(name string) []byte {
+	a, err := Asset(name)
+	if (err != nil) {
+		panic("asset: Asset(" + name + "): " + err.Error())
+	}
+
+	return a
+}
+
+// AssetInfo loads and returns the asset info for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func AssetInfo(name string) (os.FileInfo, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
+		}
+		return a.info, nil
+	}
+	return nil, fmt.Errorf("AssetInfo %s not found", name)
+}
+
+// AssetNames returns the names of the assets.
+func AssetNames() []string {
+	names := make([]string, 0, len(_bindata))
+	for name := range _bindata {
+		names = append(names, name)
+	}
+	return names
+}
+
+// _bindata is a table, holding each asset generator, mapped to its name.
+var _bindata = map[string]func() (*asset, error){
+	"in/a/test.asset": in_a_test_asset,
+	"in/b/test.asset": in_b_test_asset,
+	"in/c/test.asset": in_c_test_asset,
+	"in/test.asset": in_test_asset,
+}
+
+// AssetDir returns the file names below a certain
+// directory embedded in the file by go-bindata.
+// For example if you run go-bindata on data/... and data contains the
+// following hierarchy:
+//     data/
+//       foo.txt
+//       img/
+//         a.png
+//         b.png
+// then AssetDir("data") would return []string{"foo.txt", "img"}
+// AssetDir("data/img") would return []string{"a.png", "b.png"}
+// AssetDir("foo.txt") and AssetDir("notexist") would return an error
+// AssetDir("") will return []string{"data"}.
+func AssetDir(name string) ([]string, error) {
+	node := _bintree
+	if len(name) != 0 {
+		cannonicalName := strings.Replace(name, "\\", "/", -1)
+		pathList := strings.Split(cannonicalName, "/")
+		for _, p := range pathList {
+			node = node.Children[p]
+			if node == nil {
+				return nil, fmt.Errorf("Asset %s not found", name)
+			}
+		}
+	}
+	if node.Func != nil {
+		return nil, fmt.Errorf("Asset %s not found", name)
+	}
+	rv := make([]string, 0, len(node.Children))
+	for name := range node.Children {
+		rv = append(rv, name)
+	}
+	return rv, nil
+}
+
+type _bintree_t struct {
+	Func func() (*asset, error)
+	Children map[string]*_bintree_t
+}
+var _bintree = &_bintree_t{nil, map[string]*_bintree_t{
+	"in": &_bintree_t{nil, map[string]*_bintree_t{
+		"a": &_bintree_t{nil, map[string]*_bintree_t{
+			"test.asset": &_bintree_t{in_a_test_asset, map[string]*_bintree_t{
+			}},
+		}},
+		"b": &_bintree_t{nil, map[string]*_bintree_t{
+			"test.asset": &_bintree_t{in_b_test_asset, map[string]*_bintree_t{
+			}},
+		}},
+		"c": &_bintree_t{nil, map[string]*_bintree_t{
+			"test.asset": &_bintree_t{in_c_test_asset, map[string]*_bintree_t{
+			}},
+		}},
+		"test.asset": &_bintree_t{in_test_asset, map[string]*_bintree_t{
+		}},
+	}},
+}}
+
+// Restore an asset under the given directory
+func RestoreAsset(dir, name string) error {
+        data, err := Asset(name)
+        if err != nil {
+                return err
+        }
+        info, err := AssetInfo(name)
+        if err != nil {
+                return err
+        }
+        err = os.MkdirAll(_filePath(dir, path.Dir(name)), os.FileMode(0755))
+        if err != nil {
+                return err
+        }
+        err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
+        if err != nil {
+                return err
+        }
+        err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+        if err != nil {
+                return err
+        }
+        return nil
+}
+
+// Restore assets under the given directory recursively
+func RestoreAssets(dir, name string) error {
+        children, err := AssetDir(name)
+        if err != nil { // File
+                return RestoreAsset(dir, name)
+        } else { // Dir
+                for _, child := range children {
+                        err = RestoreAssets(dir, path.Join(name, child))
+                        if err != nil {
+                                return err
+                        }
+                }
+        }
+        return nil
+}
+
+func _filePath(dir, name string) string {
+        cannonicalName := strings.Replace(name, "\\", "/", -1)
+        return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
+}
+

testdata/out/nocompress-memcopy.go

@@ -0,0 +1,280 @@
+// Code generated by go-bindata.
+// sources:
+// in/a/test.asset
+// in/b/test.asset
+// in/c/test.asset
+// in/test.asset
+// DO NOT EDIT!
+
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+type asset struct {
+	bytes []byte
+	info  os.FileInfo
+}
+
+type bindataFileInfo struct {
+	name    string
+	size    int64
+	mode    os.FileMode
+	modTime time.Time
+}
+
+func (fi bindataFileInfo) Name() string {
+	return fi.name
+}
+func (fi bindataFileInfo) Size() int64 {
+	return fi.size
+}
+func (fi bindataFileInfo) Mode() os.FileMode {
+	return fi.mode
+}
+func (fi bindataFileInfo) ModTime() time.Time {
+	return fi.modTime
+}
+func (fi bindataFileInfo) IsDir() bool {
+	return false
+}
+func (fi bindataFileInfo) Sys() interface{} {
+	return nil
+}
+
+var _inATestAsset = []byte(`// sample file
+`)
+
+func inATestAssetBytes() ([]byte, error) {
+	return _inATestAsset, nil
+}
+
+func inATestAsset() (*asset, error) {
+	bytes, err := inATestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/a/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inBTestAsset = []byte(`// sample file
+`)
+
+func inBTestAssetBytes() ([]byte, error) {
+	return _inBTestAsset, nil
+}
+
+func inBTestAsset() (*asset, error) {
+	bytes, err := inBTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/b/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inCTestAsset = []byte(`// sample file
+`)
+
+func inCTestAssetBytes() ([]byte, error) {
+	return _inCTestAsset, nil
+}
+
+func inCTestAsset() (*asset, error) {
+	bytes, err := inCTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/c/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inTestAsset = []byte(`// sample file
+`)
+
+func inTestAssetBytes() ([]byte, error) {
+	return _inTestAsset, nil
+}
+
+func inTestAsset() (*asset, error) {
+	bytes, err := inTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+// Asset loads and returns the asset for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func Asset(name string) ([]byte, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
+		}
+		return a.bytes, nil
+	}
+	return nil, fmt.Errorf("Asset %s not found", name)
+}
+
+// MustAsset is like Asset but panics when Asset would return an error.
+// It simplifies safe initialization of global variables.
+func MustAsset(name string) []byte {
+	a, err := Asset(name)
+	if err != nil {
+		panic("asset: Asset(" + name + "): " + err.Error())
+	}
+
+	return a
+}
+
+// AssetInfo loads and returns the asset info for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func AssetInfo(name string) (os.FileInfo, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
+		}
+		return a.info, nil
+	}
+	return nil, fmt.Errorf("AssetInfo %s not found", name)
+}
+
+// AssetNames returns the names of the assets.
+func AssetNames() []string {
+	names := make([]string, 0, len(_bindata))
+	for name := range _bindata {
+		names = append(names, name)
+	}
+	return names
+}
+
+// _bindata is a table, holding each asset generator, mapped to its name.
+var _bindata = map[string]func() (*asset, error){
+	"in/a/test.asset": inATestAsset,
+	"in/b/test.asset": inBTestAsset,
+	"in/c/test.asset": inCTestAsset,
+	"in/test.asset": inTestAsset,
+}
+
+// AssetDir returns the file names below a certain
+// directory embedded in the file by go-bindata.
+// For example if you run go-bindata on data/... and data contains the
+// following hierarchy:
+//     data/
+//       foo.txt
+//       img/
+//         a.png
+//         b.png
+// then AssetDir("data") would return []string{"foo.txt", "img"}
+// AssetDir("data/img") would return []string{"a.png", "b.png"}
+// AssetDir("foo.txt") and AssetDir("notexist") would return an error
+// AssetDir("") will return []string{"data"}.
+func AssetDir(name string) ([]string, error) {
+	node := _bintree
+	if len(name) != 0 {
+		cannonicalName := strings.Replace(name, "\\", "/", -1)
+		pathList := strings.Split(cannonicalName, "/")
+		for _, p := range pathList {
+			node = node.Children[p]
+			if node == nil {
+				return nil, fmt.Errorf("Asset %s not found", name)
+			}
+		}
+	}
+	if node.Func != nil {
+		return nil, fmt.Errorf("Asset %s not found", name)
+	}
+	rv := make([]string, 0, len(node.Children))
+	for childName := range node.Children {
+		rv = append(rv, childName)
+	}
+	return rv, nil
+}
+
+type bintree struct {
+	Func     func() (*asset, error)
+	Children map[string]*bintree
+}
+var _bintree = &bintree{nil, map[string]*bintree{
+	"in": &bintree{nil, map[string]*bintree{
+		"a": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inATestAsset, map[string]*bintree{}},
+		}},
+		"b": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inBTestAsset, map[string]*bintree{}},
+		}},
+		"c": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inCTestAsset, map[string]*bintree{}},
+		}},
+		"test.asset": &bintree{inTestAsset, map[string]*bintree{}},
+	}},
+}}
+
+// RestoreAsset restores an asset under the given directory
+func RestoreAsset(dir, name string) error {
+	data, err := Asset(name)
+	if err != nil {
+		return err
+	}
+	info, err := AssetInfo(name)
+	if err != nil {
+		return err
+	}
+	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
+	if err != nil {
+		return err
+	}
+	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// RestoreAssets restores an asset under the given directory recursively
+func RestoreAssets(dir, name string) error {
+	children, err := AssetDir(name)
+	// File
+	if err != nil {
+		return RestoreAsset(dir, name)
+	}
+	// Dir
+	for _, child := range children {
+		err = RestoreAssets(dir, filepath.Join(name, child))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func _filePath(dir, name string) string {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
+}
+

testdata/out/nocompress-nomemcopy.go

@@ -0,0 +1,302 @@
+// Code generated by go-bindata.
+// sources:
+// in/a/test.asset
+// in/b/test.asset
+// in/c/test.asset
+// in/test.asset
+// DO NOT EDIT!
+
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"time"
+	"unsafe"
+)
+
+func bindataRead(data, name string) ([]byte, error) {
+	var empty [0]byte
+	sx := (*reflect.StringHeader)(unsafe.Pointer(&data))
+	b := empty[:]
+	bx := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	bx.Data = sx.Data
+	bx.Len = len(data)
+	bx.Cap = bx.Len
+	return b, nil
+}
+
+type asset struct {
+	bytes []byte
+	info  os.FileInfo
+}
+
+type bindataFileInfo struct {
+	name    string
+	size    int64
+	mode    os.FileMode
+	modTime time.Time
+}
+
+func (fi bindataFileInfo) Name() string {
+	return fi.name
+}
+func (fi bindataFileInfo) Size() int64 {
+	return fi.size
+}
+func (fi bindataFileInfo) Mode() os.FileMode {
+	return fi.mode
+}
+func (fi bindataFileInfo) ModTime() time.Time {
+	return fi.modTime
+}
+func (fi bindataFileInfo) IsDir() bool {
+	return false
+}
+func (fi bindataFileInfo) Sys() interface{} {
+	return nil
+}
+
+var _inATestAsset = "\x2f\x2f\x20\x73\x61\x6d\x70\x6c\x65\x20\x66\x69\x6c\x65\x0a"
+
+func inATestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inATestAsset,
+		"in/a/test.asset",
+	)
+}
+
+func inATestAsset() (*asset, error) {
+	bytes, err := inATestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/a/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inBTestAsset = "\x2f\x2f\x20\x73\x61\x6d\x70\x6c\x65\x20\x66\x69\x6c\x65\x0a"
+
+func inBTestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inBTestAsset,
+		"in/b/test.asset",
+	)
+}
+
+func inBTestAsset() (*asset, error) {
+	bytes, err := inBTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/b/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inCTestAsset = "\x2f\x2f\x20\x73\x61\x6d\x70\x6c\x65\x20\x66\x69\x6c\x65\x0a"
+
+func inCTestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inCTestAsset,
+		"in/c/test.asset",
+	)
+}
+
+func inCTestAsset() (*asset, error) {
+	bytes, err := inCTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/c/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+var _inTestAsset = "\x2f\x2f\x20\x73\x61\x6d\x70\x6c\x65\x20\x66\x69\x6c\x65\x0a"
+
+func inTestAssetBytes() ([]byte, error) {
+	return bindataRead(
+		_inTestAsset,
+		"in/test.asset",
+	)
+}
+
+func inTestAsset() (*asset, error) {
+	bytes, err := inTestAssetBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	info := bindataFileInfo{name: "in/test.asset", size: 15, mode: os.FileMode(436), modTime: time.Unix(1445582844, 0)}
+	a := &asset{bytes: bytes, info: info}
+	return a, nil
+}
+
+// Asset loads and returns the asset for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func Asset(name string) ([]byte, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
+		}
+		return a.bytes, nil
+	}
+	return nil, fmt.Errorf("Asset %s not found", name)
+}
+
+// MustAsset is like Asset but panics when Asset would return an error.
+// It simplifies safe initialization of global variables.
+func MustAsset(name string) []byte {
+	a, err := Asset(name)
+	if err != nil {
+		panic("asset: Asset(" + name + "): " + err.Error())
+	}
+
+	return a
+}
+
+// AssetInfo loads and returns the asset info for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func AssetInfo(name string) (os.FileInfo, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
+		}
+		return a.info, nil
+	}
+	return nil, fmt.Errorf("AssetInfo %s not found", name)
+}
+
+// AssetNames returns the names of the assets.
+func AssetNames() []string {
+	names := make([]string, 0, len(_bindata))
+	for name := range _bindata {
+		names = append(names, name)
+	}
+	return names
+}
+
+// _bindata is a table, holding each asset generator, mapped to its name.
+var _bindata = map[string]func() (*asset, error){
+	"in/a/test.asset": inATestAsset,
+	"in/b/test.asset": inBTestAsset,
+	"in/c/test.asset": inCTestAsset,
+	"in/test.asset": inTestAsset,
+}
+
+// AssetDir returns the file names below a certain
+// directory embedded in the file by go-bindata.
+// For example if you run go-bindata on data/... and data contains the
+// following hierarchy:
+//     data/
+//       foo.txt
+//       img/
+//         a.png
+//         b.png
+// then AssetDir("data") would return []string{"foo.txt", "img"}
+// AssetDir("data/img") would return []string{"a.png", "b.png"}
+// AssetDir("foo.txt") and AssetDir("notexist") would return an error
+// AssetDir("") will return []string{"data"}.
+func AssetDir(name string) ([]string, error) {
+	node := _bintree
+	if len(name) != 0 {
+		cannonicalName := strings.Replace(name, "\\", "/", -1)
+		pathList := strings.Split(cannonicalName, "/")
+		for _, p := range pathList {
+			node = node.Children[p]
+			if node == nil {
+				return nil, fmt.Errorf("Asset %s not found", name)
+			}
+		}
+	}
+	if node.Func != nil {
+		return nil, fmt.Errorf("Asset %s not found", name)
+	}
+	rv := make([]string, 0, len(node.Children))
+	for childName := range node.Children {
+		rv = append(rv, childName)
+	}
+	return rv, nil
+}
+
+type bintree struct {
+	Func     func() (*asset, error)
+	Children map[string]*bintree
+}
+var _bintree = &bintree{nil, map[string]*bintree{
+	"in": &bintree{nil, map[string]*bintree{
+		"a": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inATestAsset, map[string]*bintree{}},
+		}},
+		"b": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inBTestAsset, map[string]*bintree{}},
+		}},
+		"c": &bintree{nil, map[string]*bintree{
+			"test.asset": &bintree{inCTestAsset, map[string]*bintree{}},
+		}},
+		"test.asset": &bintree{inTestAsset, map[string]*bintree{}},
+	}},
+}}
+
+// RestoreAsset restores an asset under the given directory
+func RestoreAsset(dir, name string) error {
+	data, err := Asset(name)
+	if err != nil {
+		return err
+	}
+	info, err := AssetInfo(name)
+	if err != nil {
+		return err
+	}
+	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
+	if err != nil {
+		return err
+	}
+	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
+	if err != nil {
+		return err
+	}
+	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// RestoreAssets restores an asset under the given directory recursively
+func RestoreAssets(dir, name string) error {
+	children, err := AssetDir(name)
+	// File
+	if err != nil {
+		return RestoreAsset(dir, name)
+	}
+	// Dir
+	for _, child := range children {
+		err = RestoreAssets(dir, filepath.Join(name, child))
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func _filePath(dir, name string) string {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
+}
+

testdata/symlinkFile/file1

@@ -0,0 +1 @@
+../symlinkSrc/file1

testdata/symlinkParent/symlinkTarget

@@ -0,0 +1 @@
+../symlinkSrc/

testdata/symlinkRecursiveParent/file1

@@ -0,0 +1 @@
+// test file 1

testdata/symlinkRecursiveParent/symlinkTarget

@@ -0,0 +1 @@
+../symlinkRecursiveParent/

testdata/symlinkSrc/file1

@@ -0,0 +1 @@
+// symlink file 1

testdata/symlinkSrc/file2

@@ -0,0 +1 @@
+// symlink file 2

testdata/symlinkSrc/file3

@@ -0,0 +1 @@
+// symlink file 3

testdata/symlinkSrc/file4

@@ -0,0 +1 @@
+// symlink file 4

toc.go

@@ -0,0 +1,230 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+import (
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+)
+
+type assetTree struct {
+	Asset    Asset
+	Children map[string]*assetTree
+}
+
+func newAssetTree() *assetTree {
+	tree := &assetTree{}
+	tree.Children = make(map[string]*assetTree)
+	return tree
+}
+
+func (node *assetTree) child(name string) *assetTree {
+	rv, ok := node.Children[name]
+	if !ok {
+		rv = newAssetTree()
+		node.Children[name] = rv
+	}
+	return rv
+}
+
+func (root *assetTree) Add(route []string, asset Asset) {
+	for _, name := range route {
+		root = root.child(name)
+	}
+	root.Asset = asset
+}
+
+func ident(w io.Writer, n int) {
+	for i := 0; i < n; i++ {
+		w.Write([]byte{'\t'})
+	}
+}
+
+func (root *assetTree) funcOrNil() string {
+	if root.Asset.Func == "" {
+		return "nil"
+	} else {
+		return root.Asset.Func
+	}
+}
+
+func (root *assetTree) writeGoMap(w io.Writer, nident int) {
+	fmt.Fprintf(w, "&bintree{%s, map[string]*bintree{", root.funcOrNil())
+
+	if len(root.Children) > 0 {
+		io.WriteString(w, "\n")
+
+		// Sort to make output stable between invocations
+		filenames := make([]string, len(root.Children))
+		i := 0
+		for filename, _ := range root.Children {
+			filenames[i] = filename
+			i++
+		}
+		sort.Strings(filenames)
+
+		for _, p := range filenames {
+			ident(w, nident+1)
+			fmt.Fprintf(w, `"%s": `, p)
+			root.Children[p].writeGoMap(w, nident+1)
+		}
+		ident(w, nident)
+	}
+
+	io.WriteString(w, "}}")
+	if nident > 0 {
+		io.WriteString(w, ",")
+	}
+	io.WriteString(w, "\n")
+}
+
+func (root *assetTree) WriteAsGoMap(w io.Writer) error {
+	_, err := fmt.Fprint(w, `type bintree struct {
+	Func     func() (*asset, error)
+	Children map[string]*bintree
+}
+var _bintree = `)
+	root.writeGoMap(w, 0)
+	return err
+}
+
+func writeTOCTree(w io.Writer, toc []Asset) error {
+	_, err := fmt.Fprintf(w, `// AssetDir returns the file names below a certain
+// directory embedded in the file by go-bindata.
+// For example if you run go-bindata on data/... and data contains the
+// following hierarchy:
+//     data/
+//       foo.txt
+//       img/
+//         a.png
+//         b.png
+// then AssetDir("data") would return []string{"foo.txt", "img"}
+// AssetDir("data/img") would return []string{"a.png", "b.png"}
+// AssetDir("foo.txt") and AssetDir("notexist") would return an error
+// AssetDir("") will return []string{"data"}.
+func AssetDir(name string) ([]string, error) {
+	node := _bintree
+	if len(name) != 0 {
+		cannonicalName := strings.Replace(name, "\\", "/", -1)
+		pathList := strings.Split(cannonicalName, "/")
+		for _, p := range pathList {
+			node = node.Children[p]
+			if node == nil {
+				return nil, fmt.Errorf("Asset %%s not found", name)
+			}
+		}
+	}
+	if node.Func != nil {
+		return nil, fmt.Errorf("Asset %%s not found", name)
+	}
+	rv := make([]string, 0, len(node.Children))
+	for childName := range node.Children {
+		rv = append(rv, childName)
+	}
+	return rv, nil
+}
+
+`)
+	if err != nil {
+		return err
+	}
+	tree := newAssetTree()
+	for i := range toc {
+		pathList := strings.Split(toc[i].Name, "/")
+		tree.Add(pathList, toc[i])
+	}
+	return tree.WriteAsGoMap(w)
+}
+
+// writeTOC writes the table of contents file.
+func writeTOC(w io.Writer, toc []Asset) error {
+	err := writeTOCHeader(w)
+	if err != nil {
+		return err
+	}
+
+	for i := range toc {
+		err = writeTOCAsset(w, &toc[i])
+		if err != nil {
+			return err
+		}
+	}
+
+	return writeTOCFooter(w)
+}
+
+// writeTOCHeader writes the table of contents file header.
+func writeTOCHeader(w io.Writer) error {
+	_, err := fmt.Fprintf(w, `// Asset loads and returns the asset for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func Asset(name string) ([]byte, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("Asset %%s can't read by error: %%v", name, err)
+		}
+		return a.bytes, nil
+	}
+	return nil, fmt.Errorf("Asset %%s not found", name)
+}
+
+// MustAsset is like Asset but panics when Asset would return an error.
+// It simplifies safe initialization of global variables.
+func MustAsset(name string) []byte {
+	a, err := Asset(name)
+	if err != nil {
+		panic("asset: Asset(" + name + "): " + err.Error())
+	}
+
+	return a
+}
+
+// AssetInfo loads and returns the asset info for the given name.
+// It returns an error if the asset could not be found or
+// could not be loaded.
+func AssetInfo(name string) (os.FileInfo, error) {
+	cannonicalName := strings.Replace(name, "\\", "/", -1)
+	if f, ok := _bindata[cannonicalName]; ok {
+		a, err := f()
+		if err != nil {
+			return nil, fmt.Errorf("AssetInfo %%s can't read by error: %%v", name, err)
+		}
+		return a.info, nil
+	}
+	return nil, fmt.Errorf("AssetInfo %%s not found", name)
+}
+
+// AssetNames returns the names of the assets.
+func AssetNames() []string {
+	names := make([]string, 0, len(_bindata))
+	for name := range _bindata {
+		names = append(names, name)
+	}
+	return names
+}
+
+// _bindata is a table, holding each asset generator, mapped to its name.
+var _bindata = map[string]func() (*asset, error){
+`)
+	return err
+}
+
+// writeTOCAsset write a TOC entry for the given asset.
+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) error {
+	_, err := fmt.Fprintf(w, `}
+
+`)
+	return err
+}