config: Add "flatten" interpolation function

This function turns a list of lists or any arbitrary number of nested
lists into a flat list of primitive values.

config/interpolate_funcs.go

@@ -76,6 +76,7 @@ func Funcs() map[string]ast.Function {
 		"element":      interpolationFuncElement(),
 		"file":         interpolationFuncFile(),
 		"matchkeys":    interpolationFuncMatchKeys(),
+		"flatten":      interpolationFuncFlatten(),
 		"floor":        interpolationFuncFloor(),
 		"format":       interpolationFuncFormat(),
 		"formatlist":   interpolationFuncFormatList(),
@@ -1453,3 +1454,30 @@ func interpolationFuncSubstr() ast.Function {
 		},
 	}
 }
+
+// Flatten until it's not ast.TypeList
+func flattener(finalList []ast.Variable, flattenList []ast.Variable) []ast.Variable {
+	for _, val := range flattenList {
+		if val.Type == ast.TypeList {
+			finalList = flattener(finalList, val.Value.([]ast.Variable))
+		} else {
+			finalList = append(finalList, val)
+		}
+	}
+	return finalList
+}
+
+// Flatten to single list
+func interpolationFuncFlatten() ast.Function {
+	return ast.Function{
+		ArgTypes:   []ast.Type{ast.TypeList},
+		ReturnType: ast.TypeList,
+		Variadic:   false,
+		Callback: func(args []interface{}) (interface{}, error) {
+			inputList := args[0].([]ast.Variable)
+
+			var outputList []ast.Variable
+			return flattener(outputList, inputList), nil
+		},
+	}
+}

config/interpolate_funcs_test.go

@@ -2503,3 +2503,49 @@ func TestInterpolateFuncBcrypt(t *testing.T) {
 		},
 	})
 }
+
+func TestInterpolateFuncFlatten(t *testing.T) {
+	testFunction(t, testFunctionConfig{
+		Cases: []testFunctionCase{
+			// empty string within array
+			{
+				`${flatten(split(",", "a,,b"))}`,
+				[]interface{}{"a", "", "b"},
+				false,
+			},
+
+			// typical array
+			{
+				`${flatten(split(",", "a,b,c"))}`,
+				[]interface{}{"a", "b", "c"},
+				false,
+			},
+
+			// empty array
+			{
+				`${flatten(split(",", ""))}`,
+				[]interface{}{""},
+				false,
+			},
+
+			// list of lists
+			{
+				`${flatten(list(list("a"), list("b")))}`,
+				[]interface{}{"a", "b"},
+				false,
+			},
+			// list of lists of lists
+			{
+				`${flatten(list(list("a"), list(list("b","c"))))}`,
+				[]interface{}{"a", "b", "c"},
+				false,
+			},
+			// list of strings
+			{
+				`${flatten(list("a", "b", "c"))}`,
+				[]interface{}{"a", "b", "c"},
+				false,
+			},
+		},
+	})
+}

website/docs/configuration/interpolation.html.md

@@ -232,6 +232,10 @@ The supported built-in functions are:
   * `floor(float)` - Returns the greatest integer value less than or equal to
       the argument.
 
+  * `flatten(list of lists)` - Flattens lists of lists down to a flat list of
+       primitive values, eliminating any nested lists recursively. Examples:
+       * `flatten(data.github_user.user.*.gpg_keys)`
+
   * `format(format, args, ...)` - Formats a string according to the given
       format. The syntax for the format is standard `sprintf` syntax.
       Good documentation for the syntax can be [found here](https://golang.org/pkg/fmt/).