wolflow 0.0.1

data/lib/wolflow/simple.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class Simple < TaskSpec
+    attr_reader :next_tasks
+
+    def initialize(next_tasks: [], **kwargs)
+      super(**kwargs)
+      @next_tasks = next_tasks
+    end
+
+    def on_complete(task)
+      task.mark_as_complete!
+
+      predict(task, @next_tasks)
+    end
+
+    def connect(*task_specs)
+      task_specs.each do |task_spec|
+        connect_one(task_spec)
+      end
+
+      if block_given?
+        yield(*task_specs)
+        return self
+      end
+
+      return task_specs.first if task_specs.size <= 1
+
+      task_specs
+    end
+
+    def choose(*else_task_specs, **args)
+      choice = ExclusiveChoice.new(workflow_spec: @workflow_spec, else_tasks: else_task_specs, **args)
+      next_tasks << choice
+      choice.prev_tasks << self
+
+      if block_given?
+        yield(choice, *else_task_specs)
+        return self
+      end
+
+      [choice, *else_task_specs]
+    end
+
+    def precedes?(task_spec)
+      @next_tasks.include?(task_spec)
+    end
+
+    def to_hash
+      {
+        id: @id,
+        name: @name,
+        next_tasks: @next_tasks.map(&:id)
+      }
+    end
+
+    def to_hash_tree
+      hash_tree = @next_tasks.flat_map(&:to_hash_tree)
+      hash_tree.unshift(to_hash)
+      hash_tree
+    end
+
+    def inspect
+      "#<#{self.class}:#{hash} " \
+        "@id=#{@id} " \
+        "@next_tasks=#{@next_tasks.map(&:id)}>"
+    end
+
+    def workflow_spec=(workflow_spec)
+      return if workflow_spec == @workflow_spec
+
+      super
+
+      @next_tasks.each do |task_spec|
+        task_spec.workflow_spec = workflow_spec
+      end
+    end
+
+    # private-ish
+    def connects_with(tasks)
+      return unless @connects_to
+
+      @connects_to.each do |id|
+        connect(tasks.fetch(id))
+      end
+
+      @connects_to = nil
+    end
+
+    def build_next_tasks(task, i: 0, next_tasks: @next_tasks)
+      children = next_tasks.map do |next_task|
+        id = next_task.id
+        id = "#{id}_#{i}" unless i.zero?
+        task.class.new(
+          id: id,
+          task_spec: next_task,
+          workflow: task.workflow,
+          root: task.root
+        )
+      end
+      task.connect(*children)
+      children.each do |child|
+        child.task_spec.build_next_tasks(child, i: i)
+      end
+    end
+
+    private
+
+    def connect_one(task_spec)
+      if @workflow_spec
+        task_spec.workflow_spec = @workflow_spec
+      elsif task_spec.workflow_spec
+        raise TaskSpecError, "#{task_spec} already defined in a workflow spec"
+      end
+
+      task_spec.prev_tasks << self
+      @next_tasks << task_spec
+    end
+
+    class << self
+      def from_hash(hash)
+        case hash
+        in { next_tasks: [*, String, *] => next_tasks, **args }
+          spec = super(**args)
+          spec.connects_to = next_tasks
+          spec
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/wolflow/simple_merge.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class SimpleMerge < Simple
+    def join(*task_specs)
+      task_specs.each { |spec| spec.connect(self) }
+
+      self
+    end
+
+    def on_complete(task)
+      return unless task.parents.one?(&:completed?)
+
+      task.parents.each { |parent| parent.disconnect(task) unless parent.completed? }
+
+      super
+    end
+  end
+end

data/lib/wolflow/start.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class Start < Simple
+    def initialize(**args)
+      super(id: "start", **args)
+    end
+  end
+end

