Array variables PoC

Author: boguszj

arraytemplate/array_template.go

@@ -0,0 +1,55 @@
+package arraytemplate
+
+import (
+	"fmt"
+	"regexp"
+)
+
+type Mapping func(string) (string, bool)
+
+const (
+	maxArraySize = 100
+
+	substitution = "[_a-zA-Z][_a-zA-Z0-9]*"
+)
+
+var (
+	rawPattern = fmt.Sprintf(
+		"^\\$(?:(%s)\\[\\*]|{(%s)\\[\\*]})$",
+		substitution,
+		substitution,
+	)
+
+	ArraySubstitutionPattern = regexp.MustCompile(rawPattern)
+)
+
+func Substitute(template string, mapping Mapping) ([]string, error) {
+	matches := ArraySubstitutionPattern.FindStringSubmatch(template)
+	prefix, err := findPrefix(matches)
+
+	if err != nil {
+		return nil, fmt.Errorf("invalid array template: %s", template)
+	}
+
+	arr := make([]string, 0, maxArraySize)
+	for i := 0; i < maxArraySize; i++ {
+		key := fmt.Sprintf("%s[%d]", prefix, i)
+		value, ok := mapping(key)
+		if !ok {
+			break
+		}
+		arr = append(arr, value)
+	}
+
+	return arr, nil
+}
+
+func findPrefix(matches []string) (string, error) {
+	for _, match := range matches[1:] {
+		if match != "" {
+			return match, nil
+		}
+	}
+
+	return "", fmt.Errorf("could not find a match")
+}

interpolation/interpolation.go

