functions.go

Documentation: github.com/go-task/slim-sprig/v3

     1  package sprig
     2  
     3  import (
     4  	"errors"
     5  	"html/template"
     6  	"math/rand"
     7  	"os"
     8  	"path"
     9  	"path/filepath"
    10  	"reflect"
    11  	"strconv"
    12  	"strings"
    13  	ttemplate "text/template"
    14  	"time"
    15  )
    16  
    17  // FuncMap produces the function map.
    18  //
    19  // Use this to pass the functions into the template engine:
    20  //
    21  // 	tpl := template.New("foo").Funcs(sprig.FuncMap()))
    22  //
    23  func FuncMap() template.FuncMap {
    24  	return HtmlFuncMap()
    25  }
    26  
    27  // HermeticTxtFuncMap returns a 'text/template'.FuncMap with only repeatable functions.
    28  func HermeticTxtFuncMap() ttemplate.FuncMap {
    29  	r := TxtFuncMap()
    30  	for _, name := range nonhermeticFunctions {
    31  		delete(r, name)
    32  	}
    33  	return r
    34  }
    35  
    36  // HermeticHtmlFuncMap returns an 'html/template'.Funcmap with only repeatable functions.
    37  func HermeticHtmlFuncMap() template.FuncMap {
    38  	r := HtmlFuncMap()
    39  	for _, name := range nonhermeticFunctions {
    40  		delete(r, name)
    41  	}
    42  	return r
    43  }
    44  
    45  // TxtFuncMap returns a 'text/template'.FuncMap
    46  func TxtFuncMap() ttemplate.FuncMap {
    47  	return ttemplate.FuncMap(GenericFuncMap())
    48  }
    49  
    50  // HtmlFuncMap returns an 'html/template'.Funcmap
    51  func HtmlFuncMap() template.FuncMap {
    52  	return template.FuncMap(GenericFuncMap())
    53  }
    54  
    55  // GenericFuncMap returns a copy of the basic function map as a map[string]interface{}.
    56  func GenericFuncMap() map[string]interface{} {
    57  	gfm := make(map[string]interface{}, len(genericMap))
    58  	for k, v := range genericMap {
    59  		gfm[k] = v
    60  	}
    61  	return gfm
    62  }
    63  
    64  // These functions are not guaranteed to evaluate to the same result for given input, because they
    65  // refer to the environment or global state.
    66  var nonhermeticFunctions = []string{
    67  	// Date functions
    68  	"date",
    69  	"date_in_zone",
    70  	"date_modify",
    71  	"now",
    72  	"htmlDate",
    73  	"htmlDateInZone",
    74  	"dateInZone",
    75  	"dateModify",
    76  
    77  	// Strings
    78  	"randAlphaNum",
    79  	"randAlpha",
    80  	"randAscii",
    81  	"randNumeric",
    82  	"randBytes",
    83  	"uuidv4",
    84  
    85  	// OS
    86  	"env",
    87  	"expandenv",
    88  
    89  	// Network
    90  	"getHostByName",
    91  }
    92  
    93  var genericMap = map[string]interface{}{
    94  	"hello": func() string { return "Hello!" },
    95  
    96  	// Date functions
    97  	"ago":              dateAgo,
    98  	"date":             date,
    99  	"date_in_zone":     dateInZone,
   100  	"date_modify":      dateModify,
   101  	"dateInZone":       dateInZone,
   102  	"dateModify":       dateModify,
   103  	"duration":         duration,
   104  	"durationRound":    durationRound,
   105  	"htmlDate":         htmlDate,
   106  	"htmlDateInZone":   htmlDateInZone,
   107  	"must_date_modify": mustDateModify,
   108  	"mustDateModify":   mustDateModify,
   109  	"mustToDate":       mustToDate,
   110  	"now":              time.Now,
   111  	"toDate":           toDate,
   112  	"unixEpoch":        unixEpoch,
   113  
   114  	// Strings
   115  	"trunc":  trunc,
   116  	"trim":   strings.TrimSpace,
   117  	"upper":  strings.ToUpper,
   118  	"lower":  strings.ToLower,
   119  	"title":  strings.Title,
   120  	"substr": substring,
   121  	// Switch order so that "foo" | repeat 5
   122  	"repeat": func(count int, str string) string { return strings.Repeat(str, count) },
   123  	// Deprecated: Use trimAll.
   124  	"trimall": func(a, b string) string { return strings.Trim(b, a) },
   125  	// Switch order so that "$foo" | trimall "$"
   126  	"trimAll":    func(a, b string) string { return strings.Trim(b, a) },
   127  	"trimSuffix": func(a, b string) string { return strings.TrimSuffix(b, a) },
   128  	"trimPrefix": func(a, b string) string { return strings.TrimPrefix(b, a) },
   129  	// Switch order so that "foobar" | contains "foo"
   130  	"contains":   func(substr string, str string) bool { return strings.Contains(str, substr) },
   131  	"hasPrefix":  func(substr string, str string) bool { return strings.HasPrefix(str, substr) },
   132  	"hasSuffix":  func(substr string, str string) bool { return strings.HasSuffix(str, substr) },
   133  	"quote":      quote,
   134  	"squote":     squote,
   135  	"cat":        cat,
   136  	"indent":     indent,
   137  	"nindent":    nindent,
   138  	"replace":    replace,
   139  	"plural":     plural,
   140  	"sha1sum":    sha1sum,
   141  	"sha256sum":  sha256sum,
   142  	"adler32sum": adler32sum,
   143  	"toString":   strval,
   144  
   145  	// Wrap Atoi to stop errors.
   146  	"atoi":      func(a string) int { i, _ := strconv.Atoi(a); return i },
   147  	"int64":     toInt64,
   148  	"int":       toInt,
   149  	"float64":   toFloat64,
   150  	"seq":       seq,
   151  	"toDecimal": toDecimal,
   152  
   153  	//"gt": func(a, b int) bool {return a > b},
   154  	//"gte": func(a, b int) bool {return a >= b},
   155  	//"lt": func(a, b int) bool {return a < b},
   156  	//"lte": func(a, b int) bool {return a <= b},
   157  
   158  	// split "/" foo/bar returns map[int]string{0: foo, 1: bar}
   159  	"split":     split,
   160  	"splitList": func(sep, orig string) []string { return strings.Split(orig, sep) },
   161  	// splitn "/" foo/bar/fuu returns map[int]string{0: foo, 1: bar/fuu}
   162  	"splitn":    splitn,
   163  	"toStrings": strslice,
   164  
   165  	"until":     until,
   166  	"untilStep": untilStep,
   167  
   168  	// VERY basic arithmetic.
   169  	"add1": func(i interface{}) int64 { return toInt64(i) + 1 },
   170  	"add": func(i ...interface{}) int64 {
   171  		var a int64 = 0
   172  		for _, b := range i {
   173  			a += toInt64(b)
   174  		}
   175  		return a
   176  	},
   177  	"sub": func(a, b interface{}) int64 { return toInt64(a) - toInt64(b) },
   178  	"div": func(a, b interface{}) int64 { return toInt64(a) / toInt64(b) },
   179  	"mod": func(a, b interface{}) int64 { return toInt64(a) % toInt64(b) },
   180  	"mul": func(a interface{}, v ...interface{}) int64 {
   181  		val := toInt64(a)
   182  		for _, b := range v {
   183  			val = val * toInt64(b)
   184  		}
   185  		return val
   186  	},
   187  	"randInt": func(min, max int) int { return rand.Intn(max-min) + min },
   188  	"biggest": max,
   189  	"max":     max,
   190  	"min":     min,
   191  	"maxf":    maxf,
   192  	"minf":    minf,
   193  	"ceil":    ceil,
   194  	"floor":   floor,
   195  	"round":   round,
   196  
   197  	// string slices. Note that we reverse the order b/c that's better
   198  	// for template processing.
   199  	"join":      join,
   200  	"sortAlpha": sortAlpha,
   201  
   202  	// Defaults
   203  	"default":          dfault,
   204  	"empty":            empty,
   205  	"coalesce":         coalesce,
   206  	"all":              all,
   207  	"any":              any,
   208  	"compact":          compact,
   209  	"mustCompact":      mustCompact,
   210  	"fromJson":         fromJson,
   211  	"toJson":           toJson,
   212  	"toPrettyJson":     toPrettyJson,
   213  	"toRawJson":        toRawJson,
   214  	"mustFromJson":     mustFromJson,
   215  	"mustToJson":       mustToJson,
   216  	"mustToPrettyJson": mustToPrettyJson,
   217  	"mustToRawJson":    mustToRawJson,
   218  	"ternary":          ternary,
   219  
   220  	// Reflection
   221  	"typeOf":     typeOf,
   222  	"typeIs":     typeIs,
   223  	"typeIsLike": typeIsLike,
   224  	"kindOf":     kindOf,
   225  	"kindIs":     kindIs,
   226  	"deepEqual":  reflect.DeepEqual,
   227  
   228  	// OS:
   229  	"env":       os.Getenv,
   230  	"expandenv": os.ExpandEnv,
   231  
   232  	// Network:
   233  	"getHostByName": getHostByName,
   234  
   235  	// Paths:
   236  	"base":  path.Base,
   237  	"dir":   path.Dir,
   238  	"clean": path.Clean,
   239  	"ext":   path.Ext,
   240  	"isAbs": path.IsAbs,
   241  
   242  	// Filepaths:
   243  	"osBase":  filepath.Base,
   244  	"osClean": filepath.Clean,
   245  	"osDir":   filepath.Dir,
   246  	"osExt":   filepath.Ext,
   247  	"osIsAbs": filepath.IsAbs,
   248  
   249  	// Encoding:
   250  	"b64enc": base64encode,
   251  	"b64dec": base64decode,
   252  	"b32enc": base32encode,
   253  	"b32dec": base32decode,
   254  
   255  	// Data Structures:
   256  	"tuple":  list, // FIXME: with the addition of append/prepend these are no longer immutable.
   257  	"list":   list,
   258  	"dict":   dict,
   259  	"get":    get,
   260  	"set":    set,
   261  	"unset":  unset,
   262  	"hasKey": hasKey,
   263  	"pluck":  pluck,
   264  	"keys":   keys,
   265  	"pick":   pick,
   266  	"omit":   omit,
   267  	"values": values,
   268  
   269  	"append": push, "push": push,
   270  	"mustAppend": mustPush, "mustPush": mustPush,
   271  	"prepend":     prepend,
   272  	"mustPrepend": mustPrepend,
   273  	"first":       first,
   274  	"mustFirst":   mustFirst,
   275  	"rest":        rest,
   276  	"mustRest":    mustRest,
   277  	"last":        last,
   278  	"mustLast":    mustLast,
   279  	"initial":     initial,
   280  	"mustInitial": mustInitial,
   281  	"reverse":     reverse,
   282  	"mustReverse": mustReverse,
   283  	"uniq":        uniq,
   284  	"mustUniq":    mustUniq,
   285  	"without":     without,
   286  	"mustWithout": mustWithout,
   287  	"has":         has,
   288  	"mustHas":     mustHas,
   289  	"slice":       slice,
   290  	"mustSlice":   mustSlice,
   291  	"concat":      concat,
   292  	"dig":         dig,
   293  	"chunk":       chunk,
   294  	"mustChunk":   mustChunk,
   295  
   296  	// Flow Control:
   297  	"fail": func(msg string) (string, error) { return "", errors.New(msg) },
   298  
   299  	// Regex
   300  	"regexMatch":                 regexMatch,
   301  	"mustRegexMatch":             mustRegexMatch,
   302  	"regexFindAll":               regexFindAll,
   303  	"mustRegexFindAll":           mustRegexFindAll,
   304  	"regexFind":                  regexFind,
   305  	"mustRegexFind":              mustRegexFind,
   306  	"regexReplaceAll":            regexReplaceAll,
   307  	"mustRegexReplaceAll":        mustRegexReplaceAll,
   308  	"regexReplaceAllLiteral":     regexReplaceAllLiteral,
   309  	"mustRegexReplaceAllLiteral": mustRegexReplaceAllLiteral,
   310  	"regexSplit":                 regexSplit,
   311  	"mustRegexSplit":             mustRegexSplit,
   312  	"regexQuoteMeta":             regexQuoteMeta,
   313  
   314  	// URLs:
   315  	"urlParse": urlParse,
   316  	"urlJoin":  urlJoin,
   317  }
   318
View as plain text