wolflow 0.0.1

data/lib/wolflow/workflow.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class Workflow
+    attr_reader :id, :workflow_spec, :root, :data
+
+    def initialize(
+      workflow_spec:,
+      id: object_id,
+      root: Task.new(task_spec: workflow_spec.start, workflow: self),
+      data: {}
+    )
+      @id = id
+      @workflow_spec = workflow_spec
+      @data = data
+
+      raise Error, "#{root} has no task spec" unless root.task_spec
+
+      if root.task_spec && @workflow_spec != root.task_spec.workflow_spec
+        raise Error, "#{root} is from a different workflow spec"
+      end
+
+      @root = root
+    end
+
+    def each(&)
+      @root.each(&)
+    end
+
+    def complete_one
+      each do |task|
+        next if task.completed?
+
+        task.complete!
+
+        return task if task.completed?
+      end
+      nil
+    end
+
+    def complete_all
+      while complete_one do; end
+    end
+
+    def to_hash
+      {
+        id: @id,
+        workflow_spec: @workflow_spec.to_hash,
+        tasks: each.map(&:to_hash),
+        data: @data.to_hash
+      }
+    end
+
+    class << self
+      def from_hash(hash)
+        workflow_spec = WorkflowSpec.from_hash(hash[:workflow_spec])
+
+        # @type var tasks: Hash[String, Task]
+        tasks = {}
+
+        hash[:tasks].each do |task_hash|
+          task_spec_id = task_hash.delete(:task_spec_id)
+          task_hash[:task_spec] = workflow_spec.each.find do |task_spec|
+            task_spec.id == task_spec_id
+          end || raise(Error, "no task spec found for `#{task_spec_id}`)")
+          task = Task.from_hash(task_hash)
+          tasks[task.id] = task
+        end
+
+        tasks.each_value do |task|
+          task.connects_with(tasks)
+        end
+
+        start_task = tasks.each_value.find do |task|
+          task.parents.empty?
+        end or raise WorkflowError, "no start task found"
+
+        new(id: hash[:id], root: start_task, workflow_spec: workflow_spec, data: hash[:data])
+      end
+    end
+  end
+end

data/lib/wolflow/workflow_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class WorkflowSpec
+    attr_reader :id, :start
+
+    def initialize(id: object_id.to_s, start: Start.new(workflow_spec: self))
+      @id = id
+      @start = start
+    end
+
+    def connect(*task_specs)
+      if @start
+        @start.connect(*task_specs)
+      else
+        start_task = task_specs.first
+        if start_task.workflow_spec && start_task.workflow_spec != self
+          raise TaskSpecError, "#{start_task} already defined in a workflow spec"
+        end
+
+        start_task.workflow_spec = self
+        @start = start_task
+      end
+
+      if block_given?
+        yield(*task_specs)
+        return self
+      end
+
+      return task_specs.first if task_specs.size <= 1
+
+      task_specs
+    end
+
+    def each(&blk)
+      return unless @start
+
+      return enum_for(__method__) unless blk
+
+      blk.call(@start)
+
+      @start.each_successor([self], &blk)
+    end
+
+    def to_hash
+      {
+        id: @id,
+        task_specs: @start ? @start.to_hash_tree.uniq : []
+      }
+    end
+
+    class << self
+      def from_hash(hash)
+        workflow_spec = new(id: hash[:id], start: nil)
+
+        # @type var tasks: Hash[String, TaskSpec]
+        tasks = {}
+
+        hash[:task_specs].each do |task_hash|
+          raise Error, "no :name found" unless task_hash.key?(:name)
+
+          cls = TaskSpec.spec_types[task_hash[:name]]
+          task_hash[:workflow_spec] = workflow_spec
+          task_spec = cls.from_hash(task_hash)
+          tasks[task_spec.id] = task_spec
+        end
+
+        tasks.each_value do |task_spec|
+          task_spec.connects_with(tasks)
+        end
+
+        start_task = tasks.each_value.find do |spec|
+          spec.prev_tasks.empty?
+        end or raise WorkflowSpecError, "no start task found"
+
+        workflow_spec.connect(start_task)
+
+        workflow_spec
+      end
+    end
+  end
+end

data/lib/wolflow.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "wolflow/version"
+
+module Wolflow
+end
+
+require_relative "wolflow/errors"
+require_relative "wolflow/extensions"
+require_relative "wolflow/operators/base"
+require_relative "wolflow/workflow_spec"
+require_relative "wolflow/task_spec"
+require_relative "wolflow/simple"
+require_relative "wolflow/simple_merge"
+require_relative "wolflow/synchronization"
+require_relative "wolflow/multi_choice"
+require_relative "wolflow/exclusive_choice"
+require_relative "wolflow/structured_synchronized_merge"
+require_relative "wolflow/multi_merge"
+require_relative "wolflow/cycle"
+require_relative "wolflow/structured_loop"
+require_relative "wolflow/recursion"
+require_relative "wolflow/start"
+require_relative "wolflow/task"
+require_relative "wolflow/workflow"

