diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index ce29d4f2a06..b1ad77b1c1d 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -5,6 +5,7 @@ "Packages": [ "github.com/ugorji/go/codec/codecgen", "github.com/onsi/ginkgo/ginkgo", + "github.com/jteeuwen/go-bindata/go-bindata", "./..." ], "Deps": [ @@ -1468,6 +1469,16 @@ "ImportPath": "github.com/jonboulle/clockwork", "Rev": "72f9bd7c4e0c2a40055ab3d0f09654f730cce982" }, + { + "ImportPath": "github.com/jteeuwen/go-bindata", + "Comment": "v3.0.7-72-ga0ff256", + "Rev": "a0ff2567cfb70903282db057e799fd826784d41d" + }, + { + "ImportPath": "github.com/jteeuwen/go-bindata/go-bindata", + "Comment": "v3.0.7-72-ga0ff256", + "Rev": "a0ff2567cfb70903282db057e799fd826784d41d" + }, { "ImportPath": "github.com/juju/ratelimit", "Rev": "77ed1c8a01217656d2080ad51981f6e99adaa177" diff --git a/Godeps/LICENSES b/Godeps/LICENSES index 84666d177ee..f7ce15e7a1e 100644 --- a/Godeps/LICENSES +++ b/Godeps/LICENSES @@ -50622,6 +50622,28 @@ Apache License ================================================================================ +================================================================================ += vendor/github.com/jteeuwen/go-bindata licensed under: = + +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 + += vendor/github.com/jteeuwen/go-bindata/LICENSE 8dcedca69f7a474372829521f37954b1 - +================================================================================ + + +================================================================================ += vendor/github.com/jteeuwen/go-bindata/go-bindata licensed under: = + +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 + += vendor/github.com/jteeuwen/go-bindata/LICENSE 8dcedca69f7a474372829521f37954b1 - +================================================================================ + + ================================================================================ = vendor/github.com/juju/ratelimit licensed under: = diff --git a/hack/godep-save.sh b/hack/godep-save.sh index 68f0f9c43e0..4663dd022d3 100755 --- a/hack/godep-save.sh +++ b/hack/godep-save.sh @@ -29,6 +29,7 @@ GODEP="${GODEP:-godep}" REQUIRED_BINS=( "github.com/ugorji/go/codec/codecgen" "github.com/onsi/ginkgo/ginkgo" + "github.com/jteeuwen/go-bindata/go-bindata" "./..." ) diff --git a/vendor/BUILD b/vendor/BUILD index b643fe0f272..92d33ec078a 100644 --- a/vendor/BUILD +++ b/vendor/BUILD @@ -2558,6 +2558,16 @@ go_library( tags = ["automanaged"], ) +go_library( + name = "github.com/exponent-io/jsonpath", + srcs = [ + "github.com/exponent-io/jsonpath/decoder.go", + "github.com/exponent-io/jsonpath/path.go", + "github.com/exponent-io/jsonpath/pathaction.go", + ], + tags = ["automanaged"], +) + go_library( name = "github.com/fsnotify/fsnotify", srcs = [ @@ -4177,6 +4187,34 @@ go_library( tags = ["automanaged"], ) +go_library( + name = "github.com/jteeuwen/go-bindata", + srcs = [ + "github.com/jteeuwen/go-bindata/asset.go", + "github.com/jteeuwen/go-bindata/bytewriter.go", + "github.com/jteeuwen/go-bindata/config.go", + "github.com/jteeuwen/go-bindata/convert.go", + "github.com/jteeuwen/go-bindata/debug.go", + "github.com/jteeuwen/go-bindata/doc.go", + "github.com/jteeuwen/go-bindata/release.go", + "github.com/jteeuwen/go-bindata/restore.go", + "github.com/jteeuwen/go-bindata/stringwriter.go", + "github.com/jteeuwen/go-bindata/toc.go", + ], + tags = ["automanaged"], +) + +go_binary( + name = "github.com/jteeuwen/go-bindata/go-bindata", + srcs = [ + "github.com/jteeuwen/go-bindata/go-bindata/AppendSliceValue.go", + "github.com/jteeuwen/go-bindata/go-bindata/main.go", + "github.com/jteeuwen/go-bindata/go-bindata/version.go", + ], + tags = ["automanaged"], + deps = ["//vendor:github.com/jteeuwen/go-bindata"], +) + go_library( name = "github.com/juju/ratelimit", srcs = [ @@ -7537,176 +7575,6 @@ go_library( tags = ["automanaged"], ) -go_library( - name = "k8s.io/gengo/args", - srcs = ["k8s.io/gengo/args/args.go"], - tags = ["automanaged"], - deps = [ - "//vendor:github.com/spf13/pflag", - "//vendor:k8s.io/gengo/generator", - "//vendor:k8s.io/gengo/namer", - "//vendor:k8s.io/gengo/parser", - "//vendor:k8s.io/gengo/types", - ], -) - -go_library( - name = "k8s.io/gengo/examples/deepcopy-gen/generators", - srcs = ["k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go"], - tags = ["automanaged"], - deps = [ - "//vendor:github.com/golang/glog", - "//vendor:k8s.io/gengo/args", - "//vendor:k8s.io/gengo/examples/set-gen/sets", - "//vendor:k8s.io/gengo/generator", - "//vendor:k8s.io/gengo/namer", - "//vendor:k8s.io/gengo/types", - ], -) - -go_library( - name = "k8s.io/gengo/examples/defaulter-gen/generators", - srcs = ["k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go"], - tags = ["automanaged"], - deps = [ - "//vendor:github.com/golang/glog", - "//vendor:k8s.io/gengo/args", - "//vendor:k8s.io/gengo/generator", - "//vendor:k8s.io/gengo/namer", - "//vendor:k8s.io/gengo/types", - ], -) - -go_library( - name = "k8s.io/gengo/examples/import-boss/generators", - srcs = ["k8s.io/gengo/examples/import-boss/generators/import_restrict.go"], - tags = ["automanaged"], - deps = [ - "//vendor:github.com/golang/glog", - "//vendor:k8s.io/gengo/args", - "//vendor:k8s.io/gengo/generator", - "//vendor:k8s.io/gengo/namer", - "//vendor:k8s.io/gengo/types", - ], -) - -go_library( - name = "k8s.io/gengo/examples/set-gen/generators", - srcs = [ - "k8s.io/gengo/examples/set-gen/generators/sets.go", - "k8s.io/gengo/examples/set-gen/generators/tags.go", - ], - tags = ["automanaged"], - deps = [ - "//vendor:github.com/golang/glog", - "//vendor:k8s.io/gengo/args", - "//vendor:k8s.io/gengo/generator", - "//vendor:k8s.io/gengo/namer", - "//vendor:k8s.io/gengo/types", - ], -) - -go_library( - name = "k8s.io/gengo/examples/set-gen/sets", - srcs = [ - "k8s.io/gengo/examples/set-gen/sets/byte.go", - "k8s.io/gengo/examples/set-gen/sets/doc.go", - "k8s.io/gengo/examples/set-gen/sets/empty.go", - "k8s.io/gengo/examples/set-gen/sets/int.go", - "k8s.io/gengo/examples/set-gen/sets/int64.go", - "k8s.io/gengo/examples/set-gen/sets/string.go", - ], - tags = ["automanaged"], -) - -go_library( - name = "k8s.io/gengo/generator", - srcs = [ - "k8s.io/gengo/generator/default_generator.go", - "k8s.io/gengo/generator/default_package.go", - "k8s.io/gengo/generator/doc.go", - "k8s.io/gengo/generator/error_tracker.go", - "k8s.io/gengo/generator/execute.go", - "k8s.io/gengo/generator/generator.go", - "k8s.io/gengo/generator/import_tracker.go", - "k8s.io/gengo/generator/snippet_writer.go", - ], - tags = ["automanaged"], - deps = [ - "//vendor:github.com/golang/glog", - "//vendor:k8s.io/gengo/namer", - "//vendor:k8s.io/gengo/parser", - "//vendor:k8s.io/gengo/types", - ], -) - -go_library( - name = "k8s.io/gengo/namer", - srcs = [ - "k8s.io/gengo/namer/doc.go", - "k8s.io/gengo/namer/import_tracker.go", - "k8s.io/gengo/namer/namer.go", - "k8s.io/gengo/namer/order.go", - "k8s.io/gengo/namer/plural_namer.go", - ], - tags = ["automanaged"], - deps = ["//vendor:k8s.io/gengo/types"], -) - -go_library( - name = "k8s.io/gengo/parser", - srcs = [ - "k8s.io/gengo/parser/doc.go", - "k8s.io/gengo/parser/parse.go", - ], - tags = ["automanaged"], - deps = [ - "//vendor:github.com/golang/glog", - "//vendor:k8s.io/gengo/types", - ], -) - -go_library( - name = "k8s.io/gengo/types", - srcs = [ - "k8s.io/gengo/types/comments.go", - "k8s.io/gengo/types/doc.go", - "k8s.io/gengo/types/flatten.go", - "k8s.io/gengo/types/types.go", - ], - tags = ["automanaged"], -) - -go_library( - name = "k8s.io/heapster/metrics/api/v1/types", - srcs = [ - "k8s.io/heapster/metrics/api/v1/types/historical_types.go", - "k8s.io/heapster/metrics/api/v1/types/model_types.go", - "k8s.io/heapster/metrics/api/v1/types/types.go", - ], - tags = ["automanaged"], -) - -go_library( - name = "k8s.io/heapster/metrics/apis/metrics/v1alpha1", - srcs = ["k8s.io/heapster/metrics/apis/metrics/v1alpha1/types.go"], - tags = ["automanaged"], - deps = [ - "//pkg/api/unversioned:go_default_library", - "//pkg/api/v1:go_default_library", - ], -) - -go_library( - name = "github.com/exponent-io/jsonpath", - srcs = [ - "github.com/exponent-io/jsonpath/decoder.go", - "github.com/exponent-io/jsonpath/path.go", - "github.com/exponent-io/jsonpath/pathaction.go", - ], - tags = ["automanaged"], -) - go_library( name = "k8s.io/client-go/_vendor/cloud.google.com/go/compute/metadata", srcs = ["k8s.io/client-go/_vendor/cloud.google.com/go/compute/metadata/metadata.go"], @@ -11369,3 +11237,163 @@ go_library( "//vendor:k8s.io/client-go/pkg/util/net", ], ) + +go_library( + name = "k8s.io/gengo/args", + srcs = ["k8s.io/gengo/args/args.go"], + tags = ["automanaged"], + deps = [ + "//vendor:github.com/spf13/pflag", + "//vendor:k8s.io/gengo/generator", + "//vendor:k8s.io/gengo/namer", + "//vendor:k8s.io/gengo/parser", + "//vendor:k8s.io/gengo/types", + ], +) + +go_library( + name = "k8s.io/gengo/examples/deepcopy-gen/generators", + srcs = ["k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go"], + tags = ["automanaged"], + deps = [ + "//vendor:github.com/golang/glog", + "//vendor:k8s.io/gengo/args", + "//vendor:k8s.io/gengo/examples/set-gen/sets", + "//vendor:k8s.io/gengo/generator", + "//vendor:k8s.io/gengo/namer", + "//vendor:k8s.io/gengo/types", + ], +) + +go_library( + name = "k8s.io/gengo/examples/defaulter-gen/generators", + srcs = ["k8s.io/gengo/examples/defaulter-gen/generators/defaulter.go"], + tags = ["automanaged"], + deps = [ + "//vendor:github.com/golang/glog", + "//vendor:k8s.io/gengo/args", + "//vendor:k8s.io/gengo/generator", + "//vendor:k8s.io/gengo/namer", + "//vendor:k8s.io/gengo/types", + ], +) + +go_library( + name = "k8s.io/gengo/examples/import-boss/generators", + srcs = ["k8s.io/gengo/examples/import-boss/generators/import_restrict.go"], + tags = ["automanaged"], + deps = [ + "//vendor:github.com/golang/glog", + "//vendor:k8s.io/gengo/args", + "//vendor:k8s.io/gengo/generator", + "//vendor:k8s.io/gengo/namer", + "//vendor:k8s.io/gengo/types", + ], +) + +go_library( + name = "k8s.io/gengo/examples/set-gen/generators", + srcs = [ + "k8s.io/gengo/examples/set-gen/generators/sets.go", + "k8s.io/gengo/examples/set-gen/generators/tags.go", + ], + tags = ["automanaged"], + deps = [ + "//vendor:github.com/golang/glog", + "//vendor:k8s.io/gengo/args", + "//vendor:k8s.io/gengo/generator", + "//vendor:k8s.io/gengo/namer", + "//vendor:k8s.io/gengo/types", + ], +) + +go_library( + name = "k8s.io/gengo/examples/set-gen/sets", + srcs = [ + "k8s.io/gengo/examples/set-gen/sets/byte.go", + "k8s.io/gengo/examples/set-gen/sets/doc.go", + "k8s.io/gengo/examples/set-gen/sets/empty.go", + "k8s.io/gengo/examples/set-gen/sets/int.go", + "k8s.io/gengo/examples/set-gen/sets/int64.go", + "k8s.io/gengo/examples/set-gen/sets/string.go", + ], + tags = ["automanaged"], +) + +go_library( + name = "k8s.io/gengo/generator", + srcs = [ + "k8s.io/gengo/generator/default_generator.go", + "k8s.io/gengo/generator/default_package.go", + "k8s.io/gengo/generator/doc.go", + "k8s.io/gengo/generator/error_tracker.go", + "k8s.io/gengo/generator/execute.go", + "k8s.io/gengo/generator/generator.go", + "k8s.io/gengo/generator/import_tracker.go", + "k8s.io/gengo/generator/snippet_writer.go", + ], + tags = ["automanaged"], + deps = [ + "//vendor:github.com/golang/glog", + "//vendor:k8s.io/gengo/namer", + "//vendor:k8s.io/gengo/parser", + "//vendor:k8s.io/gengo/types", + ], +) + +go_library( + name = "k8s.io/gengo/namer", + srcs = [ + "k8s.io/gengo/namer/doc.go", + "k8s.io/gengo/namer/import_tracker.go", + "k8s.io/gengo/namer/namer.go", + "k8s.io/gengo/namer/order.go", + "k8s.io/gengo/namer/plural_namer.go", + ], + tags = ["automanaged"], + deps = ["//vendor:k8s.io/gengo/types"], +) + +go_library( + name = "k8s.io/gengo/parser", + srcs = [ + "k8s.io/gengo/parser/doc.go", + "k8s.io/gengo/parser/parse.go", + ], + tags = ["automanaged"], + deps = [ + "//vendor:github.com/golang/glog", + "//vendor:k8s.io/gengo/types", + ], +) + +go_library( + name = "k8s.io/gengo/types", + srcs = [ + "k8s.io/gengo/types/comments.go", + "k8s.io/gengo/types/doc.go", + "k8s.io/gengo/types/flatten.go", + "k8s.io/gengo/types/types.go", + ], + tags = ["automanaged"], +) + +go_library( + name = "k8s.io/heapster/metrics/api/v1/types", + srcs = [ + "k8s.io/heapster/metrics/api/v1/types/historical_types.go", + "k8s.io/heapster/metrics/api/v1/types/model_types.go", + "k8s.io/heapster/metrics/api/v1/types/types.go", + ], + tags = ["automanaged"], +) + +go_library( + name = "k8s.io/heapster/metrics/apis/metrics/v1alpha1", + srcs = ["k8s.io/heapster/metrics/apis/metrics/v1alpha1/types.go"], + tags = ["automanaged"], + deps = [ + "//pkg/api/unversioned:go_default_library", + "//pkg/api/v1:go_default_library", + ], +) diff --git a/vendor/github.com/jteeuwen/go-bindata/CONTRIBUTING.md b/vendor/github.com/jteeuwen/go-bindata/CONTRIBUTING.md new file mode 100644 index 00000000000..e0732f54ebd --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/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. + + diff --git a/vendor/github.com/jteeuwen/go-bindata/LICENSE b/vendor/github.com/jteeuwen/go-bindata/LICENSE new file mode 100644 index 00000000000..c07a9311f17 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/LICENSE @@ -0,0 +1,3 @@ +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 diff --git a/vendor/github.com/jteeuwen/go-bindata/Makefile b/vendor/github.com/jteeuwen/go-bindata/Makefile new file mode 100644 index 00000000000..84b661cb23c --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/Makefile @@ -0,0 +1,2 @@ +all: + make -C testdata diff --git a/vendor/github.com/jteeuwen/go-bindata/README.md b/vendor/github.com/jteeuwen/go-bindata/README.md new file mode 100644 index 00000000000..bca57f72db3 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/README.md @@ -0,0 +1,189 @@ +## bindata + +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 github.com/jteeuwen/go-bindata/... + + +### Usage + +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. + +The simplest invocation generates a `bindata.go` file in the current +working directory. It includes all assets from the `data` directory. + + $ go-bindata data/ + +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. + + $ go-bindata data/... + +To specify the name of the output file being generated, we use the following: + + $ go-bindata -o myfile.go data/ + +Multiple input directories can be specified if necessary. + + $ go-bindata dir1/... /path/to/dir2/... dir3 + + +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 + +Using the `-nomemcopy` flag, 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`: + +```go +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. + +```go +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 + +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 +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` 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 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`. + diff --git a/vendor/github.com/jteeuwen/go-bindata/asset.go b/vendor/github.com/jteeuwen/go-bindata/asset.go new file mode 100644 index 00000000000..95b6b94f3c3 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/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. +} diff --git a/vendor/github.com/jteeuwen/go-bindata/bytewriter.go b/vendor/github.com/jteeuwen/go-bindata/bytewriter.go new file mode 100644 index 00000000000..05d6d678092 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/bytewriter.go @@ -0,0 +1,44 @@ +// 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" +) + +var ( + newline = []byte{'\n'} + dataindent = []byte{'\t', '\t'} + space = []byte{' '} +) + +type ByteWriter struct { + io.Writer + c int +} + +func (w *ByteWriter) Write(p []byte) (n int, err error) { + if len(p) == 0 { + return + } + + 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]) + w.c++ + } + + n++ + + return +} diff --git a/vendor/github.com/jteeuwen/go-bindata/config.go b/vendor/github.com/jteeuwen/go-bindata/config.go new file mode 100644 index 00000000000..2bd0d56d8c0 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/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 +} diff --git a/vendor/github.com/jteeuwen/go-bindata/convert.go b/vendor/github.com/jteeuwen/go-bindata/convert.go new file mode 100644 index 00000000000..cf0466edd12 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/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 +} diff --git a/vendor/github.com/jteeuwen/go-bindata/debug.go b/vendor/github.com/jteeuwen/go-bindata/debug.go new file mode 100644 index 00000000000..09fee785d59 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/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 +} diff --git a/vendor/github.com/jteeuwen/go-bindata/doc.go b/vendor/github.com/jteeuwen/go-bindata/doc.go new file mode 100644 index 00000000000..09ead1e3bac --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/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 diff --git a/vendor/github.com/jteeuwen/go-bindata/go-bindata/AppendSliceValue.go b/vendor/github.com/jteeuwen/go-bindata/go-bindata/AppendSliceValue.go new file mode 100644 index 00000000000..f5da495961b --- /dev/null +++ b/vendor/github.com/jteeuwen/go-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 +} diff --git a/vendor/github.com/jteeuwen/go-bindata/go-bindata/main.go b/vendor/github.com/jteeuwen/go-bindata/go-bindata/main.go new file mode 100644 index 00000000000..503a059e618 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/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" + + "github.com/jteeuwen/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] \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 \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, + } + } + +} diff --git a/vendor/github.com/jteeuwen/go-bindata/go-bindata/version.go b/vendor/github.com/jteeuwen/go-bindata/go-bindata/version.go new file mode 100644 index 00000000000..a12508ede93 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/go-bindata/version.go @@ -0,0 +1,31 @@ +// 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 ( + "fmt" + "runtime" +) + +const ( + AppName = "go-bindata" + AppVersionMajor = 3 + AppVersionMinor = 1 +) + +// revision part of the program version. +// This will be set automatically at build time like so: +// +// go build -ldflags "-X main.AppVersionRev `date -u +%s`" +var AppVersionRev string + +func Version() string { + if len(AppVersionRev) == 0 { + AppVersionRev = "0" + } + + return fmt.Sprintf("%s %d.%d.%s (Go runtime %s).\nCopyright (c) 2010-2013, Jim Teeuwen.", + AppName, AppVersionMajor, AppVersionMinor, AppVersionRev, runtime.Version()) +} diff --git a/vendor/github.com/jteeuwen/go-bindata/release.go b/vendor/github.com/jteeuwen/go-bindata/release.go new file mode 100644 index 00000000000..6aefeb28acf --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/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 +} diff --git a/vendor/github.com/jteeuwen/go-bindata/restore.go b/vendor/github.com/jteeuwen/go-bindata/restore.go new file mode 100644 index 00000000000..65db0e8f955 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/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 +} diff --git a/vendor/github.com/jteeuwen/go-bindata/stringwriter.go b/vendor/github.com/jteeuwen/go-bindata/stringwriter.go new file mode 100644 index 00000000000..77daa04cb54 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/stringwriter.go @@ -0,0 +1,36 @@ +// 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 ( + "io" +) + +const lowerHex = "0123456789abcdef" + +type StringWriter struct { + io.Writer + c int +} + +func (w *StringWriter) Write(p []byte) (n int, err error) { + if len(p) == 0 { + return + } + + 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++ + } + + n++ + + return +} diff --git a/vendor/github.com/jteeuwen/go-bindata/toc.go b/vendor/github.com/jteeuwen/go-bindata/toc.go new file mode 100644 index 00000000000..9ec410b2568 --- /dev/null +++ b/vendor/github.com/jteeuwen/go-bindata/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 +}