data/lib/wolflow/structured_loop.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class StructuredLoop < ExclusiveChoice
+    def connect(condition, *task_specs)
+      raise TaskSpecError, "can only link with one parent" unless task_specs.size == 1
+
+      # @type var task_spec: TaskSpec
+      task_spec = task_specs.first
+
+      raise TaskSpecError, "can only link with parent" unless child_of?(task_spec)
+
+      super
+    end
+
+    def on_complete(task)
+      @condition_next_tasks.each do |cond, next_tasks|
+        next unless cond.call(task)
+
+        parent_task = task.children.find { |child_task| next_tasks.include?(child_task.task_spec) }
+
+        raise Error, "parent task not found for #{task}" unless parent_task
+
+        reset_task(parent_task)
+
+        return # rubocop:disable Lint/NonLocalExitFromIterator
+      end
+      task.mark_as_complete!
+
+      predict(task, @else_tasks)
+    end
+
+    def to_hash
+      hs = super
+      hs[:reset_task] = hs.delete(:condition_next_tasks).first
+      hs[:else_tasks] = hs.delete(:else_tasks)
+      hs
+    end
+
+    def each_child(task, &blk)
+      super(task) do |child|
+        next unless task.task_spec.else_tasks.include?(child.task_spec)
+
+        blk.call(child)
+      end
+    end
+
+    # private-ish
+    def connects_with(tasks)
+      return unless @connects_to
+
+      cond, id = @connects_to.fetch(:reset_task)
+      cond = Operators.from_hash(cond)
+      reset_task = tasks[id]
+      reset_task.connects_with(tasks)
+      connect(cond, reset_task)
+      connect_else(*@connects_to.fetch(:else_tasks).map(&tasks.method(:[])))
+    end
+
+    private
+
+    def connect_cond(condition, task_specs)
+      @condition_next_tasks << [condition, task_specs]
+    end
+
+    def predict(task, next_tasks); end
+
+    def reset_task(task)
+      task.reset!
+
+      task.task_spec.each_child(task) do |child_task|
+        next unless child_of?(child_task.task_spec)
+
+        next if self == child_task.task_spec
+
+        reset_task(child_task)
+      end
+    end
+
+    class << self
+      def from_hash(hash)
+        case hash
+        in {
+          reset_task: [{ type: String, **}, TaskSpec],
+          else_tasks: [*, TaskSpec, *] => else_tasks,
+          **args
+         }
+          super
+        in {
+          reset_task: [{ type: String, **}, String] => reset_task,
+          else_tasks: [*, String, *] => else_tasks,
+          **args
+          }
+          spec = super(**args)
+          spec.connects_to = {
+            reset_task: reset_task,
+            else_tasks: else_tasks
+          }
+          spec
+        else # rubocop:disable Lint/DuplicateBranch
+          super
+        end
+      end
+    end
+  end
+end

data/lib/wolflow/structured_synchronized_merge.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class StructuredSynchronizedMerge < Simple
+    def join(*task_specs)
+      multi_choices = task_specs.map do |task_spec|
+        task_spec.each_ancestor.find do |spec|
+          spec.is_a?(MultiChoice)
+        end or raise(TaskSpecError, "#{task_spec.id} is not from a multi-choice branch")
+      end
+
+      raise TaskSpecError, "not branches from the same multi-choice" unless multi_choices.uniq.size == 1
+
+      # @type var multi_choice: MultiChoice
+      multi_choice = multi_choices.first
+
+      unless multi_choice.next_tasks.size == multi_choices.size
+        raise TaskSpecError,
+              "not joining all branches from the common multi-choice"
+      end
+
+      task_specs.each { |spec| spec.connect(self) }
+
+      self
+    end
+
+    def on_complete(task)
+      parents_with_multi_choice = task.parents.select(&:completed?).filter_map do |parent|
+        multi_choice = parent.each_parent.find { |t| t.task_spec.is_a?(MultiChoice) }
+        [parent, multi_choice] if multi_choice
+      end
+
+      multi_choices = parents_with_multi_choice.map(&:last).uniq
+
+      return unless multi_choices.size == 1
+
+      # @type var multi_choice: Task
+      multi_choice = multi_choices.first
+
+      return unless multi_choice.children.size == parents_with_multi_choice.size
+
+      super
+    end
+  end
+end

