[Fix #786] Evaluate embedded properties

Signed-off-by: fjtirado <[email protected]>

Author: fjtirado

impl/core/src/main/java/io/serverlessworkflow/impl/expressions/AbstractProxyCollection.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.serverlessworkflow.impl.expressions;
+
+import java.util.Collection;
+
+abstract class AbstractProxyCollection<T> {
+
+  protected Collection<T> values;
+
+  protected AbstractProxyCollection(Collection<T> values) {
+    this.values = values;
+  }
+
+  public int size() {
+    return values.size();
+  }
+
+  public boolean isEmpty() {
+    return values.isEmpty();
+  }
+
+  public boolean contains(Object o) {
+    return values.contains(o);
+  }
+
+  public boolean remove(Object o) {
+    return values.remove(o);
+  }
+
+  public boolean containsAll(Collection<?> c) {
+    return values.containsAll(c);
+  }
+
+  public boolean retainAll(Collection<?> c) {
+    return values.retainAll(c);
+  }
+
+  public boolean removeAll(Collection<?> c) {
+    return values.removeAll(c);
+  }
+
+  public void clear() {
+    values.clear();
+  }
+
+  public boolean addAll(Collection<? extends T> c) {
+    return values.addAll(c);
+  }
+
+  public boolean add(T e) {
+    return values.add(e);
+  }
+}

impl/core/src/main/java/io/serverlessworkflow/impl/expressions/ObjectExpressionFactory.java

@@ -19,6 +19,7 @@
 import io.serverlessworkflow.impl.WorkflowContext;
 import io.serverlessworkflow.impl.WorkflowModel;
 import io.serverlessworkflow.impl.WorkflowPredicate;
+import java.util.Collection;
 import java.util.Map;
 
 public abstract class ObjectExpressionFactory extends AbstractExpressionFactory {
@@ -31,13 +32,23 @@ protected ObjectExpression buildExpression(ExpressionDescriptor desc) {
       return expression::eval;
     } else if (desc.asObject() != null) {
       Object exprObj = buildExpressionObject(desc.asObject(), this);
-      return exprObj instanceof Map map
-          ? (w, t, n) -> evaluateExpressionMap(map, w, t, n)
-          : (w, t, n) -> desc.asObject();
+      return (w, t, n) -> evaluateExpressionObject(exprObj, w, t, n);
     }
     throw new IllegalArgumentException("Both object and str are null");
   }
 
+  private Object evaluateExpressionObject(
+      Object obj, WorkflowContext workflow, TaskContext task, WorkflowModel model) {
+    if (obj instanceof ObjectExpression expr) {
+      return toJavaObject(expr.eval(workflow, task, model));
+    } else if (obj instanceof Map map) return evaluateExpressionMap(map, workflow, task, model);
+    else if (obj instanceof Collection col) {
+      return evaluateExpressionCollection(col, workflow, task, model);
+    } else {
+      return obj;
+    }
+  }
+
   @Override
   public WorkflowPredicate buildPredicate(ExpressionDescriptor desc) {
     ObjectExpression expr = buildExpression(desc);
@@ -53,20 +64,40 @@ protected Object toJavaObject(Object eval) {
   private Map<String, Object> buildExpressionMap(
       Map<String, Object> origMap, ExpressionFactory factory) {
     return new ProxyMap(
-        origMap, o -> ExpressionUtils.isExpr(o) ? buildExpression(o.toString()) : o);
+        origMap,
+        o ->
+            ExpressionUtils.isExpr(o)
+                ? buildExpression(o.toString())
+                : buildExpressionObject(o, factory));
+  }
+
+  private Collection<Object> buildExpressionList(
+      Collection<Object> origList, ExpressionFactory factory) {
+    return new ProxyCollection(
+        origList,
+        o ->
+            ExpressionUtils.isExpr(o)
+                ? buildExpression(o.toString())
+                : buildExpressionObject(o, factory));
   }
 
   private Object buildExpressionObject(Object obj, ExpressionFactory factory) {
-    return obj instanceof Map map ? buildExpressionMap(map, factory) : obj;
+    if (obj instanceof Map map) {
+      return buildExpressionMap(map, factory);
+    } else if (obj instanceof Collection col) {
+      return buildExpressionList(col, factory);
+    } else {
+      return obj;
+    }
   }
 
   private Map<String, Object> evaluateExpressionMap(
       Map<String, Object> origMap, WorkflowContext workflow, TaskContext task, WorkflowModel n) {
-    return new ProxyMap(
-        origMap,
-        o ->
-            o instanceof ObjectExpression
-                ? toJavaObject(((ObjectExpression) o).eval(workflow, task, n))
-                : o);
+    return new ProxyMap(origMap, o -> evaluateExpressionObject(o, workflow, task, n));
+  }
+
+  private Collection<Object> evaluateExpressionCollection(
+      Collection<Object> origList, WorkflowContext workflow, TaskContext task, WorkflowModel n) {
+    return new ProxyCollection(origList, o -> evaluateExpressionObject(o, workflow, task, n));
   }
 }

impl/core/src/main/java/io/serverlessworkflow/impl/expressions/ProxyCollection.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.serverlessworkflow.impl.expressions;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.function.UnaryOperator;
+
+class ProxyCollection extends AbstractProxyCollection<Object> implements Collection<Object> {
+
+  private final UnaryOperator<Object> function;
+
+  public ProxyCollection(Collection<Object> values, UnaryOperator<Object> function) {
+    super(values);
+    this.function = function;
+  }
+
+  @Override
+  public Iterator<Object> iterator() {
+    return new ProxyIterator(values.iterator(), function);
+  }
+
+  @Override
+  public Object[] toArray() {
+    return processArray(values.toArray());
+  }
+
+  @Override
+  public <T> T[] toArray(T[] a) {
+    return processArray(values.toArray(a));
+  }
+
+  private <S> S[] processArray(S[] array) {
+    for (int i = 0; i < array.length; i++) {
+      array[i] = (S) function.apply(array[i]);
+    }
+    return array;
+  }
+}

impl/core/src/main/java/io/serverlessworkflow/impl/expressions/ProxyIterator.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2020-Present The Serverless Workflow Specification Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.serverlessworkflow.impl.expressions;
+
+import java.util.Iterator;
+import java.util.function.UnaryOperator;
+
+class ProxyIterator implements Iterator<Object> {
+
+  private Iterator<Object> iter;
+  private final UnaryOperator<Object> function;
+
+  public ProxyIterator(Iterator<Object> iter, UnaryOperator<Object> function) {
+    this.iter = iter;
+    this.function = function;
+  }
+
+  @Override
+  public boolean hasNext() {
+    return iter.hasNext();
+  }
+
+  @Override
+  public Object next() {
+    return function.apply(iter.next());
+  }
+
+  @Override
+  public void remove() {
+    iter.remove();
+  }
+}