Allow brackets inside Tekton expressions

We were previously using a regex to extract expressions within
TriggerBindings. The regex only extracted between the initial `$(`
and the first occurrence of the `)`. This meant that some valid
JSONPath expressions that contained brackets (e.g. filters) were
incorrectly extracted.

This commit fixes the issue by splitting the string on `$(` and then
extracting until the first "unbalanced" occurrence of `)`.

Fixes #365

Co-Authored-By: Andrea Frittoli <andrea.frittoli@uk.ibm.com>
Signed-off-by: Dibyo Mukherjee <dibyo@google.com>

docs/triggerbindings.md

@@ -50,6 +50,14 @@ These are invalid expressions:
 $({body) # INVALID - Ending curly brace absent
 ```
 
+If the `$()` is embedded inside another `$()` we will use the contents of the innermost
+`$()` as the JSONPath expression
+
+```shell script
+$($(body.b)) -> $(body.b)
+$($($(body.b))) -> $(body.b)
+```
+
 ### Examples
 
 ```shell script

pkg/template/event.go

@@ -88,7 +88,7 @@ func applyEventValuesToParams(params []pipelinev1.Param, body []byte, header htt
 	for idx, p := range params {
 		pValue := p.Value.StringVal
 		// Find all expressions wrapped in $() from the value
-		expressions := tektonVar.FindAllString(pValue, -1)
+		expressions := findTektonExpressions(pValue)
 		for _, expr := range expressions {
 			val, err := ParseJSONPath(event, expr)
 			if err != nil {

pkg/template/event_test.go

@@ -150,6 +150,16 @@ func TestApplyEventValuesToParams(t *testing.T) {
 			bldr.Param("foo", `val1`),
 			bldr.Param("bar", `val2`),
 		},
+	}, {
+		name:   "Array filters",
+		body:   json.RawMessage(`{"child":[{"a": "b", "w": "1"}, {"a": "c", "w": "2"}, {"a": "d", "w": "3"}]}`),
+		params: []pipelinev1.Param{bldr.Param("a", "$(body.child[?(@.a == 'd')].w)")},
+		want:   []pipelinev1.Param{bldr.Param("a", "3")},
+	}, {
+		name:   "filters + multiple JSONPath expressions",
+		body:   json.RawMessage(`{"child":[{"a": "b", "w": "1"}, {"a": "c", "w": "2"}, {"a": "d", "w": "3"}]}`),
+		params: []pipelinev1.Param{bldr.Param("a", "$(body.child[?(@.a == 'd')].w) : $(body.child[0].a)")},
+		want:   []pipelinev1.Param{bldr.Param("a", "3 : b")},
 	}}
 
 	for _, tt := range tests {

pkg/template/jsonpath.go

@@ -146,3 +146,37 @@ func relaxedJSONPathExpression(pathExpression string) (string, error) {
 func isTektonExpr(expr string) bool {
 	return tektonVar.MatchString(expr)
 }
+
+// findTektonExpressions searches for and returns a slice of
+// all substrings that are wrapped in $()
+func findTektonExpressions(in string) []string {
+	results := []string{}
+
+	// No expressions to return
+	if !strings.Contains(in, "$(") {
+		return results
+	}
+	// Splits string on $( to find potential Tekton expressions
+	maybeExpressions := strings.Split(in, "$(")
+	for _, e := range maybeExpressions[1:] { // Split always returns at least one element
+		// Iterate until we find the first unbalanced )
+		numOpenBrackets := 0
+		for i, ch := range e {
+			switch ch {
+			case '(':
+				numOpenBrackets++
+			case ')':
+				numOpenBrackets--
+				if numOpenBrackets < 0 {
+					results = append(results, fmt.Sprintf("$(%s)", e[:i]))
+				}
+			default:
+				continue
+			}
+			if numOpenBrackets < 0 {
+				break
+			}
+		}
+	}
+	return results
+}

pkg/template/jsonpath_test.go

@@ -83,6 +83,11 @@ func TestParseJSONPath(t *testing.T) {
 		in:   `{"body":["", null, "thing"]}`,
 		expr: "$(body[:2])",
 		want: `["", null]`,
+	}, {
+		name: "Array filters",
+		in:   `{"body":{"child":[{"a": "b", "w": "1"}, {"a": "c", "w": "2"}, {"a": "d", "w": "3"}]}}`,
+		expr: "$(body.child[?(@.a == 'd')].w)",
+		want: "3",
 	}}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -213,3 +218,60 @@ func TestRelaxedJSONPathExpression_Error(t *testing.T) {
 		})
 	}
 }
+
+func TestFindTektonExpressions(t *testing.T) {
+	tcs := []struct {
+		in   string
+		want []string
+	}{{
+		in:   "$(body.blah)",
+		want: []string{"$(body.blah)"},
+	}, {
+		in:   "$(body.blah)-$(header.*)",
+		want: []string{"$(body.blah)", "$(header.*)"},
+	}, {
+		in:   "start:$(body.blah)//middle//$(header.one)-end",
+		want: []string{"$(body.blah)", "$(header.one)"},
+	}, {
+		in:   "start:$(body.[?(@.a == 'd')])-$(body.another-one)",
+		want: []string{"$(body.[?(@.a == 'd')])", "$(body.another-one)"},
+	}, {
+		in:   "$(this)-$(not-this",
+		want: []string{"$(this)"},
+	}, {
+		in:   "$body.)",
+		want: []string{},
+	}, {
+		in:   "($(body.blah))-and-$(body.foo)",
+		want: []string{"$(body.blah)", "$(body.foo)"},
+	}, {
+		in:   "(staticvalue)$(body.blah)",
+		want: []string{"$(body.blah)"},
+	}, {
+		in:   "asd)$(asd",
+		want: []string{},
+	}, {
+		in:   "onlystatic",
+		want: []string{},
+	}, {
+		in:   "",
+		want: []string{},
+	}, {
+		in:   "$())))",
+		want: []string{"$()"},
+	}, {
+		in:   "$($())",
+		want: []string{"$()"},
+	}, {
+		in:   "$($($(blahblah)))",
+		want: []string{"$(blahblah)"},
+	}}
+
+	for _, tc := range tcs {
+		t.Run(tc.in, func(t *testing.T) {
+			if diff := cmp.Diff(tc.want, findTektonExpressions(tc.in)); diff != "" {
+				t.Fatalf("error -want/+got: %s", diff)
+			}
+		})
+	}
+}