mirror of
https://github.com/strongdm/comply
synced 2024-08-29 18:43:32 +00:00
231 lines
5.4 KiB
Go
231 lines
5.4 KiB
Go
|
// 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
|
||
|
}
|