data/lib/wolflow/synchronization.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class Synchronization < Simple
+    def join(*task_specs)
+      task_specs.each { |spec| spec.connect(self) }
+
+      self
+    end
+
+    def on_complete(task)
+      return unless task.parents.all?(&:completed?)
+
+      super
+    end
+  end
+end

data/lib/wolflow/task.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class Task
+    attr_reader :id, :task_spec, :root, :workflow, :parents, :children, :data
+
+    def initialize(
+      id: object_id.to_s,
+      task_spec: nil,
+      workflow: nil,
+      completed: false,
+      root: nil,
+      parents: [],
+      children: [],
+      data: {}
+    )
+      @id = id
+      @task_spec = task_spec
+      @completed = completed
+      @workflow = workflow
+      @root = root
+      @parents = parents
+      @children = children
+      @data = data
+    end
+
+    def initialize_dup(other)
+      super
+      @parents = other.instance_variable_get(:@parents).dup
+      @children = other.instance_variable_get(:@children).dup
+      @data = other.instance_variable_get(:@data).dup
+    end
+
+    def initialize_clone(other, **kwargs)
+      super
+      @parents = other.instance_variable_get(:@parents).clone(**kwargs)
+      @children = other.instance_variable_get(:@children).clone(**kwargs)
+      @data = other.instance_variable_get(:@data).clone(**kwargs)
+    end
+
+    def completed?
+      @completed
+    end
+
+    def complete!
+      @task_spec.on_complete(self) if @task_spec
+    end
+
+    def mark_as_complete!
+      @completed = true
+    end
+
+    def reset!
+      @completed = false
+    end
+
+    def connect(*tasks)
+      tasks.each do |task|
+        connect_one(task)
+      end
+
+      if block_given?
+        yield(*tasks)
+        return self
+      end
+
+      return tasks.first if tasks.size <= 1
+
+      tasks
+    end
+
+    def disconnect(task)
+      unless @children.include?(task) && task.parents.include?(self)
+        raise TaskError, "#{self} and #{task} are not connected"
+      end
+
+      task.parents.delete(self)
+      @children.delete(task)
+    end
+
+    def build_task_tree
+      raise TaskError, "there's already a task tree" unless @children.empty?
+
+      @task_spec.build_next_tasks(self)
+    end
+
+    def copy_task_tree(i)
+      @task_spec.build_next_tasks(self, i: i)
+    end
+
+    def each(visited = [], &blk)
+      return enum_for(__method__, visited) unless blk
+
+      blk.call(self) unless @task_spec.id.start_with?("__")
+
+      visited << self
+
+      @task_spec.each_child(self) do |child|
+        # do not allow multiple visits on the same node
+        next if visited.include?(child)
+
+        if child.task_spec.is_a?(Synchronization) && !child.parents.all? { |parent| visited.include?(parent) }
+          # only jump in after all parents are consumed
+          next
+        end
+
+        child.each(visited, &blk)
+      end
+      self
+    end
+
+    def each_parent(visited = [self], &blk)
+      return enum_for(__method__, visited) unless blk
+
+      @task_spec.each_parent(self) do |parent|
+        # do not allow multiple visits on the same node
+        next if visited.include?(parent)
+
+        visited << parent
+
+        blk.call(parent)
+
+        parent.each_parent(visited, &blk)
+      end
+      self
+    end
+
+    def inspect
+      "#<#{self.class}:#{hash} " \
+        "@id=#{@id} " \
+        "@parents=#{@parents.map(&:id)} " \
+        "@children=#{@children.map(&:id)} " \
+        "@completed=#{@completed}>"
+    end
+
+    # private-ish
+    def connects_with(tasks)
+      @parents = @parents.map do |parent|
+        parent.is_a?(Task) ? parent : tasks.fetch(parent)
+      end
+      @children = @children.map do |child|
+        child.is_a?(Task) ? child : tasks.fetch(child)
+      end
+    end
+
+    def to_hash
+      {
+        id: @id,
+        parents: @parents.map(&:id),
+        children: @children.map(&:id),
+        completed: @completed,
+        data: (@data.to_hash unless @data.empty?),
+        task_spec_id: (@task_spec.id if @task_spec)
+      }.compact
+    end
+
+    class << self
+      def from_hash(hash)
+        if hash.key?(:task_spec) && !hash[:task_spec].is_a?(TaskSpec)
+          task_spec = TaskSpec.spec_types[hash[:task_spec]]
+
+          raise Error, "no task spec registered for #{hash[:task_spec]}" unless task_spec
+
+          hash[:task_spec] = task_spec.new
+        end
+
+        new(**hash)
+      end
+    end
+
+    protected
+
+    def root=(rt)
+      @root = rt
+      @children.each do |task|
+        task.root = rt
+      end
+    end
+
+    private
+
+    def connect_one(task)
+      raise TaskError, "#{task} is from a different workflow" if @workflow && @workflow != task.workflow
+
+      unless @task_spec.nil? || @task_spec.precedes?(task.task_spec)
+        raise TaskError,
+              "#{task} can't connect from task spec"
+      end
+
+      task.parents << self
+      task.root = @root || self
+      @children << task
+    end
+  end
+end

