Doc updates (#9)

Author: cam-stitt

docs/SUMMARY.md

@@ -8,6 +8,9 @@
 
 ## Interpolation
 
+* [encoding](interpolation/encoding.md)
 * [helpers](interpolation/helpers.md)
+* [lists](interpolation/lists.md)
 * [maps](interpolation/maps.md)
+* [math](interpolation/math.md)
 * [strings](interpolation/strings.md)

docs/interpolation/encoding.md

@@ -0,0 +1,57 @@
+# Encoding
+
+## base64enc
+
+### Parameters
+
+* *item* - `string`- The value to encode
+
+### Returns
+
+* `string` - The base64 encoded representation of *item*
+
+### Examples
+
+```dart
+${base64enc("foo")} // Zm9v
+```
+
+---
+
+## base64dec
+
+### Parameters
+
+* *encoding* - `string`- A base64 encoded value
+
+### Returns
+
+* `string` - The decoded representation of *encoding*
+
+### Examples
+
+```dart
+${base64dec("Zm9v")} // foo
+```
+
+---
+
+## jsonencode
+
+### Parameters
+
+* *item* - `list/map/string`- The value to encode
+
+### Returns
+
+* `string` - The json representation of the value
+
+### Examples
+
+```dart
+${jsonencode("foo")} // foo
+```
+
+```dart
+${jsonencode(list("1", "2"))} // ["1", "2"]
+```

docs/interpolation/lists.md

@@ -0,0 +1,72 @@
+# Lists
+
+## list
+
+### Parameters
+
+* *value* - `any (variadic)` - The values that make up a list
+
+### Returns
+
+* `list` - The list made up of the arguments provided
+
+### Examples
+
+```dart
+${list("1", "2")} // ["1", "2"]
+```
+
+---
+
+## concat
+
+### Parameters
+
+* *lists* - `list (variadic)` - The lists to concat
+
+### Returns
+
+* `list` - The resulting list
+
+### Examples
+
+```dart
+${concat(list("1", "2"), list("3", "4"))} // ["1", "2", "3", "4"]
+```
+
+---
+
+## unique
+
+### Parameters
+
+* *list* - `list` - The lists to extract unique values from
+
+### Returns
+
+* `list` - The resulting list with the unique items
+
+### Examples
+
+```dart
+${unique(list("1", "2", "2", "1", "3"))} // ["3"]
+```
+
+---
+
+## join
+
+### Parameters
+
+* *sep* - `string` - The separator between each value
+* *values* - `list` - The list of values to join
+
+### Returns
+
+* `string` - The values joined by sep
+
+### Examples
+
+```dart
+${join(",", ["foo", "bar"])} // "foo,bar"
+```

docs/interpolation/math.md

@@ -0,0 +1,35 @@
+# Math
+
+## max
+
+### Parameters
+
+* *number* - `float (variadic)`- The values to find the max in
+
+### Returns
+
+* `float` - The largest number found
+
+### Examples
+
+```dart
+${max(2.1, 4.7, 4)} // 4.7
+```
+
+---
+
+## min
+
+### Parameters
+
+* *number* - `float (variadic)`- The values to find the min in
+
+### Returns
+
+* `float` - The smallest number found
+
+### Examples
+
+```dart
+${max(2.1, 4.7, 4)} // 2.1
+```

docs/interpolation/strings.md

@@ -35,25 +35,6 @@ ${upper("foo")} // FOO
 
 ---
 
-## join
-
-### Parameters
-
-* *sep* - `string` - The separator between each value
-* *values* - `list` - The list of values to join
-
-### Returns
-
-* `string` - The values joined by sep
-
-### Examples
-
-```dart
-${join(",", ["foo", "bar"])} // "foo,bar"
-```
-
----
-
 ## split
 
 ### Parameters

interpolation/funcs.go

@@ -10,25 +10,39 @@ import (
 
 // CoreFunctions are the custom functions for interpolation
 var CoreFunctions = map[string]ast.Function{
-	"lower":      interpolationFuncLower(),
-	"upper":      interpolationFuncUpper(),
-	"env":        interpolationFuncEnv(),
-	"join":       interpolationFuncJoin(),
-	"has":        interpolationFuncHas(),
-	"map":        interpolationFuncMap(),
-	"keys":       interpolationFuncKeys(),
-	"list":       interpolationFuncList(),
-	"concat":     interpolationFuncConcat(),
-	"replace":    interpolationFuncReplace(),
-	"max":        interpolationFuncMax(),
-	"min":        interpolationFuncMin(),
-	"contains":   interpolationFuncContains(),
-	"split":      interpolationFuncSplit(),
-	"length":     interpolationFuncLength(),
+	// helpers
+	"env":    interpolationFuncEnv(),
+	"length": interpolationFuncLength(),
+
+	// strings
+	"lower":    interpolationFuncLower(),
+	"upper":    interpolationFuncUpper(),
+	"replace":  interpolationFuncReplace(),
+	"contains": interpolationFuncContains(),
+	"split":    interpolationFuncSplit(),
+
+	// maps
+	"has":   interpolationFuncHas(),
+	"map":   interpolationFuncMap(),
+	"keys":  interpolationFuncKeys(),
+	"merge": interpolationFuncMerge(),
+	"pick":  interpolationFuncPick(),
+	"omit":  interpolationFuncOmit(),
+
+	// lists
+	"join":   interpolationFuncJoin(),
+	"list":   interpolationFuncList(),
+	"concat": interpolationFuncConcat(),
+	"unique": interpolationFuncUnique(),
+
+	// math
+	"max": interpolationFuncMax(),
+	"min": interpolationFuncMin(),
+
+	// encoding
 	"jsonencode": interpolationFuncJSONEncode(),
-	"pick":       interpolationFuncPick(),
-	"omit":       interpolationFuncOmit(),
-	"unique":     interpolationFuncUnique(),
+	"base64enc":  interpolationFuncBase64Encode(),
+	"base64dec":  interpolationFuncBase64Decode(),
 }
 
 // interpolationFuncEnv will extract a variable out of the env

interpolation/lists.go

@@ -2,6 +2,7 @@ package interpolation
 
 import (
 	"fmt"
+	"strings"
 
 	"reflect"
 
@@ -90,3 +91,26 @@ func interpolationFuncUnique() ast.Function {
 		},
 	}
 }
+
+// interpolationFuncJoin will join together a list of values with the provided separator
+func interpolationFuncJoin() ast.Function {
+	return ast.Function{
+		ArgTypes:   []ast.Type{ast.TypeString, ast.TypeList},
+		ReturnType: ast.TypeString,
+		Callback: func(inputs []interface{}) (interface{}, error) {
+			var list []string
+
+			for _, arg := range inputs[1].([]ast.Variable) {
+				if arg.Type != ast.TypeString {
+					return nil, fmt.Errorf(
+						"only works on string lists, this list contains elements of %s",
+						arg.Type.Printable(),
+					)
+				}
+				list = append(list, arg.Value.(string))
+			}
+
+			return strings.Join(list, inputs[0].(string)), nil
+		},
+	}
+}

interpolation/lists_test.go

@@ -122,3 +122,65 @@ func TestInterpolationFuncUnique(t *testing.T) {
 		})
 	}
 }
