Merge branch 'main' into incubator-kie-issues-1131-3

apache · Jun 4, 2024 · 832362f · 832362f
2 parents 9356c65 + 7e2a311
commit 832362f
Show file tree

Hide file tree

Showing 23 changed files with 206 additions and 1,855 deletions.
diff --git a/.github/workflows/pr-kogito-runtimes.yml b/.github/workflows/pr-kogito-runtimes.yml
@@ -65,7 +65,7 @@ jobs:
           github-token: "${{ secrets.GITHUB_TOKEN }}"
           definition-file: https://raw.githubusercontent.com/${GROUP:apache}/incubator-kie-kogito-pipelines/${BRANCH:main}/.ci/pull-request-config.yaml
         env:
-          BUILD_MVN_OPTS_CURRENT: '-T 1.5C'
+          BUILD_MVN_OPTS_CURRENT: '-T 1.5C -Dvalidate-formatting'
       - name: Junit Report
         uses: apache/incubator-kie-kogito-pipelines/.ci/actions/action-junit-report@main
         if: ${{ always() }}

diff --git a/jbpm/jbpm-flow-builder/src/main/java/org/jbpm/compiler/canonical/AbstractVisitor.java b/jbpm/jbpm-flow-builder/src/main/java/org/jbpm/compiler/canonical/AbstractVisitor.java
@@ -32,11 +32,11 @@
 import org.kie.api.definition.process.NodeContainer;
 import org.kie.api.definition.process.WorkflowElementIdentifier;
 import org.kie.kogito.internal.process.runtime.KogitoNode;
-import org.kie.kogito.internal.utils.KogitoTags;
 
 import com.github.javaparser.ast.NodeList;
 import com.github.javaparser.ast.expr.ClassExpr;
 import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.FieldAccessExpr;
 import com.github.javaparser.ast.expr.MethodCallExpr;
 import com.github.javaparser.ast.expr.NameExpr;
 import com.github.javaparser.ast.expr.NullLiteralExpr;
@@ -102,13 +102,28 @@ protected void visitVariableScope(String field, VariableScope variableScope, Blo
                 if (!visitedVariables.add(variable.getName())) {
                     continue;
                 }
-                String tags = (String) variable.getMetaData(KogitoTags.VARIABLE_TAGS);
+
+                Map<String, Object> metaData = variable.getMetaData();
+                NodeList<Expression> parameters = new NodeList<>();
+                for (Map.Entry<String, Object> entry : metaData.entrySet().stream().filter(e -> e.getValue() != null).toList()) {
+                    parameters.add(new StringLiteralExpr(entry.getKey()));
+                    parameters.add(new StringLiteralExpr(entry.getValue().toString()));
+                }
+
+                Expression metadataExpression = new FieldAccessExpr(new NameExpr(Map.class.getPackage().getName()), Map.class.getSimpleName());
+                metadataExpression = new MethodCallExpr(metadataExpression, "of", parameters);
                 Object defaultValue = variable.getValue();
                 body.tryAddImportToParentCompilationUnit(variable.getType().getClass());
-                body.addStatement(getFactoryMethod(field, METHOD_VARIABLE, new StringLiteralExpr(variable.getName()),
-                        new MethodCallExpr(DataTypeResolver.class.getName() + ".fromClass", new ClassExpr(parseClassOrInterfaceType(variable.getType().getStringType()).removeTypeArguments())),
-                        defaultValue != null ? new StringLiteralExpr(defaultValue.toString()) : new NullLiteralExpr(), new StringLiteralExpr(KogitoTags.VARIABLE_TAGS),
-                        tags != null ? new StringLiteralExpr(tags) : new NullLiteralExpr()));
+
+                NodeList<Expression> variableFactoryParameters = new NodeList<>();
+                variableFactoryParameters.add(new StringLiteralExpr(variable.getName()));
+                variableFactoryParameters
+                        .add(new MethodCallExpr(DataTypeResolver.class.getName() + ".fromClass", new ClassExpr(parseClassOrInterfaceType(variable.getType().getStringType()).removeTypeArguments())));
+                if (defaultValue != null) {
+                    variableFactoryParameters.add(new StringLiteralExpr(defaultValue.toString()));
+                }
+                variableFactoryParameters.add(metadataExpression);
+                body.addStatement(getFactoryMethod(field, METHOD_VARIABLE, variableFactoryParameters.stream().toArray(Expression[]::new)));
             }
         }
     }

diff --git a/...ow-builder/src/test/java/org/jbpm/compiler/canonical/ProcessToExecModelGeneratorTest.java b/...ow-builder/src/test/java/org/jbpm/compiler/canonical/ProcessToExecModelGeneratorTest.java
@@ -18,6 +18,8 @@
  */
 package org.jbpm.compiler.canonical;
 
+import java.util.Collections;
+
 import org.jbpm.process.core.datatype.impl.type.IntegerDataType;
 import org.jbpm.process.core.datatype.impl.type.ObjectDataType;
 import org.jbpm.process.core.datatype.impl.type.StringDataType;
