Rename java -> func / standard -> spec

experimental/lambda/pom.xml

@@ -19,7 +19,7 @@
         </dependency>
         <dependency>
             <groupId>io.serverlessworkflow</groupId>
-            <artifactId>serverlessworkflow-fluent-java</artifactId>
+            <artifactId>serverlessworkflow-fluent-func</artifactId>
         </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>

experimental/lambda/src/test/java/io/serverless/workflow/impl/FluentDSLCallTest.java

@@ -19,7 +19,7 @@
 
 import io.serverlessworkflow.api.types.FlowDirectiveEnum;
 import io.serverlessworkflow.api.types.Workflow;
-import io.serverlessworkflow.fluent.java.JavaWorkflowBuilder;
+import io.serverlessworkflow.fluent.func.FuncWorkflowBuilder;
 import io.serverlessworkflow.impl.WorkflowApplication;
 import io.serverlessworkflow.impl.WorkflowDefinition;
 import java.util.Collection;
@@ -33,7 +33,7 @@ public class FluentDSLCallTest {
   void testJavaFunction() throws InterruptedException, ExecutionException {
     try (WorkflowApplication app = WorkflowApplication.builder().build()) {
       final Workflow workflow =
-          JavaWorkflowBuilder.workflow("testJavaCall")
+          FuncWorkflowBuilder.workflow("testJavaCall")
               .tasks(tasks -> tasks.callFn(f -> f.fn(JavaFunctions::getName)))
               .build();
       assertThat(
@@ -51,7 +51,7 @@ void testJavaFunction() throws InterruptedException, ExecutionException {
   void testForLoop() throws InterruptedException, ExecutionException {
     try (WorkflowApplication app = WorkflowApplication.builder().build()) {
       Workflow workflow =
-          JavaWorkflowBuilder.workflow()
+          FuncWorkflowBuilder.workflow()
               .tasks(
                   t ->
                       t.forFn(
@@ -76,7 +76,7 @@ void testForLoop() throws InterruptedException, ExecutionException {
   void testSwitch() throws InterruptedException, ExecutionException {
     try (WorkflowApplication app = WorkflowApplication.builder().build()) {
       Workflow workflow =
-          JavaWorkflowBuilder.workflow()
+          FuncWorkflowBuilder.workflow()
               .tasks(
                   tasks ->
                       tasks

experimental/pom.xml

@@ -32,7 +32,7 @@
         </dependency>
         <dependency>
             <groupId>io.serverlessworkflow</groupId>
-            <artifactId>serverlessworkflow-fluent-java</artifactId>
+            <artifactId>serverlessworkflow-fluent-func</artifactId>
             <version>${project.version}</version>
         </dependency>
     </dependencies>

fluent/java/pom.xml → fluent/func/pom.xml

@@ -9,8 +9,8 @@
         <version>8.0.0-SNAPSHOT</version>
     </parent>
 
-    <name>Serverless Workflow :: Fluent :: Java</name>
-    <artifactId>serverlessworkflow-fluent-java</artifactId>
+    <name>Serverless Workflow :: Fluent :: Functional</name>
+    <artifactId>serverlessworkflow-fluent-func</artifactId>
 
     <properties>
         <maven.compiler.source>17</maven.compiler.source>
@@ -29,7 +29,7 @@
         </dependency>
         <dependency>
             <groupId>io.serverlessworkflow</groupId>
-            <artifactId>serverlessworkflow-fluent-standard</artifactId>
+            <artifactId>serverlessworkflow-fluent-spec</artifactId>
         </dependency>
 
         <dependency>

fluent/java/src/main/java/io/serverlessworkflow/fluent/java/CallTaskJavaBuilder.java → fluent/func/src/main/java/io/serverlessworkflow/fluent/func/FuncCallTaskBuilder.java

@@ -13,29 +13,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.serverlessworkflow.fluent.java;
+package io.serverlessworkflow.fluent.func;
 
 import io.serverlessworkflow.api.types.CallJava;
 import io.serverlessworkflow.api.types.CallTaskJava;
-import io.serverlessworkflow.fluent.standard.TaskBaseBuilder;
+import io.serverlessworkflow.fluent.spec.TaskBaseBuilder;
 import java.util.function.Function;
 
-public class CallTaskJavaBuilder extends TaskBaseBuilder<CallTaskJavaBuilder>
-    implements JavaTransformationHandlers<CallTaskJavaBuilder> {
+public class FuncCallTaskBuilder extends TaskBaseBuilder<FuncCallTaskBuilder>
+    implements FuncTransformations<FuncCallTaskBuilder> {
 
   private CallTaskJava callTaskJava;
 
-  CallTaskJavaBuilder() {
+  FuncCallTaskBuilder() {
     callTaskJava = new CallTaskJava(new CallJava() {});
     super.setTask(callTaskJava.getCallJava());
   }
 
   @Override
-  protected CallTaskJavaBuilder self() {
+  protected FuncCallTaskBuilder self() {
     return this;
   }
 
-  public <T, V> CallTaskJavaBuilder fn(Function<T, V> function) {
+  public <T, V> FuncCallTaskBuilder fn(Function<T, V> function) {
     this.callTaskJava = new CallTaskJava(CallJava.function(function));
     super.setTask(this.callTaskJava.getCallJava());
     return this;

fluent/java/src/main/java/io/serverlessworkflow/fluent/java/DoTaskJavaBuilder.java → fluent/func/src/main/java/io/serverlessworkflow/fluent/func/FuncDoTaskBuilder.java

@@ -13,49 +13,49 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.serverlessworkflow.fluent.java;
+package io.serverlessworkflow.fluent.func;
 
-import io.serverlessworkflow.fluent.standard.BaseDoTaskBuilder;
+import io.serverlessworkflow.fluent.spec.BaseDoTaskBuilder;
 import java.util.function.Consumer;
 
-public class DoTaskJavaBuilder extends BaseDoTaskBuilder<DoTaskJavaBuilder, TaskItemListJavaBuilder>
-    implements JavaTransformationHandlers<DoTaskJavaBuilder> {
+public class FuncDoTaskBuilder extends BaseDoTaskBuilder<FuncDoTaskBuilder, FuncTaskItemListBuilder>
+    implements FuncTransformations<FuncDoTaskBuilder> {
 
-  DoTaskJavaBuilder() {
-    super(new TaskItemListJavaBuilder());
+  FuncDoTaskBuilder() {
+    super(new FuncTaskItemListBuilder());
   }
 
   @Override
-  protected DoTaskJavaBuilder self() {
+  protected FuncDoTaskBuilder self() {
     return this;
   }
 
-  public DoTaskJavaBuilder callFn(String name, Consumer<CallTaskJavaBuilder> consumer) {
+  public FuncDoTaskBuilder callFn(String name, Consumer<FuncCallTaskBuilder> consumer) {
     this.innerListBuilder().callJava(name, consumer);
     return this;
   }
 
-  public DoTaskJavaBuilder callFn(Consumer<CallTaskJavaBuilder> consumer) {
+  public FuncDoTaskBuilder callFn(Consumer<FuncCallTaskBuilder> consumer) {
     this.innerListBuilder().callJava(consumer);
     return this;
   }
 
-  public DoTaskJavaBuilder forFn(String name, Consumer<ForTaskJavaBuilder> consumer) {
+  public FuncDoTaskBuilder forFn(String name, Consumer<FuncForTaskBuilder> consumer) {
     this.innerListBuilder().forFn(name, consumer);
     return this;
   }
 
-  public DoTaskJavaBuilder forFn(Consumer<ForTaskJavaBuilder> consumer) {
+  public FuncDoTaskBuilder forFn(Consumer<FuncForTaskBuilder> consumer) {
     this.innerListBuilder().forFn(consumer);
     return this;
   }
 
-  public DoTaskJavaBuilder switchFn(String name, Consumer<SwitchTaskJavaBuilder> consumer) {
+  public FuncDoTaskBuilder switchFn(String name, Consumer<FuncSwitchTaskBuilder> consumer) {
     this.innerListBuilder().switchFn(name, consumer);
     return this;
   }
 
-  public DoTaskJavaBuilder switchFn(Consumer<SwitchTaskJavaBuilder> consumer) {
+  public FuncDoTaskBuilder switchFn(Consumer<FuncSwitchTaskBuilder> consumer) {
     this.innerListBuilder().switchFn(consumer);
     return this;
   }

fluent/java/src/main/java/io/serverlessworkflow/fluent/java/ForTaskJavaBuilder.java → fluent/func/src/main/java/io/serverlessworkflow/fluent/func/FuncForTaskBuilder.java

@@ -13,15 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.serverlessworkflow.fluent.java;
+package io.serverlessworkflow.fluent.func;
 
 import io.serverlessworkflow.api.types.CallJava;
 import io.serverlessworkflow.api.types.CallTaskJava;
 import io.serverlessworkflow.api.types.ForTaskConfiguration;
 import io.serverlessworkflow.api.types.ForTaskFunction;
 import io.serverlessworkflow.api.types.Task;
 import io.serverlessworkflow.api.types.TaskItem;
-import io.serverlessworkflow.fluent.standard.TaskBaseBuilder;
+import io.serverlessworkflow.fluent.spec.TaskBaseBuilder;
 import io.serverlessworkflow.impl.expressions.LoopFunction;
 import io.serverlessworkflow.impl.expressions.LoopPredicate;
 import io.serverlessworkflow.impl.expressions.LoopPredicateIndex;
@@ -32,40 +32,40 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 
-public class ForTaskJavaBuilder extends TaskBaseBuilder<ForTaskJavaBuilder>
-    implements JavaTransformationHandlers<ForTaskJavaBuilder> {
+public class FuncForTaskBuilder extends TaskBaseBuilder<FuncForTaskBuilder>
+    implements FuncTransformations<FuncForTaskBuilder> {
 
   private final ForTaskFunction forTaskFunction;
   private final List<TaskItem> items;
 
-  ForTaskJavaBuilder() {
+  FuncForTaskBuilder() {
     this.forTaskFunction = new ForTaskFunction();
     this.forTaskFunction.withFor(new ForTaskConfiguration());
     this.items = new ArrayList<>();
     super.setTask(forTaskFunction);
   }
 
   @Override
-  protected ForTaskJavaBuilder self() {
+  protected FuncForTaskBuilder self() {
     return this;
   }
 
-  public <T, V> ForTaskJavaBuilder whileC(LoopPredicate<T, V> predicate) {
+  public <T, V> FuncForTaskBuilder whileC(LoopPredicate<T, V> predicate) {
     this.forTaskFunction.withWhile(predicate);
     return this;
   }
 
-  public <T, V> ForTaskJavaBuilder whileC(LoopPredicateIndex<T, V> predicate) {
+  public <T, V> FuncForTaskBuilder whileC(LoopPredicateIndex<T, V> predicate) {
     this.forTaskFunction.withWhile(predicate);
     return this;
   }
 
-  public <T> ForTaskJavaBuilder collection(Function<T, Collection<?>> collectionF) {
+  public <T> FuncForTaskBuilder collection(Function<T, Collection<?>> collectionF) {
     this.forTaskFunction.withCollection(collectionF);
     return this;
   }
 
-  public <T, V, R> ForTaskJavaBuilder tasks(String name, LoopFunction<T, V, R> function) {
+  public <T, V, R> FuncForTaskBuilder tasks(String name, LoopFunction<T, V, R> function) {
     this.items.add(
         new TaskItem(
             name,
@@ -77,12 +77,12 @@ public <T, V, R> ForTaskJavaBuilder tasks(String name, LoopFunction<T, V, R> fun
     return this;
   }
 
-  public <T, V, R> ForTaskJavaBuilder tasks(LoopFunction<T, V, R> function) {
+  public <T, V, R> FuncForTaskBuilder tasks(LoopFunction<T, V, R> function) {
     return this.tasks(UUID.randomUUID().toString(), function);
   }
 
-  public ForTaskJavaBuilder tasks(Consumer<TaskItemListJavaBuilder> consumer) {
-    final TaskItemListJavaBuilder builder = new TaskItemListJavaBuilder();
+  public FuncForTaskBuilder tasks(Consumer<FuncTaskItemListBuilder> consumer) {
+    final FuncTaskItemListBuilder builder = new FuncTaskItemListBuilder();
     consumer.accept(builder);
     this.items.addAll(builder.build());
     return this;

fluent/java/src/main/java/io/serverlessworkflow/fluent/java/SwitchTaskJavaBuilder.java → fluent/func/src/main/java/io/serverlessworkflow/fluent/func/FuncSwitchTaskBuilder.java

@@ -13,43 +13,43 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.serverlessworkflow.fluent.java;
+package io.serverlessworkflow.fluent.func;
 
 import io.serverlessworkflow.api.types.FlowDirective;
 import io.serverlessworkflow.api.types.FlowDirectiveEnum;
 import io.serverlessworkflow.api.types.SwitchCase;
 import io.serverlessworkflow.api.types.SwitchCaseFunction;
 import io.serverlessworkflow.api.types.SwitchItem;
 import io.serverlessworkflow.api.types.SwitchTask;
-import io.serverlessworkflow.fluent.standard.TaskBaseBuilder;
+import io.serverlessworkflow.fluent.spec.TaskBaseBuilder;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
-public class SwitchTaskJavaBuilder extends TaskBaseBuilder<SwitchTaskJavaBuilder>
-    implements JavaTransformationHandlers<SwitchTaskJavaBuilder> {
+public class FuncSwitchTaskBuilder extends TaskBaseBuilder<FuncSwitchTaskBuilder>
+    implements FuncTransformations<FuncSwitchTaskBuilder> {
 
   private final SwitchTask switchTask;
   private final List<SwitchItem> switchItems;
 
-  SwitchTaskJavaBuilder() {
+  FuncSwitchTaskBuilder() {
     this.switchTask = new SwitchTask();
     this.switchItems = new ArrayList<>();
     super.setTask(switchTask);
   }
 
   @Override
-  protected SwitchTaskJavaBuilder self() {
+  protected FuncSwitchTaskBuilder self() {
     return this;
   }
 
-  public SwitchTaskJavaBuilder items(Consumer<SwitchCaseJavaBuilder> consumer) {
+  public FuncSwitchTaskBuilder items(Consumer<SwitchCaseJavaBuilder> consumer) {
     return this.items(UUID.randomUUID().toString(), consumer);
   }
 
-  public SwitchTaskJavaBuilder items(String name, Consumer<SwitchCaseJavaBuilder> consumer) {
+  public FuncSwitchTaskBuilder items(String name, Consumer<SwitchCaseJavaBuilder> consumer) {
     final SwitchCaseJavaBuilder switchCase = new SwitchCaseJavaBuilder();
     consumer.accept(switchCase);
     this.switchItems.add(new SwitchItem(name, switchCase.build()));

fluent/java/src/main/java/io/serverlessworkflow/fluent/java/TaskItemListJavaBuilder.java → fluent/func/src/main/java/io/serverlessworkflow/fluent/func/FuncTaskItemListBuilder.java

@@ -13,61 +13,61 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.serverlessworkflow.fluent.java;
+package io.serverlessworkflow.fluent.func;
 
 import io.serverlessworkflow.api.types.Task;
 import io.serverlessworkflow.api.types.TaskItem;
-import io.serverlessworkflow.fluent.standard.BaseTaskItemListBuilder;
+import io.serverlessworkflow.fluent.spec.BaseTaskItemListBuilder;
 import java.util.UUID;
 import java.util.function.Consumer;
 
-public class TaskItemListJavaBuilder extends BaseTaskItemListBuilder<TaskItemListJavaBuilder> {
+public class FuncTaskItemListBuilder extends BaseTaskItemListBuilder<FuncTaskItemListBuilder> {
 
-  TaskItemListJavaBuilder() {
+  FuncTaskItemListBuilder() {
     super();
   }
 
   @Override
-  protected TaskItemListJavaBuilder self() {
+  protected FuncTaskItemListBuilder self() {
     return this;
   }
 
   @Override
-  protected TaskItemListJavaBuilder newItemListBuilder() {
-    return new TaskItemListJavaBuilder();
+  protected FuncTaskItemListBuilder newItemListBuilder() {
+    return new FuncTaskItemListBuilder();
   }
 
-  public TaskItemListJavaBuilder callJava(String name, Consumer<CallTaskJavaBuilder> consumer) {
+  public FuncTaskItemListBuilder callJava(String name, Consumer<FuncCallTaskBuilder> consumer) {
     this.requireNameAndConfig(name, consumer);
-    final CallTaskJavaBuilder callTaskJavaBuilder = new CallTaskJavaBuilder();
+    final FuncCallTaskBuilder callTaskJavaBuilder = new FuncCallTaskBuilder();
     consumer.accept(callTaskJavaBuilder);
     return addTaskItem(new TaskItem(name, new Task().withCallTask(callTaskJavaBuilder.build())));
   }
 
-  public TaskItemListJavaBuilder callJava(Consumer<CallTaskJavaBuilder> consumer) {
+  public FuncTaskItemListBuilder callJava(Consumer<FuncCallTaskBuilder> consumer) {
     return this.callJava(UUID.randomUUID().toString(), consumer);
   }
 
-  public TaskItemListJavaBuilder forFn(String name, Consumer<ForTaskJavaBuilder> consumer) {
+  public FuncTaskItemListBuilder forFn(String name, Consumer<FuncForTaskBuilder> consumer) {
     this.requireNameAndConfig(name, consumer);
-    final ForTaskJavaBuilder forTaskJavaBuilder = new ForTaskJavaBuilder();
+    final FuncForTaskBuilder forTaskJavaBuilder = new FuncForTaskBuilder();
     consumer.accept(forTaskJavaBuilder);
     return this.addTaskItem(new TaskItem(name, new Task().withForTask(forTaskJavaBuilder.build())));
   }
 
-  public TaskItemListJavaBuilder forFn(Consumer<ForTaskJavaBuilder> consumer) {
+  public FuncTaskItemListBuilder forFn(Consumer<FuncForTaskBuilder> consumer) {
     return this.forFn(UUID.randomUUID().toString(), consumer);
   }
 
-  public TaskItemListJavaBuilder switchFn(String name, Consumer<SwitchTaskJavaBuilder> consumer) {
+  public FuncTaskItemListBuilder switchFn(String name, Consumer<FuncSwitchTaskBuilder> consumer) {
     this.requireNameAndConfig(name, consumer);
-    final SwitchTaskJavaBuilder switchTaskJavaBuilder = new SwitchTaskJavaBuilder();
-    consumer.accept(switchTaskJavaBuilder);
+    final FuncSwitchTaskBuilder funcSwitchTaskBuilder = new FuncSwitchTaskBuilder();
+    consumer.accept(funcSwitchTaskBuilder);
     return this.addTaskItem(
-        new TaskItem(name, new Task().withSwitchTask(switchTaskJavaBuilder.build())));
+        new TaskItem(name, new Task().withSwitchTask(funcSwitchTaskBuilder.build())));
   }
 
-  public TaskItemListJavaBuilder switchFn(Consumer<SwitchTaskJavaBuilder> consumer) {
+  public FuncTaskItemListBuilder switchFn(Consumer<FuncSwitchTaskBuilder> consumer) {
     return this.switchFn(UUID.randomUUID().toString(), consumer);
   }
 }