data/sig/cycle.rbs

@@ -0,0 +1,7 @@
+module Wolflow
+  class Cycle < Simple
+    private
+
+    def reset_task: (Task task) -> void
+  end
+end

data/sig/dsl.rbs

@@ -0,0 +1,36 @@
+module Wolflow
+  module DSL
+    def self.load!: () -> void
+
+    module WolflowDSL
+      def spec: (String id) ?{ (WorkflowSpec) -> void } -> (WorkflowSpec & WorkflowSpecDSL)
+    end
+
+    module WorkflowSpecDSL
+      def connect:  (*String ids) { (*simple task_specs) -> void } -> self
+                  | (*String ids) -> Array[simple]
+                  | (*TaskSpec task_specs) { (*TaskSpec task_specs) -> void } -> self
+                  | (*TaskSpec task_specs) -> Array[TaskSpec]
+    end
+
+    module SimpleDSL
+      @on_complete_callbacks: Array[^(Task task) -> void]
+
+      def on_perform: () { (Task task) -> void } -> self
+
+      def connect: (*String ids) { (*simple task_specs) -> void } -> self
+                 | (*String ids) -> Array[simple]
+                 | (*TaskSpec task_specs) { (*TaskSpec task_specs) -> void } -> self
+                 | (*TaskSpec task_specs) -> Array[TaskSpec]
+
+      def choose: (*String ids, **untyped) ?{ (choice choice, *simple else_task_specs) -> void } -> Array[simple]# [choice, *simple]
+                | (*TaskSpec else_task_specs, **untyped) ?{ (ExclusiveChoice choice, *TaskSpec else_task_specs) -> void } -> Array[TaskSpec]# [ExclusiveChoice, *TaskSpec]
+    end
+
+    module ChoiceDSL
+    end
+
+    type simple = Simple & SimpleDSL
+    type choice = ExclusiveChoice & ChoiceDSL
+  end
+end

data/sig/exclusive_choice.rbs

@@ -0,0 +1,12 @@
+module Wolflow
+  class ExclusiveChoice < MultiChoice
+
+    attr_reader else_tasks: Array[TaskSpec]
+
+    def connect_else: (*TaskSpec task_specs) -> (Array[TaskSpec] | TaskSpec)
+
+    private
+
+    def initialize: (?else_tasks: Array[TaskSpec], **untyped) -> void
+  end
+end

data/sig/multi_choice.rbs

@@ -0,0 +1,23 @@
+module Wolflow
+  class MultiChoice < TaskSpec
+    interface _Call
+      def call: (Task task) -> untyped
+    end
+
+    type condition = Operators::Base | (Object & _Call)
+
+    attr_reader condition_next_tasks: Array[[condition, Array[TaskSpec]]] # Array[[condition, *TaskSpec]]
+
+    # TODO: remove :reset_task when rbs allows overriding attr_writer in subclass
+    attr_writer connects_to: Hash[:reset_task | :condition_next_tasks | :else_tasks, untyped]
+
+    def connect: (condition condition, *TaskSpec task_specs) { (*TaskSpec tasks) -> void } -> self
+    | (condition condition, *TaskSpec task_specs) -> Array[TaskSpec]# [ExclusiveChoice, *TaskSpec]
+
+    private
+
+    def initialize: (?condition_next_tasks: Array[TaskSpec], **untyped) -> void
+
+    def connect_cond: (condition condition, Array[TaskSpec]) -> void
+  end
+end

data/sig/multi_merge.rbs

@@ -0,0 +1,6 @@
+module Wolflow
+  class MultiMerge < Simple
+
+    def join: (*Simple task_specs) -> self
+  end
+end

data/sig/operators/attribute.rbs

@@ -0,0 +1,11 @@
+module Wolflow
+  module Operators
+    class Attribute < Base
+      @name: interned
+
+      private
+
+      def initialize: (name: interned, **untyped) -> void
+    end
+  end
+end

data/sig/operators/base.rbs

@@ -0,0 +1,21 @@
+module Wolflow
+  module Operators
+    class Base
+      @type: String
+
+      attr_reader self.op_type: String
+
+      public
+
+      def self.from_hash: (Hash[Symbol, untyped] hash) -> Hash[Symbol, untyped]
+
+      def call: (Task task) -> untyped
+
+      def to_hash: () -> Hash[Symbol, untyped]
+
+      private
+
+      def initialize: (?type: String) -> void
+    end
+  end
+end

