Merge pull request #38 from filefrog/resolver

Handle recursive cases for (( grab )) and (( concat ))

Author: geofffranks

assets/concat/loop.yml

@@ -0,0 +1,2 @@
+a: (( concat "a" b ))
+b: (( concat a "b" ))

assets/concat/multi.yml

@@ -0,0 +1,5 @@
+# foo shoud be 'quux.bar.baz.foo'
+foo: (( concat baz ".foo" ))
+bar: (( concat quux ".bar" ))
+baz: (( concat bar ".baz" ))
+quux: "quux"

assets/dereference/multi.yml

@@ -0,0 +1,4 @@
+name1: (( grab name2 ))
+name2: (( grab name3 ))
+name3: (( grab name4 ))
+name4: "name"

concat.go

@@ -21,38 +21,76 @@ type Token struct {
 // Concatenator is an implementation of PostProcessor to de-reference (( grab me.data )) calls
 type Concatenator struct {
 	root map[interface{}]interface{}
+	ttl  int
 }
 
 // Action returns the Action string for the Concatenator
 func (s Concatenator) Action() string {
 	return "concatenator"
 }
 
-// PostProcess - resolves a value by seeing if it matches (( grab me.data )) and retrieves me.data's value
-func (s Concatenator) PostProcess(o interface{}, node string) (interface{}, string, error) {
+// parseConcatOp - determine if an object is a (( concat ... )) call
+func parseConcatOp(o interface{}) (bool, string) {
 	if o != nil && reflect.TypeOf(o).Kind() == reflect.String {
 		re := regexp.MustCompile(`^\Q((\E\s*concat\s+(.+)\s*\Q))\E$`)
 		if re.MatchString(o.(string)) {
 			keys := re.FindStringSubmatch(o.(string))
+			return true, keys[1]
+		}
+	}
+	return false, ""
+}
+
+// resolve - resolves a set of tokens (literals or references), co-recursively with resolveKey()
+func (s Concatenator) resolve(node string, tokens []Token) (string, error) {
+	str := ""
 
-			tokens := parseWords(keys[1])
-			str := ""
-			for _, token := range tokens {
-				if token.Type == TokenLiteral {
-					str += token.Value
-				} else {
-					DEBUG("%s: resolving from %s", node, token.Value)
-					val, err := resolveNode(token.Value, s.root)
-					if err != nil {
-						return nil, "error", fmt.Errorf("%s: Unable to resolve `%s`: `%s", node, token.Value, err.Error())
-					}
-					// error if val is not a string
-					str += val.(string)
-				}
+	for _, token := range tokens {
+		if token.Type == TokenLiteral {
+			str += token.Value
+		} else {
+			DEBUG("%s: resolving from %s", node, token.Value)
+			val, err := s.resolveKey(token.Value)
+			if err != nil {
+				return "", err
 			}
+			str += val
+		}
+	}
+	return str, nil
+}
 
-			return str, "replace", nil
+// resolveKey - resolves a single key reference, co-recursively with resolve()
+func (s Concatenator) resolveKey(key string) (string, error) {
+	val, err := resolveNode(key, s.root)
+	if err != nil {
+		return "", fmt.Errorf("Unable to resolve `%s`: %s", key, err)
+	}
+
+	if should, args := parseConcatOp(val); should {
+		if s.ttl -= 1; s.ttl <= 0 {
+			return "", fmt.Errorf("possible recursion detected in call to (( concat ))")
+		}
+		str, err := s.resolve(key, parseWords(args))
+		s.ttl += 1
+		if err != nil {
+			return "", err
+		}
+		return str, nil
+	}
+	// error if val is not a string
+	return val.(string), err
+}
+
+// PostProcess - resolves a value by seeing if it matches (( concat me.data )) and retrieves me.data's value
+func (s Concatenator) PostProcess(o interface{}, node string) (interface{}, string, error) {
+	if should, args := parseConcatOp(o); should {
+		s.ttl = 64
+		str, err := s.resolve(node, parseWords(args))
+		if err != nil {
+			return nil, "error", fmt.Errorf("%s: %s", node, err.Error())
 		}
+		return str, "replace", nil
 	}
 
 	return nil, "ignore", nil

dereferencer.go

@@ -4,51 +4,83 @@ import (
 	"fmt"
 	"reflect"
 	"regexp"
+	"strings"
 )
 
 // DeReferencer is an implementation of PostProcessor to de-reference (( grab me.data )) calls
 type DeReferencer struct {
 	root map[interface{}]interface{}
+	ttl  int
 }
 
-// PostProcess - resolves a value by seeing if it matches (( grab me.data )) and retrieves me.data's value
-func (d DeReferencer) PostProcess(o interface{}, node string) (interface{}, string, error) {
+// parseGrabOp - determine if an object is a (( grab ... )) call
+func parseGrabOp(o interface{}) (bool, string) {
 	if o != nil && reflect.TypeOf(o).Kind() == reflect.String {
-		re := regexp.MustCompile("^\\Q((\\E\\s*grab\\s+(.+?)\\s*\\Q))\\E$")
+		re := regexp.MustCompile(`^\Q((\E\s*grab\s+(.+)\s*\Q))\E$`)
 		if re.MatchString(o.(string)) {
 			keys := re.FindStringSubmatch(o.(string))
-			if keys[1] != "" {
-				wsSquasher := regexp.MustCompile("\\s+")
-				targets := wsSquasher.Split(keys[1], -1)
-				if len(targets) <= 1 {
-					DEBUG("%s: dereferencing value '%s'", node, targets[0])
-					val, err := resolveNode(targets[0], d.root)
-					if err != nil {
-						return nil, "error", fmt.Errorf("%s: Unable to resolve `%s`: `%s", node, targets[0], err.Error())
-					}
-					DEBUG("%s: setting to %#v", node, val)
-					return val, "replace", nil
-				}
-				val := []interface{}{}
-				for _, target := range targets {
-					DEBUG("%s: dereferencing value '%s'", node, target)
-					v, err := resolveNode(target, d.root)
-					if err != nil {
-						return nil, "error", fmt.Errorf("%s: Unable to resolve `%s`: `%s", node, target, err.Error())
-					}
-					if reflect.TypeOf(v).Kind() == reflect.Slice {
-						for i := 0; i < reflect.ValueOf(v).Len(); i++ {
-							val = append(val, reflect.ValueOf(v).Index(i).Interface())
-						}
-					} else {
-						val = append(val, v)
-					}
-				}
-				DEBUG("%s: setting to %#v", node, val)
-				return val, "replace", nil
+			return true, keys[1]
+		}
+	}
+	return false, ""
+}
+
+// resolve - resolves a set of tokens (literals or references), co-recursively with resolveKey()
+func (d DeReferencer) resolve(node string, args string) (interface{}, error) {
+	DEBUG("%s: resolving (( grab %s )))", node, args)
+	re := regexp.MustCompile(`\s+`)
+	targets := re.Split(strings.Trim(args, " \t\r\n"), -1)
+
+	if len(targets) <= 1 {
+		val, err := d.resolveKey(targets[0])
+		return val, err
+	}
+	val := []interface{}{}
+	for _, target := range targets {
+		v, err := d.resolveKey(target)
+		if err != nil {
+			return nil, err
+		}
+		if v != nil && reflect.TypeOf(v).Kind() == reflect.Slice {
+			for i := 0; i < reflect.ValueOf(v).Len(); i++ {
+				val = append(val, reflect.ValueOf(v).Index(i).Interface())
 			}
+		} else {
+			val = append(val, v)
+		}
+	}
+	return val, nil
+}
+
+// resolveKey - resolves a single key reference, co-recursively with resolve()
+func (d DeReferencer) resolveKey(key string) (interface{}, error) {
+	DEBUG("  -> resolving reference to `%s`", key)
+	val, err := resolveNode(key, d.root)
+	if err != nil {
+		return nil, fmt.Errorf("Unable to resolve `%s`: `%s", key, err)
+	}
+
+	if should, args := parseGrabOp(val); should {
+		if d.ttl -= 1; d.ttl <= 0 {
+			return "", fmt.Errorf("possible recursion detected in call to (( grab ))")
 		}
+		val, err = d.resolve(key, args)
+		d.ttl += 1
+		return val, err
 	}
+	return val, nil
+}
 
+// PostProcess - resolves a value by seeing if it matches (( grab me.data )) and retrieves me.data's value
+func (d DeReferencer) PostProcess(o interface{}, node string) (interface{}, string, error) {
+	if should, args := parseGrabOp(o); should {
+		d.ttl = 64
+		val, err := d.resolve(node, args)
+		if err != nil {
+			return nil, "error", fmt.Errorf("%s: %s", node, err.Error())
+		}
+		DEBUG("%s: setting to %#v", node, val)
+		return val, "replace", nil
+	}
 	return nil, "ignore", nil
 }

main_test.go

@@ -329,6 +329,19 @@ properties:
 			So(stderr, ShouldEqual, "")
 			So(stdout, ShouldEqual, `value: null
 
+`)
+		})
+		Convey("can dereference nestedly", func() {
+			os.Args = []string{"spruce", "merge", "assets/dereference/multi.yml"}
+			stdout = ""
+			stderr = ""
+			main()
+			So(stderr, ShouldEqual, "")
+			So(stdout, ShouldEqual, `name1: name
+name2: name
+name3: name
+name4: name
+
 `)
 		})
 		Convey("static_ips() failures return errors to the user", func() {
@@ -421,6 +434,27 @@ storage: 4096
 			So(stderr, ShouldStartWith, "$.ident: Unable to resolve `local.sites.[42].uuid`:")
 			So(stdout, ShouldEqual, "")
 		})
+		Convey("string concatentation handles multiple levels of reference", func() {
+			os.Args = []string{"spruce", "merge", "assets/concat/multi.yml"}
+			stdout = ""
+			stderr = ""
+			main()
+			So(stderr, ShouldEqual, "")
+			So(stdout, ShouldEqual, `bar: quux.bar
+baz: quux.bar.baz
+foo: quux.bar.baz.foo
+quux: quux
+
+`)
+			Convey("string concatenation handles infinite loop self-reference", func() {
+				os.Args = []string{"spruce", "merge", "assets/concat/loop.yml"}
+				stdout = ""
+				stderr = ""
+				main()
+				So(stderr, ShouldContainSubstring, "possible recursion detected in call to (( concat ))")
+				So(stdout, ShouldEqual, "")
+			})
+		})
 	})
 }