data/lib/wolflow/task_spec.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class TaskSpec
+    using StringExtensions unless ::String.method_defined?(:underscore)
+
+    attr_reader :id, :name, :workflow_spec, :prev_tasks
+
+    attr_writer :connects_to
+
+    def initialize(id: object_id.to_s, name: self.class.spec_type, workflow_spec: nil, prev_tasks: [])
+      @id = id
+      @name = name
+      @workflow_spec = workflow_spec
+      @prev_tasks = prev_tasks
+    end
+
+    def each_child(task, &)
+      task.children.each(&)
+    end
+
+    def each_parent(task, &)
+      task.parents.each(&)
+    end
+
+    def each_successor(visited = [self], &blk)
+      return enum_for(__method__, visited) unless blk
+
+      next_tasks.each do |spec|
+        next if visited.include?(spec)
+
+        blk.call(spec)
+
+        visited << spec
+
+        spec.each_successor(visited, &blk)
+      end
+    end
+
+    def each_ancestor(visited = [self], &blk)
+      return enum_for(__method__, visited) unless blk
+
+      @prev_tasks.each do |spec|
+        next if visited.include?(spec)
+
+        blk.call(spec)
+
+        visited << spec
+
+        spec.each_ancestor(visited, &blk)
+      end
+    end
+
+    def workflow_spec=(workflow_spec)
+      if @workflow_spec
+        return if workflow_spec == @workflow_spec
+
+        raise TaskSpecError, "#{self} already defined in a workflow spec"
+      end
+
+      @workflow_spec = workflow_spec
+    end
+
+    def child_of?(spec)
+      spec.next_tasks.include?(self) || spec.next_tasks.one? { |child_spec| child_of?(child_spec) }
+    end
+
+    private
+
+    def predict(task, next_tasks)
+      return unless task.children.empty?
+
+      next_tasks.each do |task_spec|
+        task.connect(Task.new(task_spec: task_spec, workflow: task.workflow))
+      end
+    end
+
+    @spec_types = {}
+
+    class << self
+      attr_reader :spec_types, :spec_type
+
+      def inherited(subclass)
+        super
+
+        return superclass.inherited(subclass) unless self == TaskSpec
+
+        name = subclass.name
+
+        return unless name # anon class
+
+        tag = name.demodulize.underscore
+
+        raise Error, "spec type for #{tag} already exists" if @spec_types.key?(tag)
+
+        subclass.instance_variable_set(:@spec_type, tag)
+        subclass.instance_variable_get(:@spec_type).freeze
+
+        @spec_types[tag] = subclass
+      end
+
+      def from_hash(hash)
+        case hash
+        in { id: String => id, name: String => name, ** }
+          TaskSpec.spec_types[name].new(**hash)
+        in { id: String => id }
+          new(id: id)
+        else
+          raise TaskSpecError, "can't deserialize #{hash} to a TaskSpec"
+        end
+      end
+    end
+  end
+end

data/lib/wolflow/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Wolflow
+  VERSION = "0.0.1"
+end