Extracting data namespace, renaming typeconv to conv namespace

Signed-off-by: Dave Henderson <dhenderson@gmail.com>

2 files changed, 174 insertions, 0 deletions

diff --git a/funcs/conv.go b/funcs/conv.go
new file mode 100644
index 00000000..2e5327b1
--- /dev/null
+++ b/funcs/conv.go
@@ -0,0 +1,64 @@
+package funcs
+
+import (
+	"net/url"
+	"sync"
+
+	"github.com/hairyhenderson/gomplate/conv"
+)
+
+var (
+	convNS     *ConvFuncs
+	convNSInit sync.Once
+)
+
+// ConvNS -
+func ConvNS() *ConvFuncs {
+	convNSInit.Do(func() { convNS = &ConvFuncs{} })
+	return convNS
+}
+
+// AddConvFuncs -
+func AddConvFuncs(f map[string]interface{}) {
+	f["conv"] = ConvNS
+
+	f["urlParse"] = ConvNS().URL
+	f["bool"] = ConvNS().Bool
+	f["has"] = ConvNS().Has
+	f["slice"] = ConvNS().Slice
+	f["join"] = ConvNS().Join
+}
+
+// ConvFuncs -
+type ConvFuncs struct{}
+
+func (f *ConvFuncs) Bool(s string) bool {
+	return conv.Bool(s)
+}
+
+func (f *ConvFuncs) Slice(args ...interface{}) []interface{} {
+	return conv.Slice(args...)
+}
+func (f *ConvFuncs) Join(in interface{}, sep string) string {
+	return conv.Join(in, sep)
+}
+func (f *ConvFuncs) Has(in interface{}, key string) bool {
+	return conv.Has(in, key)
+}
+
+func (f *ConvFuncs) ParseInt(s string, base, bitSize int) int64 {
+	return conv.MustParseInt(s, base, bitSize)
+}
+func (f *ConvFuncs) ParseFloat(s string, bitSize int) float64 {
+	return conv.MustParseFloat(s, bitSize)
+}
+func (f *ConvFuncs) ParseUint(s string, base, bitSize int) uint64 {
+	return conv.MustParseUint(s, base, bitSize)
+}
+func (f *ConvFuncs) Atoi(s string) int {
+	return conv.MustAtoi(s)
+}
+
+func (f *ConvFuncs) URL(s string) (*url.URL, error) {
+	return url.Parse(s)
+}
diff --git a/funcs/data.go b/funcs/data.go
new file mode 100644
index 00000000..0a432c1e
--- /dev/null
+++ b/funcs/data.go
@@ -0,0 +1,110 @@
+package funcs
+
+import (
+	"sync"
+
+	"github.com/hairyhenderson/gomplate/data"
+)
+
+var (
+	dataNS     *DataFuncs
+	dataNSInit sync.Once
+)
+
+// DataNS -
+func DataNS() *DataFuncs {
+	dataNSInit.Do(func() { dataNS = &DataFuncs{} })
+	return dataNS
+}
+
+// AddDataFuncs -
+func AddDataFuncs(f map[string]interface{}, d *data.Data) {
+	f["datasource"] = d.Datasource
+	f["ds"] = d.Datasource
+	f["datasourceExists"] = d.DatasourceExists
+	f["include"] = d.Include
+
+	f["data"] = DataNS
+
+	f["json"] = DataNS().JSON
+	f["jsonArray"] = DataNS().JSONArray
+	f["yaml"] = DataNS().YAML
+	f["yamlArray"] = DataNS().YAMLArray
+	f["toml"] = DataNS().TOML
+	f["csv"] = DataNS().CSV
+	f["csvByRow"] = DataNS().CSVByRow
+	f["csvByColumn"] = DataNS().CSVByColumn
+	f["toJSON"] = DataNS().ToJSON
+	f["toJSONPretty"] = DataNS().ToJSONPretty
+	f["toYAML"] = DataNS().ToYAML
+	f["toTOML"] = DataNS().ToTOML
+	f["toCSV"] = DataNS().ToCSV
+}
+
+// DataFuncs -
+type DataFuncs struct{}
+
+// JSON -
+func (f *DataFuncs) JSON(in string) map[string]interface{} {
+	return data.JSON(in)
+}
+
+// JSONArray -
+func (f *DataFuncs) JSONArray(in string) []interface{} {
+	return data.JSONArray(in)
+}
+
+// YAML -
+func (f *DataFuncs) YAML(in string) map[string]interface{} {
+	return data.YAML(in)
+}
+
+// YAMLArray -
+func (f *DataFuncs) YAMLArray(in string) []interface{} {
+	return data.YAMLArray(in)
+}
+
+// TOML -
+func (f *DataFuncs) TOML(in string) interface{} {
+	return data.TOML(in)
+}
+
+// CSV -
+func (f *DataFuncs) CSV(args ...string) [][]string {
+	return data.CSV(args...)
+}
+
+// CSVByRow -
+func (f *DataFuncs) CSVByRow(args ...string) (rows []map[string]string) {
+	return data.CSVByRow(args...)
+}
+
+// CSVByColumn -
+func (f *DataFuncs) CSVByColumn(args ...string) (cols map[string][]string) {
+	return data.CSVByColumn(args...)
+}
+
+// ToCSV -
+func (f *DataFuncs) ToCSV(args ...interface{}) string {
+	return data.ToCSV(args...)
+}
+
+// ToJSON -
+func (f *DataFuncs) ToJSON(in interface{}) string {
+	return data.ToJSON(in)
+}
+
+// ToJSONPretty -
+func (f *DataFuncs) ToJSONPretty(indent string, in interface{}) string {
+	return data.ToJSONPretty(indent, in)
+}
+
+// ToYAML -
+func (f *DataFuncs) ToYAML(in interface{}) string {
+	return data.ToYAML(in)
+}
+
+// ToTOML -
+func (f *DataFuncs) ToTOML(in interface{}) string {
+	return data.ToTOML(in)
+}