@@ -130,8 +132,8 @@ public void testScriptVariablewithDefaultValue() {
         RuleFlowProcessFactory factory = RuleFlowProcessFactory.createProcess("demo.orders");
         factory
                 .variable("order", new ObjectDataType("com.myspace.demo.Order"))
-                .variable("approver", new StringDataType(), "john", "customTags", null)
-                .variable("age", new IntegerDataType(), "1", "customTags", null)
+                .variable("approver", new StringDataType(), "john", Collections.singletonMap("customTags", null))
+                .variable("age", new IntegerDataType(), "1", Collections.singletonMap("customTags", null))
                 .name("orders")
                 .packageName("com.myspace.demo")
                 .dynamic(false)

diff --git a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowNodeContainerFactory.java b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowNodeContainerFactory.java
@@ -18,6 +18,8 @@
  */
 package org.jbpm.ruleflow.core;
 
+import java.util.Map;
+
 import org.jbpm.process.core.Context;
 import org.jbpm.process.core.ContextContainer;
 import org.jbpm.process.core.context.exception.ActionExceptionHandler;
@@ -237,11 +239,11 @@ public T errorExceptionHandler(String signalType, String faultCode, String fault
 
     public abstract T variable(String name, DataType type);
 
-    public abstract T variable(String name, DataType type, Object value);
+    public abstract T variable(String name, DataType type, Map<String, Object> metadata);
 
-    public abstract T variable(String name, DataType type, String metaDataName, Object metaDataValue);
+    public abstract T variable(String name, DataType type, Object value);
 
-    public abstract T variable(String name, DataType type, Object value, String metaDataName, Object metaDataValue);
+    public abstract T variable(String name, DataType type, Object value, Map<String, Object> metadata);
 
     private <S extends Context> S getScope(String scopeType, Class<S> scopeClass) {
         ContextContainer contextContainer = (ContextContainer) getNodeContainer();

diff --git a/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowProcessFactory.java b/jbpm/jbpm-flow/src/main/java/org/jbpm/ruleflow/core/RuleFlowProcessFactory.java
@@ -20,6 +20,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -201,29 +202,30 @@ public RuleFlowProcessFactory variable(String name, Class<?> clazz) {
 
     @Override
     public RuleFlowProcessFactory variable(String name, DataType type) {
-        return variable(name, type, null);
+        return variable(name, type, Collections.emptyMap());
     }
 
     @Override
     public RuleFlowProcessFactory variable(String name, DataType type, Object value) {
-        return variable(name, type, value, null, null);
+        return variable(name, type, value, Collections.emptyMap());
     }
 
     @Override
-    public RuleFlowProcessFactory variable(String name, DataType type, String metaDataName, Object metaDataValue) {
-        return variable(name, type, null, metaDataName, metaDataValue);
+    public RuleFlowProcessFactory variable(String name, DataType type, Map<String, Object> metadata) {
+        return this.variable(name, type, null, metadata);
     }
 
     @Override
-    public RuleFlowProcessFactory variable(String name, DataType type, Object value, String metaDataName, Object metaDataValue) {
-
+    public RuleFlowProcessFactory variable(String name, DataType type, Object value, Map<String, Object> metadata) {
         Variable variable = new Variable();
         variable.setName(name);
         variable.setType(type);
         variable.setValue(type.verifyDataType(value) ? value : type.readValue((String) value));
-        if (metaDataName != null && metaDataValue != null) {
-            variable.setMetaData(metaDataName, metaDataValue);
+
+        for (Map.Entry<String, Object> entry : metadata.entrySet()) {
+            variable.setMetaData(entry.getKey(), entry.getValue());
         }
+
         getRuleFlowProcess().getVariableScope().getVariables().add(variable);
         return this;
     }

diff --git a/.../jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/AbstractCompositeNodeFactory.java b/.../jbpm-flow/src/main/java/org/jbpm/ruleflow/core/factory/AbstractCompositeNodeFactory.java
@@ -18,6 +18,9 @@
  */
 package org.jbpm.ruleflow.core.factory;
 
+import java.util.Collections;
+import java.util.Map;
+
 import org.jbpm.process.core.context.variable.Variable;
 import org.jbpm.process.core.context.variable.VariableScope;
 import org.jbpm.process.core.datatype.DataType;
@@ -53,28 +56,28 @@ public T timeout(String timeout) {
 
     @Override
     public T variable(String name, DataType type) {
-        return variable(name, type, null);
+        return variable(name, type, Collections.emptyMap());
     }
 
     @Override
     public T variable(String name, DataType type, Object value) {
-        return variable(name, type, value, null, null);
+        return variable(name, type, value, Collections.emptyMap());
     }
 
     @Override
-    public T variable(String name, DataType type, String metaDataName, Object metaDataValue) {
-        return variable(name, type, null, metaDataName, metaDataValue);
+    public T variable(String name, DataType type, Map<String, Object> metaData) {
+        return variable(name, type, null, metaData);
     }
 
     @Override
-    public T variable(String name, DataType type, Object value, String metaDataName, Object metaDataValue) {
+    public T variable(String name, DataType type, Object value, Map<String, Object> metadata) {
         Variable variable = new Variable();
         variable.setName(name);
         variable.setType(type);
         variable.setValue(value);
         VariableScope variableScope = (VariableScope) getCompositeNode().getDefaultContext(VariableScope.VARIABLE_SCOPE);
-        if (metaDataName != null && metaDataValue != null) {
-            variable.setMetaData(metaDataName, metaDataValue);
+        for (Map.Entry<String, Object> entry : metadata.entrySet()) {
+            variable.setMetaData(entry.getKey(), entry.getValue());
         }
         if (variableScope == null) {
             variableScope = new VariableScope();