fix action compiler to make it exensible

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/compiler/canonical/AbstractNodeVisitor.java

@@ -19,13 +19,12 @@
 package org.jbpm.compiler.canonical;
 
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
-import java.util.Set;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
+import org.jbpm.process.builder.action.ActionCompilerRegistry;
 import org.jbpm.process.core.ContextContainer;
 import org.jbpm.process.core.context.variable.Mappable;
 import org.jbpm.process.core.context.variable.Variable;
@@ -46,11 +45,9 @@
 import org.kie.api.definition.process.Connection;
 import org.kie.api.definition.process.Node;
 
-import com.github.javaparser.StaticJavaParser;
 import com.github.javaparser.ast.NodeList;
 import com.github.javaparser.ast.body.Parameter;
 import com.github.javaparser.ast.expr.AssignExpr;
-import com.github.javaparser.ast.expr.AssignExpr.Operator;
 import com.github.javaparser.ast.expr.CastExpr;
 import com.github.javaparser.ast.expr.ClassExpr;
 import com.github.javaparser.ast.expr.EnclosedExpr;
@@ -117,31 +114,10 @@ private void addScript(ExtendedNodeImpl extendedNodeImpl, BlockStmt body, String
     }
 
     private Expression buildDroolsConsequenceAction(ExtendedNodeImpl extendedNodeImpl, String dialect, String script) {
-        BlockStmt newDroolsConsequenceActionExpression = new BlockStmt();
-        if (script != null) {
-            if (dialect.contains("java")) {
-                newDroolsConsequenceActionExpression = StaticJavaParser.parseBlock("{" + script + "}");
-                Set<NameExpr> identifiers = new HashSet<>(newDroolsConsequenceActionExpression.findAll(NameExpr.class));
-                for (NameExpr identifier : identifiers) {
-                    VariableScope scope = (VariableScope) extendedNodeImpl.resolveContext(VariableScope.VARIABLE_SCOPE, identifier.getNameAsString());
-                    if (scope == null) {
-                        continue;
-                    }
-                    Variable var = scope.findVariable(identifier.getNameAsString());
-                    if (var == null) {
-                        continue;
-                    }
-                    Type type = StaticJavaParser.parseType(var.getType().getStringType());
-                    VariableDeclarationExpr target = new VariableDeclarationExpr(type, var.getName());
-                    Expression source = new MethodCallExpr(new NameExpr(KCONTEXT_VAR), "getVariable", NodeList.nodeList(new StringLiteralExpr(var.getName())));
-                    source = new CastExpr(type, source);
-                    AssignExpr assign = new AssignExpr(target, source, Operator.ASSIGN);
-                    newDroolsConsequenceActionExpression.addStatement(0, assign);
-                }
-            }
+        if (script == null) {
+            return new NullLiteralExpr();
         }
-        ClassOrInterfaceType type = StaticJavaParser.parseClassOrInterfaceType(org.kie.kogito.internal.process.runtime.KogitoProcessContext.class.getName());
-        return new LambdaExpr(NodeList.nodeList(new Parameter(type, KCONTEXT_VAR)), newDroolsConsequenceActionExpression, true);
+        return ActionCompilerRegistry.instance().find(dialect).buildAction(extendedNodeImpl, script);
     }
 
     private boolean isExtendedNode(T node) {

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/compiler/canonical/AbstractVisitor.java

@@ -56,7 +56,7 @@ public abstract class AbstractVisitor {
 
     protected static final String ON_ACTION_SCRIPT_METHOD = "onActionScript";
     protected static final String FACTORY_FIELD_NAME = "factory";
-    protected static final String KCONTEXT_VAR = "kcontext";
+    public static final String KCONTEXT_VAR = "kcontext";
 
     protected MethodCallExpr getWorkflowElementConstructor(WorkflowElementIdentifier identifier) {
         Type type = new ClassOrInterfaceType().setName(WorkflowElementIdentifierFactory.class.getName());

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/process/builder/action/ActionCompiler.java

@@ -0,0 +1,36 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.jbpm.process.builder.action;
+
+import java.util.Arrays;
+
+import org.jbpm.workflow.core.impl.NodeImpl;
+
+import com.github.javaparser.ast.expr.Expression;
+
+public interface ActionCompiler {
+
+    String[] dialects();
+
+    default boolean accept(String dialect) {
+        return Arrays.asList(dialect).contains(dialect);
+    }
+
+    Expression buildAction(NodeImpl nodeImpl, String scrtip);
+}

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/process/builder/action/ActionCompilerRegistry.java

@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.jbpm.process.builder.action;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.ServiceLoader;
+
+import org.jbpm.util.JbpmClassLoaderUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ActionCompilerRegistry {
+
+    private static final Logger logger = LoggerFactory.getLogger(ActionCompilerRegistry.class);
+
+    private static ActionCompilerRegistry INSTANCE;
+
+    private List<ActionCompiler> registry;
+
+    public static ActionCompilerRegistry instance() {
+        if (INSTANCE == null) {
+            INSTANCE = new ActionCompilerRegistry();
+        }
+        return INSTANCE;
+    }
+
+    protected ActionCompilerRegistry() {
+        this.registry = new ArrayList<>();
+        ServiceLoader.load(ActionCompiler.class, JbpmClassLoaderUtil.findClassLoader()).forEach(registry::add);
+    }
+
+    public void register(ActionCompiler actionCompiler) {
+        this.registry.add(actionCompiler);
+        logger.debug("Manual registration of scripting language {} with instance {}", List.of(actionCompiler.dialects()), actionCompiler);
+    }
+
+    public ActionCompiler find(String language) {
+        for (ActionCompiler transformer : registry) {
+            if (transformer.accept(language)) {
+                return transformer;
+            }
+        }
+        throw new IllegalArgumentException("action compiler not support for dialect " + language);
+    }
+}

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/process/builder/action/JavaActionCompiler.java

@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.jbpm.process.builder.action;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.jbpm.compiler.canonical.AbstractNodeVisitor;
+import org.jbpm.process.core.context.variable.Variable;
+import org.jbpm.process.core.context.variable.VariableScope;
+import org.jbpm.workflow.core.impl.NodeImpl;
+
+import com.github.javaparser.StaticJavaParser;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.body.Parameter;
+import com.github.javaparser.ast.expr.AssignExpr;
+import com.github.javaparser.ast.expr.AssignExpr.Operator;
+import com.github.javaparser.ast.expr.CastExpr;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.LambdaExpr;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.NameExpr;
+import com.github.javaparser.ast.expr.StringLiteralExpr;
+import com.github.javaparser.ast.expr.VariableDeclarationExpr;
+import com.github.javaparser.ast.stmt.BlockStmt;
+import com.github.javaparser.ast.type.ClassOrInterfaceType;
+import com.github.javaparser.ast.type.Type;
+
+public class JavaActionCompiler implements ActionCompiler {
+
+    @Override
+    public String[] dialects() {
+        return new String[] { "java" };
+    }
+
+    @Override
+    public boolean accept(String dialect) {
+        return dialect.toLowerCase().contains("java");
+    }
+
+    @Override
+    public Expression buildAction(NodeImpl nodeImpl, String script) {
+        BlockStmt newDroolsConsequenceActionExpression = new BlockStmt();
+        newDroolsConsequenceActionExpression = StaticJavaParser.parseBlock("{" + script + "}");
+        Set<NameExpr> identifiers = new HashSet<>(newDroolsConsequenceActionExpression.findAll(NameExpr.class));
+        for (NameExpr identifier : identifiers) {
+            VariableScope scope = (VariableScope) nodeImpl.resolveContext(VariableScope.VARIABLE_SCOPE, identifier.getNameAsString());
+            if (scope == null) {
+                continue;
+            }
+            Variable var = scope.findVariable(identifier.getNameAsString());
+            if (var == null) {
+                continue;
+            }
+            Type type = StaticJavaParser.parseType(var.getType().getStringType());
+            VariableDeclarationExpr target = new VariableDeclarationExpr(type, var.getName());
+            Expression source = new MethodCallExpr(new NameExpr(AbstractNodeVisitor.KCONTEXT_VAR), "getVariable", NodeList.nodeList(new StringLiteralExpr(var.getName())));
+            source = new CastExpr(type, source);
+            AssignExpr assign = new AssignExpr(target, source, Operator.ASSIGN);
+            newDroolsConsequenceActionExpression.addStatement(0, assign);
+        }
+        ClassOrInterfaceType type = StaticJavaParser.parseClassOrInterfaceType(org.kie.kogito.internal.process.runtime.KogitoProcessContext.class.getName());
+        return new LambdaExpr(NodeList.nodeList(new Parameter(type, AbstractNodeVisitor.KCONTEXT_VAR)), newDroolsConsequenceActionExpression, true);
+    }
+
+}

jbpm/jbpm-flow-builder/src/main/java/org/jbpm/process/builder/action/MVELActionCompiler.java

@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.jbpm.process.builder.action;
+
+import org.jbpm.compiler.canonical.AbstractNodeVisitor;
+import org.jbpm.workflow.core.impl.NodeImpl;
+
+import com.github.javaparser.StaticJavaParser;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.body.Parameter;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.LambdaExpr;
+import com.github.javaparser.ast.stmt.BlockStmt;
+import com.github.javaparser.ast.type.ClassOrInterfaceType;
+
+import static org.kie.kogito.internal.utils.ConversionUtils.sanitizeString;
+
+public class MVELActionCompiler implements ActionCompiler {
+
+    @Override
+    public String[] dialects() {
+        return new String[] { "mvel" };
+    }
+
+    @Override
+    public Expression buildAction(NodeImpl nodeImpl, String script) {
+        BlockStmt actionExpression = StaticJavaParser.parseBlock(
+                "{ org.mvel2.MVEL.eval(\"" + sanitizeString(script) +
+                        "\", new org.jbpm.workflow.instance.impl.NodeInstanceResolverFactory((org.jbpm.workflow.instance.NodeInstance) kcontext.getNodeInstance())); }");
+        ClassOrInterfaceType type = StaticJavaParser.parseClassOrInterfaceType(org.kie.kogito.internal.process.runtime.KogitoProcessContext.class.getName());
+        return new LambdaExpr(NodeList.nodeList(new Parameter(type, AbstractNodeVisitor.KCONTEXT_VAR)), actionExpression, true);
+    }
+
+}

jbpm/jbpm-flow-builder/src/main/resources/META-INF/services/org.jbpm.process.builder.action.ActionCompiler

@@ -0,0 +1,2 @@
+org.jbpm.process.builder.action.JavaActionCompiler
+org.jbpm.process.builder.action.MVELActionCompiler