+
+func TestInterpolationFuncJoin(t *testing.T) {
+	testCases := []functionTestCase{
+		{
+			description: "Joins multiple values",
+			text:        `${join(",", i)}`,
+			expectation: "Foo,Bar",
+			vars: map[string]ast.Variable{
+				"i": ast.Variable{
+					Type: ast.TypeList,
+					Value: []ast.Variable{
+						{
+							Type:  ast.TypeString,
+							Value: "Foo",
+						},
+						{
+							Type:  ast.TypeString,
+							Value: "Bar",
+						},
+					},
+				},
+			},
+		},
+		{
+			description: "Bad variable length fails",
+			text:        `${join(",")}`,
+			expectation: "",
+			evalError:   true,
+		},
+		{
+			description: "Bad parse",
+			text:        `${join(",", [4]}`,
+			expectation: "",
+			parseError:  true,
+		},
+		{
+			description: "Bad array item",
+			text:        `${join(",", i)}`,
+			expectation: "Foo,Bar",
+			vars: map[string]ast.Variable{
+				"i": ast.Variable{
+					Type: ast.TypeList,
+					Value: []ast.Variable{
+						{
+							Type:  ast.TypeInt,
+							Value: 4,
+						},
+					},
+				},
+			},
+			evalError: true,
+		},
+	}
+
+	joinTestFunc := testInterpolationFunc(keyFuncs{"join": interpolationFuncJoin})
+
+	for _, tc := range testCases {
+		t.Run(tc.description, func(t *testing.T) {
+			joinTestFunc(t, tc)
+		})
+	}
+}

interpolation/strings.go

@@ -1,7 +1,6 @@
 package interpolation
 
 import (
-	"fmt"
 	"strings"
 
 	"github.com/hashicorp/hil"
@@ -32,29 +31,6 @@ func interpolationFuncUpper() ast.Function {
 	}
 }
 
-// interpolationFuncJoin will join together a list of values with the provided separator
-func interpolationFuncJoin() ast.Function {
-	return ast.Function{
-		ArgTypes:   []ast.Type{ast.TypeString, ast.TypeList},
-		ReturnType: ast.TypeString,
-		Callback: func(inputs []interface{}) (interface{}, error) {
-			var list []string
-
-			for _, arg := range inputs[1].([]ast.Variable) {
-				if arg.Type != ast.TypeString {
-					return nil, fmt.Errorf(
-						"only works on string lists, this list contains elements of %s",
-						arg.Type.Printable(),
-					)
-				}
-				list = append(list, arg.Value.(string))
-			}
-
-			return strings.Join(list, inputs[0].(string)), nil
-		},
-	}
-}
-
 // interpolationFuncSplit will split a string into substrings separated by a separator string.
 func interpolationFuncSplit() ast.Function {
 	return ast.Function{