data/sig/operators/literal.rbs

@@ -0,0 +1,15 @@
+module Wolflow
+  module Operators
+    class Literal < Base
+      @value: untyped
+
+      public
+
+      def call: (*untyped) -> untyped
+
+      private
+
+      def initialize: (value: untyped, **untyped) -> void
+    end
+  end
+end

data/sig/operators/operation.rbs

@@ -0,0 +1,10 @@
+module Wolflow
+  module Operators
+    class Operation < Base
+      @op: interned
+      @members: Array[Base]
+
+      def initialize: (op: interned, members: Array[Base], **untyped) -> void
+    end
+  end
+end

data/sig/operators.rbs

@@ -0,0 +1,7 @@
+module Wolflow
+  module Operators
+    attr_reader self.op_types: Hash[String, singleton(Base)]
+
+    def self.from_hash: (Hash[Symbol, untyped] hash) -> Base
+  end
+end

data/sig/recursion.rbs

@@ -0,0 +1,4 @@
+module Wolflow
+  class Recursion < Simple
+  end
+end

data/sig/simple.rbs

@@ -0,0 +1,22 @@
+module Wolflow
+  class Simple < TaskSpec
+    @next_tasks: Array[TaskSpec]
+
+    attr_writer connects_to: Array[String]
+
+    public
+
+    def choose: (*TaskSpec else_task_specs, **untyped) ?{ (ExclusiveChoice choice, *TaskSpec else_task_specs) -> void } -> Array[TaskSpec]# [ExclusiveChoice, *TaskSpec]
+
+    def connect: (*TaskSpec task_specs) { (*TaskSpec tasks) -> void } -> self
+               | (*TaskSpec task_specs) -> Array[TaskSpec]# [ExclusiveChoice, *TaskSpec]
+
+    def workflow_spec=: (WorkflowSpec workflow_spec) -> void
+
+    private
+
+    def connect_one: (TaskSpec task_spec) -> void
+
+    def initialize: (?next_tasks: Array[TaskSpec], **untyped) -> void
+  end
+end

data/sig/simple_merge.rbs

@@ -0,0 +1,6 @@
+module Wolflow
+  class SimpleMerge < Simple
+
+    def join: (*Simple task_specs) -> self
+  end
+end

data/sig/start.rbs

@@ -0,0 +1,4 @@
+module Wolflow
+  class Start < Simple
+  end
+end

data/sig/structured_loop.rbs

@@ -0,0 +1,8 @@
+module Wolflow
+  class StructuredLoop < ExclusiveChoice
+
+    private
+
+    def reset_task: (Task task) -> void
+  end
+end

data/sig/structured_synchronized_merge.rbs

@@ -0,0 +1,6 @@
+module Wolflow
+  class StructuredSynchronizedMerge < Simple
+
+    def join: (*Simple task_specs) -> self
+  end
+end

data/sig/synchronization.rbs

@@ -0,0 +1,6 @@
+module Wolflow
+  class Synchronization < Simple
+
+    def join: (*Simple task_specs) -> self
+  end
+end

data/sig/task.rbs

@@ -0,0 +1,66 @@
+module Wolflow
+  class Task
+    type record = {
+      id: String,
+      parents: Array[String],
+      children: Array[String],
+      completed: bool,
+      task_spec_id: String?
+    }
+
+    def self.from_hash: (untyped hash) -> instance
+
+    attr_reader id: String
+
+    attr_reader task_spec: TaskSpec
+
+    attr_reader workflow: Workflow?
+
+    attr_reader completed: bool
+
+    attr_reader root: Task
+
+    attr_reader parents: Array[Task]
+
+    attr_reader children: Array[Task]
+
+    attr_reader data: Hash[untyped, untyped]
+
+    public
+
+    def build_task_tree: () -> void
+
+    def complete!: () -> void
+
+    def completed?: () -> bool
+
+    def connect: (*Task tasks) { (*Task tasks) -> void } -> self
+               | (*Task tasks) -> Array[Task]
+
+    def copy_task_tree: (Integer i) -> void
+
+    def disconnect: (Task task) -> void
+
+    def each: (?Array[Task] visited) { (Task task) -> void } -> self
+            | (?Array[Task] visited) -> Enumerator[Task, self]
+
+    def each_parent: (?Array[Task] visited) { (Task task) -> void } -> self
+                   | (?Array[Task] visited) -> Enumerator[Task, self]
+
+    def mark_as_complete!: () -> void
+
+    def reset!: () -> void
+
+    def to_hash: () -> record
+
+    def root=: (Task rt) -> void
+
+    def connects_with: (Hash[String, Task] tasks) -> void
+
+    private
+
+    def connect_one: (Task task) -> void
+
+    def initialize: (?id: String, ?task_spec: TaskSpec, ?workflow: Workflow, ?completed: bool, ?root: Task, ?parents: Array[Task], ?children: Array[Task], ?data: Hash[untyped, untyped]) -> void
+  end
+end

