- [*] v5.0.01: make all template external to expose the API on godoc

suntong · suntong · commit 570d6a120509 · 2020-07-27T00:58:00.000-04:00
diff --git a/cmd/easygen/main.go b/cmd/easygen/main.go
@@ -41,7 +41,7 @@ import (
 
 var (
 	progname = "easygen"
-	version  = "4.1.01"
+	version  = "5.0.01"
 	date     = "2020-07-26"
 )
 
diff --git a/egCal/EgCal.go b/egCal/EgCal.go
@@ -26,15 +26,23 @@ import (
 // Constant and data type/structure definitions
 
 // EgCal -- EasyGen Calculation
+/*
+
+  add is template function for Add
+  subtract is template function for Subtract
+  multiply is template function for Multiply
+  divide is template function for Divide
+
+*/
 type EgCal struct {
 	*easygen.EgBase
 }
 
 var egFuncMap = easygen.FuncMap{
-	"add":      add,
-	"subtract": subtract,
-	"multiply": multiply,
-	"divide":   divide,
+	"add":      Add,
+	"subtract": Subtract,
+	"multiply": Multiply,
+	"divide":   Divide,
 }
 
 ////////////////////////////////////////////////////////////////////////////
diff --git a/egCal/consul-template_functions.go b/egCal/consul-template_functions.go
@@ -12,8 +12,8 @@ import (
 	"reflect"
 )
 
-// add returns the sum of a and b.
-func add(a, b interface{}) (interface{}, error) {
+// Add returns the sum of a and b.
+func Add(a, b interface{}) (interface{}, error) {
 	av := reflect.ValueOf(a)
 	bv := reflect.ValueOf(b)
 
@@ -56,8 +56,8 @@ func add(a, b interface{}) (interface{}, error) {
 	}
 }
 
-// subtract returns the difference of b from a.
-func subtract(a, b interface{}) (interface{}, error) {
+// Subtract returns the difference of b from a.
+func Subtract(a, b interface{}) (interface{}, error) {
 	av := reflect.ValueOf(a)
 	bv := reflect.ValueOf(b)
 
@@ -100,8 +100,8 @@ func subtract(a, b interface{}) (interface{}, error) {
 	}
 }
 
-// multiply returns the product of a and b.
-func multiply(a, b interface{}) (interface{}, error) {
+// Multiply returns the product of a and b.
+func Multiply(a, b interface{}) (interface{}, error) {
 	av := reflect.ValueOf(a)
 	bv := reflect.ValueOf(b)
 
@@ -144,8 +144,8 @@ func multiply(a, b interface{}) (interface{}, error) {
 	}
 }
 
-// divide returns the division of b from a.
-func divide(a, b interface{}) (interface{}, error) {
+// Divide returns the division of b from a.
+func Divide(a, b interface{}) (interface{}, error) {
 	av := reflect.ValueOf(a)
 	bv := reflect.ValueOf(b)
 
diff --git a/egFilePath/EgFilePath.go b/egFilePath/EgFilePath.go
@@ -26,6 +26,29 @@ import (
 // Constant and data type/structure definitions
 
 // EgFilePath -- EasyGen FilePath manupilation functionalities
+/*
+
+  fpAbs is wrapper for filepath.Abs
+  fpBase is wrapper for filepath.Base
+  fpClean is wrapper for filepath.Clean
+  fpDir is wrapper for filepath.Dir
+  fpEvalSymlinks is wrapper for filepath.EvalSymlinks
+  fpExt is wrapper for filepath.Ext
+  fpFromSlash is wrapper for filepath.FromSlash
+  fpGlob is wrapper for filepath.Glob
+  fpHasPrefix is wrapper for filepath.HasPrefix
+  fpIsAbs is wrapper for filepath.IsAbs
+  fpJoin is wrapper for filepath.Join
+  fpMatch is wrapper for filepath.Match
+  fpRel is wrapper for filepath.Rel
+  fpSplitList is wrapper for filepath.SplitList
+  fpToSlash is wrapper for filepath.ToSlash
+  fpVolumeName is wrapper for filepath.VolumeName
+
+  isDir is template function for IsDir
+  basename is template function for Basename
+
+*/
 type EgFilePath struct {
 	*easygen.EgBase
 }
@@ -62,11 +85,13 @@ func FuncDefs() template.FuncMap {
 //==========================================================================
 // support functions
 
+// IsDir returns true if path is dir
 func IsDir(path string) bool {
 	info, _ := os.Stat(path)
 	return info.IsDir()
 }
 
+// Basename returns basename(path)
 func Basename(s string) string {
 	s = filepath.Base(s)
 	n := strings.LastIndexByte(s, '.')
diff --git a/template.go b/template.go
@@ -26,6 +26,79 @@ type Template interface {
 }
 
 // EgBase -- EasyGen Template Base
+/*
+
+  stringsCompare is wrapper for strings.Compare
+  stringsContains is wrapper for strings.Contains
+  stringsContainsAny is wrapper for strings.ContainsAny
+  stringsContainsRune is wrapper for strings.ContainsRune
+  stringsCount is wrapper for strings.Count
+  stringsEqualFold is wrapper for strings.EqualFold
+  stringsFields is wrapper for strings.Fields
+  stringsFieldsFunc is wrapper for strings.FieldsFunc
+  stringsHasPrefix is wrapper for strings.HasPrefix
+  stringsHasSuffix is wrapper for strings.HasSuffix
+  stringsIndex is wrapper for strings.Index
+  stringsIndexAny is wrapper for strings.IndexAny
+  stringsIndexByte is wrapper for strings.IndexByte
+  stringsIndexFunc is wrapper for strings.IndexFunc
+  stringsIndexRune is wrapper for strings.IndexRune
+  stringsJoin is wrapper for strings.Join
+  stringsLastIndex is wrapper for strings.LastIndex
+  stringsLastIndexAny is wrapper for strings.LastIndexAny
+  stringsLastIndexByte is wrapper for strings.LastIndexByte
+  stringsLastIndexFunc is wrapper for strings.LastIndexFunc
+  stringsMap is wrapper for strings.Map
+  stringsRepeat is wrapper for strings.Repeat
+  stringsReplace is wrapper for strings.Replace
+  stringsSplit is wrapper for strings.Split
+  stringsSplitAfter is wrapper for strings.SplitAfter
+  stringsSplitAfterN is wrapper for strings.SplitAfterN
+  stringsSplitN is wrapper for strings.SplitN
+  stringsTitle is wrapper for strings.Title
+  stringsToLower is wrapper for strings.ToLower
+  stringsToLowerSpecial is wrapper for strings.ToLowerSpecial
+  stringsToTitle is wrapper for strings.ToTitle
+  stringsToTitleSpecial is wrapper for strings.ToTitleSpecial
+  stringsToUpper is wrapper for strings.ToUpper
+  stringsToUpperSpecial is wrapper for strings.ToUpperSpecial
+  stringsTrim is wrapper for strings.Trim
+  stringsTrimFunc is wrapper for strings.TrimFunc
+  stringsTrimLeft is wrapper for strings.TrimLeft
+  stringsTrimLeftFunc is wrapper for strings.TrimLeftFunc
+  stringsTrimPrefix is wrapper for strings.TrimPrefix
+  stringsTrimRight is wrapper for strings.TrimRight
+  stringsTrimRightFunc is wrapper for strings.TrimRightFunc
+  stringsTrimSpace is wrapper for strings.TrimSpace
+  stringsTrimSuffix is wrapper for strings.TrimSuffix
+
+  eqf is wrapper for strings.EqualFold
+  split is wrapper for strings.Fields
+
+  regexpFindAllString is template function for RegexpFindAllString
+  regexpFindAllStringIndex is template function for RegexpFindAllStringIndex
+  regexpFindAllStringSubmatch is template function for RegexpFindAllStringSubmatch
+  regexpFindAllStringSubmatchIndex is template function for RegexpFindAllStringSubmatchIndex
+  regexpFindString is template function for RegexpFindString
+  regexpFindStringIndex is template function for RegexpFindStringIndex
+  regexpFindStringSubmatch is template function for RegexpFindStringSubmatch
+  regexpFindStringSubmatchIndex is template function for RegexpFindStringSubmatchIndex
+  regexpMatchString is template function for RegexpMatchString
+  regexpReplaceAllLiteralString is template function for RegexpReplaceAllLiteralString
+  regexpReplaceAllString is template function for RegexpReplaceAllString
+  regexpReplaceAllStringFunc is template function for RegexpReplaceAllStringFunc
+  regexpSplit is template function for RegexpSplit
+
+  ENV is template function for os.Getenv
+  substr is template function for Substr
+  coalesce is template function for Coalesce
+  quote4shell is template function for Quote4shell
+
+  minus1 is template function for Minus1
+  date is template function for Date
+  timestamp is template function for Timestamp
+
+*/
 type EgBase struct {
 	*template.Template
 }
@@ -85,29 +158,29 @@ var egFuncMap = FuncMap{
 	"split": strings.Fields,
 
 	// == standard regexp function definitions
-	"regexpFindAllString":              regexpFindAllString,
-	"regexpFindAllStringIndex":         regexpFindAllStringIndex,
-	"regexpFindAllStringSubmatch":      regexpFindAllStringSubmatch,
-	"regexpFindAllStringSubmatchIndex": regexpFindAllStringSubmatchIndex,
-	"regexpFindString":                 regexpFindString,
-	"regexpFindStringIndex":            regexpFindStringIndex,
-	"regexpFindStringSubmatch":         regexpFindStringSubmatch,
-	"regexpFindStringSubmatchIndex":    regexpFindStringSubmatchIndex,
-	"regexpMatchString":                regexpMatchString,
-	"regexpReplaceAllLiteralString":    regexpReplaceAllLiteralString,
-	"regexpReplaceAllString":           regexpReplaceAllString,
-	"regexpReplaceAllStringFunc":       regexpReplaceAllStringFunc,
-	"regexpSplit":                      regexpSplit,
+	"regexpFindAllString":              RegexpFindAllString,
+	"regexpFindAllStringIndex":         RegexpFindAllStringIndex,
+	"regexpFindAllStringSubmatch":      RegexpFindAllStringSubmatch,
+	"regexpFindAllStringSubmatchIndex": RegexpFindAllStringSubmatchIndex,
+	"regexpFindString":                 RegexpFindString,
+	"regexpFindStringIndex":            RegexpFindStringIndex,
+	"regexpFindStringSubmatch":         RegexpFindStringSubmatch,
+	"regexpFindStringSubmatchIndex":    RegexpFindStringSubmatchIndex,
+	"regexpMatchString":                RegexpMatchString,
+	"regexpReplaceAllLiteralString":    RegexpReplaceAllLiteralString,
+	"regexpReplaceAllString":           RegexpReplaceAllString,
+	"regexpReplaceAllStringFunc":       RegexpReplaceAllStringFunc,
+	"regexpSplit":                      RegexpSplit,
 
 	// == my added functions
 	"ENV":         os.Getenv,
 	"substr":      Substr,
-	"coalesce":    coalesce,
-	"quote4shell": quote4shell,
+	"coalesce":    Coalesce,
+	"quote4shell": Quote4shell,
 
-	"minus1":    minus1,
-	"date":      date,
-	"timestamp": timestamp,
+	"minus1":    Minus1,
+	"date":      Date,
+	"timestamp": Timestamp,
 }
 
 ////////////////////////////////////////////////////////////////////////////
diff --git a/tf-calc.go b/tf-calc.go
@@ -6,5 +6,5 @@ package easygen
 // By Caleb Spare @gmail.com
 // https://groups.google.com/d/msg/golang-nuts/gzAyBLAeUbU/LwgomgxcjQ8J
 
-// Get input less 1
-func minus1(n int) int { return n - 1 }
+// Minus1 calculates to input less 1
+func Minus1(n int) int { return n - 1 }
diff --git a/tf-datetime.go b/tf-datetime.go
@@ -15,8 +15,8 @@ var now = func() time.Time { return time.Now() }
 
 // https://godoc.org/time#pkg-constants
 
-// date returns the date or year
-func date(fmt string) string {
+// Date returns the date or year
+func Date(fmt string) string {
 	switch fmt {
 	case "Y4":
 		// returns the year string of length 4
@@ -33,9 +33,9 @@ func date(fmt string) string {
 
 // https://github.com/hashicorp/consul-template/blob/de2ebf4/template_functions.go#L666-L682
 
-// timestamp returns the current UNIX timestamp in UTC. If an argument is
+// Timestamp returns the current UNIX timestamp in UTC. If an argument is
 // specified, it will be used to format the timestamp.
-func timestamp(s ...string) (string, error) {
+func Timestamp(s ...string) (string, error) {
 	switch len(s) {
 	case 0:
 		return now().Format(time.RFC3339), nil
diff --git a/tf-strings.go b/tf-strings.go
@@ -82,64 +82,77 @@ func Substr(a string, nums ...interface{}) (string, error) {
 ////////////////////////////////////////////////////////////////////////////
 // Regexp Function Definitions
 
-func regexpFindAllString(s string, regExp string, n int) []string {
+// RegexpFindAllString is wrapper for regexp.FindAllString
+func RegexpFindAllString(s string, regExp string, n int) []string {
 	return regexp.MustCompile(regExp).FindAllString(s, n)
 }
 
-func regexpFindAllStringIndex(s string, regExp string, n int) [][]int {
+// RegexpFindAllStringIndex is wrapper for regexp.FindAllStringIndex
+func RegexpFindAllStringIndex(s string, regExp string, n int) [][]int {
 	return regexp.MustCompile(regExp).FindAllStringIndex(s, n)
 }
 
-func regexpFindAllStringSubmatch(s string, regExp string, n int) [][]string {
+// RegexpFindAllStringSubmatch is wrapper for regexp.FindAllStringSubmatch
+func RegexpFindAllStringSubmatch(s string, regExp string, n int) [][]string {
 	return regexp.MustCompile(regExp).FindAllStringSubmatch(s, n)
 }
 
-func regexpFindAllStringSubmatchIndex(s string, regExp string, n int) [][]int {
+// RegexpFindAllStringSubmatchIndex is wrapper for regexp.FindAllStringSubmatchIndex
+func RegexpFindAllStringSubmatchIndex(s string, regExp string, n int) [][]int {
 	return regexp.MustCompile(regExp).FindAllStringSubmatchIndex(s, n)
 }
 
-func regexpFindString(s string, regExp string) string {
+// RegexpFindString is wrapper for regexp.FindString
+func RegexpFindString(s string, regExp string) string {
 	return regexp.MustCompile(regExp).FindString(s)
 }
 
-func regexpFindStringIndex(s string, regExp string) (loc []int) {
+// RegexpFindStringIndex is wrapper for regexp.FindStringIndex
+func RegexpFindStringIndex(s string, regExp string) (loc []int) {
 	return regexp.MustCompile(regExp).FindStringIndex(s)
 }
 
-func regexpFindStringSubmatch(s string, regExp string) []string {
+// RegexpFindStringSubmatch is wrapper for regexp.FindStringSubmatch
+func RegexpFindStringSubmatch(s string, regExp string) []string {
 	return regexp.MustCompile(regExp).FindStringSubmatch(s)
 }
 
-func regexpFindStringSubmatchIndex(s string, regExp string) []int {
+// RegexpFindStringSubmatchIndex is wrapper for regexp.FindStringSubmatchIndex
+func RegexpFindStringSubmatchIndex(s string, regExp string) []int {
 	return regexp.MustCompile(regExp).FindStringSubmatchIndex(s)
 }
 
-func regexpMatchString(s string, regExp string) bool {
+// RegexpMatchString is wrapper for regexp.MatchString
+func RegexpMatchString(s string, regExp string) bool {
 	return regexp.MustCompile(regExp).MatchString(s)
 }
 
-func regexpReplaceAllLiteralString(src, regExp string, repl string) string {
+// RegexpReplaceAllLiteralString is wrapper for regexp.ReplaceAllLiteralString
+func RegexpReplaceAllLiteralString(src, regExp string, repl string) string {
 	return regexp.MustCompile(regExp).ReplaceAllLiteralString(src, repl)
 }
 
-func regexpReplaceAllString(src, regExp string, repl string) string {
+// RegexpReplaceAllString is wrapper for regexp.ReplaceAllString
+func RegexpReplaceAllString(src, regExp string, repl string) string {
 	return regexp.MustCompile(regExp).ReplaceAllString(src, repl)
 }
 
-func regexpReplaceAllStringFunc(src string, regExp string, repl func(string) string) string {
+// RegexpReplaceAllStringFunc is wrapper for regexp.ReplaceAllStringFunc
+func RegexpReplaceAllStringFunc(src string, regExp string, repl func(string) string) string {
 	return regexp.MustCompile(regExp).ReplaceAllStringFunc(src, repl)
 }
 
-func regexpSplit(s string, regExp string, n int) []string {
+// RegexpSplit is wrapper for regexp.Split
+func RegexpSplit(s string, regExp string, n int) []string {
 	return regexp.MustCompile(regExp).Split(s, n)
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // Misc
 
-// coalesce function takes two or more string arguments and returns the first argument that is not empty.
+// Coalesce function takes two or more string arguments and returns the first argument that is not empty.
 // The result is empty only if all the arguments are empty.
-func coalesce(s ...string) string {
+func Coalesce(s ...string) string {
 	for _, str := range s {
 		if len(str) != 0 && str != "<no value>" {
 			return str
@@ -148,8 +161,8 @@ func coalesce(s ...string) string {
 	return ""
 }
 
-// quote4shell -- quote file name for shell.
+// Quote4shell -- quote file name for shell.
 // So "%bob's file" will be quoted as '%bob'\''s file'
-func quote4shell(s string) string {
+func Quote4shell(s string) string {
 	return "'" + strings.Join(strings.Split(s, "'"), `'\''`) + "'"
 }

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ import (`
`41`	`41`
`42`	`42`	`var (`
`43`	`43`	`progname = "easygen"`
`44`		`- version = "4.1.01"`
	`44`	`+ version = "5.0.01"`
`45`	`45`	`date = "2020-07-26"`
`46`	`46`	`)`
`47`	`47`
Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,8 @@ import (`
`12`	`12`	`"reflect"`
`13`	`13`	`)`
`14`	`14`
`15`		`-// add returns the sum of a and b.`
`16`		`-func add(a, b interface{}) (interface{}, error) {`
	`15`	`+// Add returns the sum of a and b.`
	`16`	`+func Add(a, b interface{}) (interface{}, error) {`
`17`	`17`	`av := reflect.ValueOf(a)`
`18`	`18`	`bv := reflect.ValueOf(b)`
`19`	`19`
`@@ -56,8 +56,8 @@ func add(a, b interface{}) (interface{}, error) {`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`-// subtract returns the difference of b from a.`
`60`		`-func subtract(a, b interface{}) (interface{}, error) {`
	`59`	`+// Subtract returns the difference of b from a.`
	`60`	`+func Subtract(a, b interface{}) (interface{}, error) {`
`61`	`61`	`av := reflect.ValueOf(a)`
`62`	`62`	`bv := reflect.ValueOf(b)`
`63`	`63`
`@@ -100,8 +100,8 @@ func subtract(a, b interface{}) (interface{}, error) {`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
`103`		`-// multiply returns the product of a and b.`
`104`		`-func multiply(a, b interface{}) (interface{}, error) {`
	`103`	`+// Multiply returns the product of a and b.`
	`104`	`+func Multiply(a, b interface{}) (interface{}, error) {`
`105`	`105`	`av := reflect.ValueOf(a)`
`106`	`106`	`bv := reflect.ValueOf(b)`
`107`	`107`
`@@ -144,8 +144,8 @@ func multiply(a, b interface{}) (interface{}, error) {`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`
`147`		`-// divide returns the division of b from a.`
`148`		`-func divide(a, b interface{}) (interface{}, error) {`
	`147`	`+// Divide returns the division of b from a.`
	`148`	`+func Divide(a, b interface{}) (interface{}, error) {`
`149`	`149`	`av := reflect.ValueOf(a)`
`150`	`150`	`bv := reflect.ValueOf(b)`
`151`	`151`