feat: support reference var in rule files (#97)

Author: renyijiu

pkg/rule_engine/action.go

@@ -70,6 +70,12 @@ func NewAction(
 				return nil, errors.Errorf("failed to compile argument %s: %v", k, err)
 			}
 			kwargs[k] = evaluator
+		case []string:
+			evaluator, err := compileArrayExpr(env, val)
+			if err != nil {
+				return nil, errors.Errorf("failed to compile array argument %s: %v", k, err)
+			}
+			kwargs[k] = evaluator
 		case map[string]interface{}:
 			evaluator, err := compileDictExpr(env, val)
 			if err != nil {
@@ -203,6 +209,85 @@ func compileDictExpr(env *cel.Env, dict map[string]interface{}) (expressionEvalu
 	}, nil
 }
 
+// compileArrayExpr compiles expressions in a string array.
+// Each array element can contain embedded CEL expressions like "{scope.files}".
+func compileArrayExpr(env *cel.Env, arr []string) (expressionEvaluator, error) {
+	compiledEvaluators := make([]expressionEvaluator, len(arr))
+
+	for i, element := range arr {
+		pattern := regexp.MustCompile(`\{\s*(.*?)\s*}`)
+		matches := pattern.FindAllStringSubmatch(element, -1)
+
+		switch {
+		case len(matches) == 0:
+			// If no expressions found, return the constant string
+			compiledEvaluators[i] = func(map[string]interface{}) (interface{}, error) {
+				return element, nil
+			}
+		case len(matches) == 1 && matches[0][0] == element:
+			// Special case: element is pure expression like "{scope.files}"
+			// Try to evaluate it as an array expression first
+			ast, issues := env.Compile(matches[0][1])
+			if issues != nil && issues.Err() != nil {
+				return nil, errors.Errorf("failed to compile array expression '%s': %v", matches[0][1], issues.Err())
+			}
+			program, err := env.Program(ast)
+			if err != nil {
+				return nil, errors.Errorf("failed to create program for array expression '%s': %v", matches[0][1], err)
+			}
+
+			compiledEvaluators[i] = func(activation map[string]interface{}) (interface{}, error) {
+				val, _, err := program.Eval(activation)
+				if err != nil {
+					return nil, errors.Errorf("failed to evaluate array expression '%s': %v", matches[0][1], err)
+				}
+				return val.Value(), nil
+			}
+		default:
+			// Element contains mixed content with expressions, treat as string
+			evaluator, err := compileEmbeddedExpr(env, element)
+			if err != nil {
+				return nil, errors.Errorf("failed to compile embedded expression in array element: %v", err)
+			}
+			compiledEvaluators[i] = evaluator
+		}
+	}
+
+	return func(activation map[string]interface{}) (interface{}, error) {
+		result := make([]string, 0)
+
+		for _, evaluator := range compiledEvaluators {
+			value, err := evaluator(activation)
+			if err != nil {
+				return nil, err
+			}
+
+			switch v := value.(type) {
+			case []interface{}:
+				// If the expression evaluates to an array, append all elements
+				for _, item := range v {
+					result = append(result, fmt.Sprintf("%v", item))
+				}
+			case []string:
+				// If it's already a string array, append directly
+				result = append(result, v...)
+			case string:
+				// Single string value
+				if v != "" {
+					result = append(result, v)
+				}
+			default:
+				// Convert other types to string
+				if str := fmt.Sprintf("%v", v); str != "" {
+					result = append(result, str)
+				}
+			}
+		}
+
+		return result, nil
+	}, nil
+}
+
 func (a *Action) String() string {
 	return fmt.Sprintf("Action(%s)%v", a.Name, a.RawKwargs)
 }

pkg/rule_engine/action_test.go

@@ -182,3 +182,107 @@ func TestActionValidation(t *testing.T) {
 		})
 	}
 }
+
+func TestActionArrayExpansion(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		rawKwargs  map[string]interface{}
+		activation map[string]interface{}
+		expected   map[string]interface{}
+		expectErr  bool
+	}{
+		{
+			name: "array with scope.files expansion",
+			rawKwargs: map[string]interface{}{
+				"extra_files": []string{"/static/file1.txt", "{scope.files}", "/static/file2.txt"},
+			},
+			activation: map[string]interface{}{
+				"scope": map[string]interface{}{
+					"files": []string{"/dynamic/file1.txt", "/dynamic/file2.txt"},
+				},
+			},
+			expected: map[string]interface{}{
+				"extra_files": []string{"/static/file1.txt", "/dynamic/file1.txt", "/dynamic/file2.txt", "/static/file2.txt"},
+			},
+			expectErr: false,
+		},
+		{
+			name: "array with mixed expressions",
+			rawKwargs: map[string]interface{}{
+				"files": []string{"{scope.code}_prefix.txt", "{scope.files}", "suffix_{scope.version}.log"},
+			},
+			activation: map[string]interface{}{
+				"scope": map[string]interface{}{
+					"code":    "ABC123",
+					"version": "v1.0",
+					"files":   []string{"data1.bin", "data2.bin"},
+				},
+			},
+			expected: map[string]interface{}{
+				"files": []string{"ABC123_prefix.txt", "data1.bin", "data2.bin", "suffix_v1.0.log"},
+			},
+			expectErr: false,
+		},
+		{
+			name: "empty array expansion",
+			rawKwargs: map[string]interface{}{
+				"files": []string{"{scope.files}"},
+			},
+			activation: map[string]interface{}{
+				"scope": map[string]interface{}{
+					"files": []string{},
+				},
+			},
+			expected: map[string]interface{}{
+				"files": []string{},
+			},
+			expectErr: false,
+		},
+		{
+			name: "no array expansion - static files only",
+			rawKwargs: map[string]interface{}{
+				"files": []string{"/path/file1.txt", "/path/file2.txt"},
+			},
+			activation: map[string]interface{}{
+				"scope": map[string]interface{}{},
+			},
+			expected: map[string]interface{}{
+				"files": []string{"/path/file1.txt", "/path/file2.txt"},
+			},
+			expectErr: false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			var result map[string]interface{}
+			action, err := createTestAction(test.rawKwargs, &result)
+			if err != nil {
+				if !test.expectErr {
+					t.Fatalf("Failed to create action: %v", err)
+				}
+				return
+			}
+
+			err = action.RunDirect(test.activation)
+			if test.expectErr {
+				if err == nil {
+					t.Error("Expected error but got none")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("Action execution failed: %v", err)
+			}
+
+			if !reflect.DeepEqual(result["extra_files"], test.expected["extra_files"]) {
+				t.Errorf("Expected %v, got %v", test.expected, result)
+			}
+		})
+	}
+}