data/sig/task_spec.rbs

@@ -0,0 +1,52 @@
+module Wolflow
+  class TaskSpec
+    def self.from_hash: (Hash[Symbol, untyped] hash) -> TaskSpec
+
+    def self.spec_type: () -> String
+
+    def self.spec_types: () -> Hash[String, singleton(TaskSpec)]
+
+    attr_reader id: String
+    attr_reader name: String
+    attr_reader workflow_spec: WorkflowSpec
+    attr_reader prev_tasks: Array[TaskSpec]
+
+    public
+
+    def on_complete: (Task task) -> void
+
+    def next_tasks: () -> Array[TaskSpec]
+
+    def child_of?: (TaskSpec spec) -> bool
+
+    def each_ancestor: (?Array[TaskSpec] visited) { (TaskSpec spec) -> void } -> void
+                     | (?Array[TaskSpec] visited) -> ::Enumerator[TaskSpec, void]
+
+    def each_successor: (?Array[TaskSpec] visited) { (TaskSpec spec) -> void } -> void
+                      | (?Array[TaskSpec] visited) -> ::Enumerator[TaskSpec, void]
+
+    def each_child: (Task task) { (Task task) -> void } -> void
+                     | (Task task) -> ::Enumerator[Task, void]
+
+    def each_parent: (Task task) { (Task task) -> void } -> void
+                   | (Task task) -> ::Enumerator[Task, void]
+
+    def to_hash: () -> Hash[Symbol, untyped]
+
+    def to_hash_tree: () -> Array[Hash[Symbol, untyped]]
+
+    def precedes?: (TaskSpec task_spec) -> void
+
+    def workflow_spec=: (untyped workflow_spec) -> untyped
+
+    def connects_with: (Hash[String, TaskSpec] tasks) -> void
+
+    def build_next_tasks: (Task task, ?i: Integer, ?next_tasks: Array[TaskSpec]) -> void
+
+    private
+
+    def initialize: (?id: String, ?name: String, ?workflow_spec: WorkflowSpec, ?prev_tasks: Array[TaskSpec]) -> void
+
+    def predict: (Task task, Array[TaskSpec] next_tasks) -> void
+  end
+end

data/sig/wolflow.rbs

@@ -0,0 +1,18 @@
+module Wolflow
+  VERSION: String
+
+  class Error < StandardError
+  end
+
+  class TaskError < Error
+  end
+
+  class TaskSpecError < Error
+  end
+
+  class WorkflowError < Error
+  end
+
+  class WorkflowSpecError < Error
+  end
+end

data/sig/workflow.rbs

@@ -0,0 +1,33 @@
+module Wolflow
+  class Workflow
+    type record = {
+      id: String,
+      workflow_spec: WorkflowSpec::record,
+      tasks: Array[Task::record],
+      data: Hash[untyped, untyped]
+    }
+
+    attr_reader id: String
+
+    attr_reader workflow_spec: WorkflowSpec
+
+    attr_reader root: Task
+
+    attr_reader data: Hash[untyped, untyped]
+
+    def self.from_hash: (untyped hash) -> instance
+
+    def complete_all: () -> untyped
+
+    def complete_one: () -> Task?
+
+    def each: () { (Task task) -> void } -> self
+            | () -> Enumerator[Task, self]
+
+    def to_hash: () -> record
+
+    private
+
+    def initialize: (workflow_spec: WorkflowSpec, ?id: String, ?root: Task, ?data: Hash[untyped, untyped]) -> void
+  end
+end

data/sig/workflow_spec.rbs

@@ -0,0 +1,20 @@
+module Wolflow
+  class WorkflowSpec
+    type record = { id: String, task_specs: Array[Array[Hash[Symbol, untyped]]] }
+
+    attr_reader id: String
+
+    attr_reader start: Simple?
+
+    def self.from_hash: (untyped hash) -> instance
+
+    def connect: (*TaskSpec task_specs) { (*TaskSpec task_specs) -> void } -> self
+               | (*TaskSpec task_specs) -> Array[TaskSpec]
+
+    def to_hash: () -> record
+
+    private
+
+    def initialize: (?id: String, ?start: Simple?) -> void
+  end
+end