Added support for dereferenced map properties

pkg/exprparser/functions_test.go

@@ -31,6 +31,10 @@ func TestFunctionContains(t *testing.T) {
 		{`contains(fromJSON('[3.14,"second"]'), 3.14) }}`, true, "contains-item-number-number"},
 		{`contains(fromJSON('["","second"]'), fromJSON('[]')) }}`, false, "contains-item-str-arr"},
 		{`contains(fromJSON('["","second"]'), fromJSON('{}')) }}`, false, "contains-item-str-obj"},
+		{`contains(fromJSON('[{ "first": { "result": "success" }},{ "second": { "result": "success" }}]').first.result, 'success') }}`, true, "multiple-contains-item"},
+		{`contains(fromJSON('[{ "result": "success" },{ "result": "failure" }]').*.result, 'failure') }}`, true, "multiple-contains-dereferenced-failure-item"},
+		{`contains(fromJSON('[{ "result": "failure" },{ "result": "success" }]').*.result, 'success') }}`, true, "multiple-contains-dereferenced-success-item"},
+		{`contains(fromJSON('[{ "result": "failure" },{ "result": "success" }]').*.result, 'notthere') }}`, false, "multiple-contains-dereferenced-missing-item"},
 	}
 
 	env := &EvaluationEnvironment{}
@@ -249,3 +253,23 @@ func TestFunctionFormat(t *testing.T) {
 		})
 	}
 }
+
+func TestMapContains(t *testing.T) {
+	env := &EvaluationEnvironment{}
+
+	env.Needs = map[string]Needs{
+		"first-job": {
+			Outputs: map[string]string{},
+			Result:  "success",
+		},
+		"second-job": {
+			Outputs: map[string]string{},
+			Result:  "failure",
+		},
+	}
+
+	output, err := NewInterpeter(env, Config{}).Evaluate("contains(needs.*.result, 'failure')", DefaultStatusCheckNone)
+	assert.Nil(t, err)
+
+	assert.Equal(t, true, output)
+}

pkg/exprparser/interpreter.go

@@ -229,7 +229,12 @@ func (impl *interperterImpl) evaluateObjectDeref(objectDerefNode *actionlint.Obj
 		return nil, err
 	}
 
-	return impl.getPropertyValue(reflect.ValueOf(left), objectDerefNode.Property)
+	_, receiverIsDeref := objectDerefNode.Receiver.(*actionlint.ArrayDerefNode)
+	if receiverIsDeref {
+		return impl.getPropertyValueDereferenced(reflect.ValueOf(left), objectDerefNode.Property)
+	} else {
+		return impl.getPropertyValue(reflect.ValueOf(left), objectDerefNode.Property)
+	}
 }
 
 func (impl *interperterImpl) evaluateArrayDeref(arrayDerefNode *actionlint.ArrayDerefNode) (interface{}, error) {
@@ -312,6 +317,34 @@ func (impl *interperterImpl) getPropertyValue(left reflect.Value, property strin
 	return nil, nil
 }
 
+func (impl *interperterImpl) getPropertyValueDereferenced(left reflect.Value, property string) (value interface{}, err error) {
+	switch left.Kind() {
+	case reflect.Ptr:
+		return impl.getPropertyValue(left, property)
+
+	case reflect.Struct:
+		return impl.getPropertyValue(left, property)
+	case reflect.Map:
+		iter := left.MapRange()
+
+		var values []interface{}
+		for iter.Next() {
+			value, err := impl.getPropertyValue(iter.Value(), property)
+			if err != nil {
+				return nil, err
+			}
+
+			values = append(values, value)
+		}
+
+		return values, nil
+	case reflect.Slice:
+		return impl.getPropertyValue(left, property)
+	}
+
+	return nil, nil
+}
+
 func (impl *interperterImpl) getMapValue(value reflect.Value) (interface{}, error) {
 	if value.Kind() == reflect.Ptr {
 		return impl.getMapValue(value.Elem())

pkg/exprparser/interpreter_test.go

@@ -562,6 +562,8 @@ func TestContexts(t *testing.T) {
 		{"matrix.os", "Linux", "matrix-context"},
 		{"needs.job-id.outputs.output-name", "value", "needs-context"},
 		{"needs.job-id.result", "success", "needs-context"},
+		{"contains(needs.*.result, 'success')", true, "needs-wildcard-context-contains-success"},
+		{"contains(needs.*.result, 'failure')", false, "needs-wildcard-context-contains-failure"},
 		{"inputs.name", "value", "inputs-context"},
 	}
 
@@ -610,6 +612,12 @@ func TestContexts(t *testing.T) {
 				},
 				Result: "success",
 			},
+			"another-job-id": {
+				Outputs: map[string]string{
+					"output-name": "value",
+				},
+				Result: "success",
+			},
 		},
 		Inputs: map[string]interface{}{
 			"name": "value",