@@ -19,7 +19,9 @@ package interpolation
 import (
 	"errors"
 	"fmt"
+	"github.com/compose-spec/compose-go/v2/arraytemplate"
 	"os"
+	"reflect"
 
 	"github.com/compose-spec/compose-go/v2/template"
 	"github.com/compose-spec/compose-go/v2/tree"
@@ -32,7 +34,12 @@ type Options struct {
 	// TypeCastMapping maps key paths to functions to cast to a type
 	TypeCastMapping map[tree.Path]Cast
 	// Substitution function to use
-	Substitute func(string, template.Mapping) (string, error)
+	Substitute func(string, LookupValue) (*SubstitutionResult, error)
+}
+
+type SubstitutionResult struct {
+	String string
+	Array  []string
 }
 
 // LookupValue is a function which maps from variable names to values.
@@ -53,7 +60,7 @@ func Interpolate(config map[string]interface{}, opts Options) (map[string]interf
 		opts.TypeCastMapping = make(map[tree.Path]Cast)
 	}
 	if opts.Substitute == nil {
-		opts.Substitute = template.Substitute
+		opts.Substitute = DefaultSubstitute
 	}
 
 	out := map[string]interface{}{}
@@ -69,18 +76,30 @@ func Interpolate(config map[string]interface{}, opts Options) (map[string]interf
 	return out, nil
 }
 
+func DefaultSubstitute(t string, lookup LookupValue) (*SubstitutionResult, error) {
+	if (arraytemplate.ArraySubstitutionPattern).MatchString(t) {
+		arr, err := arraytemplate.Substitute(t, arraytemplate.Mapping(lookup))
+		return &SubstitutionResult{Array: arr}, err
+	}
+	str, err := template.Substitute(t, template.Mapping(lookup))
+	return &SubstitutionResult{String: str}, err
+}
+
 func recursiveInterpolate(value interface{}, path tree.Path, opts Options) (interface{}, error) {
 	switch value := value.(type) {
 	case string:
-		newValue, err := opts.Substitute(value, template.Mapping(opts.LookupValue))
+		result, err := opts.Substitute(value, opts.LookupValue)
 		if err != nil {
 			return value, newPathError(path, err)
 		}
+		if result.Array != nil {
+			return result.Array, nil
+		}
 		caster, ok := opts.getCasterForPath(path)
 		if !ok {
-			return newValue, nil
+			return result.String, nil
 		}
-		casted, err := caster(newValue)
+		casted, err := caster(result.String)
 		if err != nil {
 			return casted, newPathError(path, fmt.Errorf("failed to cast to expected type: %w", err))
 		}
@@ -98,13 +117,19 @@ func recursiveInterpolate(value interface{}, path tree.Path, opts Options) (inte
 		return out, nil
 
 	case []interface{}:
-		out := make([]interface{}, len(value))
-		for i, elem := range value {
+		out := make([]interface{}, 0, len(value))
+		for _, elem := range value {
 			interpolatedElem, err := recursiveInterpolate(elem, path.Next(tree.PathMatchList), opts)
 			if err != nil {
 				return nil, err
 			}
-			out[i] = interpolatedElem
+			if isStringSlice(interpolatedElem) {
+				for _, nestedElem := range interpolatedElem.([]string) {
+					out = append(out, nestedElem)
+				}
+			} else {
+				out = append(out, interpolatedElem)
+			}
 		}
 		return out, nil
 
@@ -113,6 +138,20 @@ func recursiveInterpolate(value interface{}, path tree.Path, opts Options) (inte
 	}
 }
 
+func isStringSlice(value interface{}) bool {
+	if value == nil {
+		return false
+	}
+	t := reflect.TypeOf(value)
+	if t.Kind() != reflect.Slice {
+		return false
+	}
+	if t.Elem().Kind() != reflect.String {
+		return false
+	}
+	return true
+}
+
 func newPathError(path tree.Path, err error) error {
 	var ite *template.InvalidTemplateError
 	switch {

interpolation/interpolation_test.go

@@ -27,9 +27,12 @@ import (
 )
 
 var defaults = map[string]string{
-	"USER":  "jenny",
-	"FOO":   "bar",
-	"count": "5",
+	"USER":   "jenny",
+	"FOO":    "bar",
+	"count":  "5",
+	"ARR[0]": "zero",
+	"ARR[1]": "one",
+	"ARR[2]": "two",
 }
 
 func defaultMapping(name string) (string, bool) {
@@ -40,8 +43,11 @@ func defaultMapping(name string) (string, bool) {
 func TestInterpolate(t *testing.T) {
 	services := map[string]interface{}{
 		"servicea": map[string]interface{}{
-			"image":   "example:${USER}",
-			"volumes": []interface{}{"$FOO:/target"},
+			"image": "example:${USER}",
+			"volumes": []interface{}{
+				"$FOO:/target",
+				"$ARR[*]",
+			},
 			"logging": map[string]interface{}{
 				"driver": "${FOO}",
 				"options": map[string]interface{}{
@@ -52,8 +58,13 @@ func TestInterpolate(t *testing.T) {
 	}
 	expected := map[string]interface{}{
 		"servicea": map[string]interface{}{
-			"image":   "example:jenny",
-			"volumes": []interface{}{"bar:/target"},
+			"image": "example:jenny",
+			"volumes": []interface{}{
+				"bar:/target",
+				"zero",
+				"one",
+				"two",
+			},
 			"logging": map[string]interface{}{
 				"driver": "bar",
 				"options": map[string]interface{}{

loader/loader.go

@@ -35,7 +35,6 @@ import (
 	"github.com/compose-spec/compose-go/v2/override"
 	"github.com/compose-spec/compose-go/v2/paths"
 	"github.com/compose-spec/compose-go/v2/schema"
-	"github.com/compose-spec/compose-go/v2/template"
 	"github.com/compose-spec/compose-go/v2/transform"
 	"github.com/compose-spec/compose-go/v2/tree"
 	"github.com/compose-spec/compose-go/v2/types"
@@ -351,7 +350,7 @@ func loadModelWithContext(ctx context.Context, configDetails *types.ConfigDetail
 func toOptions(configDetails *types.ConfigDetails, options []func(*Options)) *Options {
 	opts := &Options{
 		Interpolate: &interp.Options{
-			Substitute:      template.Substitute,
+			Substitute:      interp.DefaultSubstitute,
 			LookupValue:     configDetails.LookupEnv,
 			TypeCastMapping: interpolateTypeCastMapping,
 		},