allow external task id creation and parsing

Author: rouzwawi

workflow/src/main/java/io/rouz/task/Task.java

@@ -91,6 +91,6 @@ static <T> Task<T> create(
       EvalClosure<T> code,
       String taskName,
       Object... args) {
-    return new AutoValue_Task<>(TaskIds.create(taskName, args), code, inputs);
+    return new AutoValue_Task<>(TaskId.create(taskName, args), code, inputs);
   }
 }

workflow/src/main/java/io/rouz/task/TaskId.java

@@ -14,4 +14,31 @@ public interface TaskId {
    * @return A hash for the task parameter values
    */
   int hash();
+
+  /**
+   * Creates a {@link TaskId}.
+   *
+   * The task name can not contain any parenthesis.
+   *
+   * @throws IllegalArgumentException if the name contains any parenthesis
+   * @param name  Task name
+   * @param args  Arbitrary task arguments
+   * @return A task id for the given arguments
+   */
+  static TaskId create(String name, Object... args) {
+    return TaskIds.create(name, args);
+  }
+
+  /**
+   * Parses a {@link TaskId} based on a string representation.
+   *
+   * A parsed id is equal to a task id that was created using {@link #create(String, Object...)}.
+   *
+   * @throws IllegalArgumentException if the string does not conform to a task id
+   * @param stringId  The id to parse
+   * @return A parsed task id
+   */
+  static TaskId parse(String stringId) {
+    return TaskIds.parse(stringId);
+  }
 }

workflow/src/main/java/io/rouz/task/TaskIds.java

@@ -3,33 +3,55 @@
 import com.google.auto.value.AutoValue;
 
 import java.io.Serializable;
-import java.util.Arrays;
-import java.util.List;
 import java.util.Objects;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * {@link AutoValue} implementation of {@link TaskId}
  */
 @AutoValue
 abstract class TaskIds implements TaskId, Serializable {
 
-  abstract List<Object> args();
+  abstract String args();
 
   static TaskId create(String name, Object... args) {
+    if (name.contains("(") || name.contains(")")) {
+      throw new IllegalArgumentException("Name can not contain any parenthesis");
+    }
+
     return new AutoValue_TaskIds(
         name,
         name.hashCode() * 1000003 ^ Objects.hash(args),
-        Arrays.asList(args));
+        argsString(args));
+  }
+
+  static TaskId parse(String stringId) {
+    final int pOpen = stringId.indexOf('(');
+    final int pClose = stringId.lastIndexOf(')');
+    final int pHash = stringId.lastIndexOf('#');
+
+    if (pOpen < 0 || pClose < pOpen || pHash < pClose) {
+      throw new IllegalArgumentException("Invalid stringId, follow 'Name(foo,bar)#deadbeef'");
+    }
+
+    final String name = stringId.substring(0, pOpen);
+    final String args = stringId.substring(pOpen + 1, pClose);
+    final String hash = stringId.substring(pHash + 1);
+
+    return new AutoValue_TaskIds(
+        name,
+        Integer.parseInt(hash, 16),
+        args);
   }
 
   @Override
   public String toString() {
-    return String.format("%s(%s)#%08x", name(), argsString(), hash());
+    return String.format("%s(%s)#%08x", name(), args(), hash());
   }
 
-  private String argsString() {
-    return args().stream()
+  private static String argsString(Object... args) {
+    return Stream.of(args)
         .map(Object::toString)
         .collect(Collectors.joining(","));
   }

workflow/src/test/java/io/rouz/task/TaskIdsTest.java

@@ -12,21 +12,46 @@ public class TaskIdsTest {
 
   @Test
   public void shouldHaveHumanReadableToString() {
-    TaskId taskId = TaskIds.create("MyTask", "a", 1, 2.3, new Param(7));
+    TaskId taskId = TaskId.create("MyTask", "a", 1, 2.3, new Param(7));
 
     assertThat(taskId.toString(), startsWith("MyTask(a,1,2.3,Param{arg=7})"));
   }
 
   @Test
   public void shouldHaveIdentity() {
-    TaskId taskId1 = TaskIds.create("MyTask", "a", 1, 2.3, new Param(7));
-    TaskId taskId2 = TaskIds.create("MyTask", "a", 1, 2.3, new Param(7));
+    TaskId taskId1 = TaskId.create("MyTask", "a", 1, 2.3, new Param(7));
+    TaskId taskId2 = TaskId.create("MyTask", "a", 1, 2.3, new Param(7));
 
     assertThat(taskId1, not(sameInstance(taskId2)));
     assertThat(taskId1, equalTo(taskId2));
     assertThat(taskId2, equalTo(taskId1));
   }
 
+  @Test
+  public void parsedIdEqualToActual() throws Exception {
+    TaskId taskId1 = TaskId.create("MyTask", "a", 1, 2.3, new Param(7));
+    TaskId taskId2 = TaskId.parse(taskId1.toString());
+
+    assertThat(taskId1, not(sameInstance(taskId2)));
+    assertThat(taskId1, equalTo(taskId2));
+    assertThat(taskId2, equalTo(taskId1));
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void shouldNotAllowOpenParenthesisInName() throws Exception {
+    TaskId.create("MyTa(sk");
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void shouldNotAllowCloseParenthesisInName() throws Exception {
+    TaskId.create("MyTa)sk");
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void shouldNotParseInvalidId() throws Exception {
+    TaskId.parse("Wat)#(123)#hello");
+  }
+
   private static class Param {
 
     private final int arg;