wolflow 0.0.1

data/lib/wolflow/cycle.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class Cycle < Simple
+    def connect(*specs)
+      raise TaskSpecError, "cycles can only connect to a single task spec" unless specs.size == 1
+
+      spec = specs.first
+
+      raise TaskSpecError, "cycles can only connect to previous task specs" unless child_of?(spec)
+
+      super
+    end
+
+    def on_complete(task)
+      super
+
+      task.children.each do |child_task|
+        next if task == child_task
+
+        reset_task(child_task)
+      end
+
+      task.reset!
+    end
+
+    def to_hash_tree
+      [to_hash]
+    end
+
+    def each_child(task); end
+
+    # def each_parent(task); end
+
+    private
+
+    def predict(task, next_tasks)
+      return unless task.children.empty?
+
+      workflow = task.workflow
+
+      return unless workflow
+
+      tasks = workflow.each.each_with_object([]) do |wtask, wtasks| # rubocop:disable Style/RedundantEach
+        next unless next_tasks.include?(wtask.task_spec)
+
+        wtasks << wtask
+
+        break if wtasks.size == next_tasks.size
+      end
+
+      task.connect(*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
+  end
+end

data/lib/wolflow/dsl.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "wolflow"
+
+module Wolflow
+  module DSL
+    def self.load!
+      WorkflowSpec.prepend(WorkflowSpecDSL)
+      Simple.prepend(SimpleDSL)
+      MultiChoice.prepend(ChoiceDSL)
+      Wolflow.extend(WolflowDSL)
+    end
+
+    module WolflowDSL
+      def spec(id, &blk)
+        wf = WorkflowSpec.new(id: id)
+
+        blk.call(wf) if blk
+
+        wf
+      end
+    end
+
+    module WorkflowSpecDSL
+      def connect(*ids, &)
+        return super unless ids.all?(String)
+
+        specs = ids.map { |id| Simple.new(id: id) }
+
+        super(*specs, &)
+      end
+    end
+
+    module SimpleDSL
+      def initialize(...)
+        @on_complete_callbacks = []
+        super
+      end
+
+      def on_perform(&blk)
+        @on_complete_callbacks << blk
+
+        self
+      end
+
+      def on_complete(task)
+        @on_complete_callbacks.each do |blk|
+          blk.call(task)
+        end
+
+        super
+      end
+
+      def connect(*ids, &)
+        return super unless ids.all?(String)
+
+        specs = ids.map { |id| Simple.new(id: id, workflow_spec: @workflow_spec) }
+
+        super(*specs, &)
+      end
+
+      def choose(*ids, **, &)
+        return super unless ids.all?(String) && ids.size > 1
+
+        if_id, *else_ids = ids
+
+        else_specs = else_ids.map { |else_id| Simple.new(id: else_id, workflow_spec: @workflow_spec) }
+
+        super(*else_specs, id: if_id, &)
+      end
+
+      def join(id, *task_specs)
+        synch = Synchronization.new(id: id, workflow_spec: @workflow_spec)
+
+        synch.join(self, *task_specs)
+
+        synch
+      end
+    end
+
+    module ChoiceDSL
+      def connect(*ids, cond)
+        return super unless ids.all?(String)
+
+        specs = ids.map { |id| Simple.new(id: id, workflow_spec: @workflow_spec) }
+
+        super(cond, *specs)
+      end
+    end
+  end
+
+  DSL.load!
+end

data/lib/wolflow/errors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class Error < StandardError; end
+
+  class WorkflowSpecError < Error; end
+
+  class TaskSpecError < Error; end
+
+  class WorkflowError < Error; end
+
+  class TaskError < Error; end
+end

data/lib/wolflow/exclusive_choice.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class ExclusiveChoice < MultiChoice
+    attr_reader :else_tasks
+
+    def initialize(else_tasks: [], **kwargs)
+      super(**kwargs)
+      @else_tasks = Array(else_tasks)
+
+      @else_tasks.each do |task_spec|
+        task_spec.prev_tasks << self
+
+        @workflow_spec ||= task_spec.workflow_spec
+      end
+    end
+
+    def next_tasks
+      [*super, *@else_tasks]
+    end
+
+    def on_complete(task)
+      task.mark_as_complete!
+
+      @condition_next_tasks.each do |cond, next_tasks|
+        next unless cond.call(task)
+
+        predict(task, next_tasks)
+        return # rubocop:disable Lint/NonLocalExitFromIterator
+      end
+      predict(task, @else_tasks)
+    end
+
+    def connect_else(*task_specs)
+      task_specs.each do |task_spec|
+        task_spec.prev_tasks << self
+        @else_tasks << task_spec
+
+        @workflow_spec ||= task_spec.workflow_spec
+      end
+
+      return task_specs.first if task_specs.size <= 1
+
+      task_specs
+    end
+
+    def precedes?(task_spec)
+      @else_tasks.include?(task_spec) || super
+    end
+
+    def to_hash
+      super.merge(
+        else_tasks: @else_tasks.map(&:id)
+      )
+    end
+
+    def to_hash_tree
+      [*super, *@else_tasks.flat_map(&:to_hash_tree)]
+    end
+
+    def inspect
+      "<#{self.class}:#{hash} " \
+        "@id=#{@id} " \
+        "@condition_next_tasks=#{@condition_next_tasks.map { |k, t| [k, t.map(&:id)] }} " \
+        "@else_tasks=#{@else_tasks.map(&:id)}>"
+    end
+
+    def workflow_spec=(workflow_spec)
+      return if workflow_spec == @workflow_spec
+
+      super
+
+      @else_tasks.each do |task_spec|
+        task_spec.workflow_spec = workflow_spec
+      end
+    end
+
+    # private-ish
+    def connects_with(tasks)
+      return unless @connects_to
+
+      connect_else(*@connects_to.fetch(:else_tasks).map { |id| tasks[id] })
+      super
+    end
+
+    class << self
+      def from_hash(hash)
+        case hash
+        in {
+            condition_next_tasks: [[{ type: String, **}, [*, String, *]]] => cond_tasks,
+            else_tasks: [*, String, *] => else_tasks,
+            **args
+           }
+          spec = super(**args)
+          spec.connects_to = {
+            condition_next_tasks: cond_tasks,
+            else_tasks: else_tasks
+          }
+          spec
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/wolflow/extensions.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Wolflow
+  module StringExtensions
+    refine ::String do
+      # https://github.com/jeremyevans/sequel/blob/58dd8d6e17d86cbf8809467c339be59aad54d5bf/lib/sequel/extensions/inflector.rb#L254
+      def underscore
+        gsub("::", "/").gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                       .gsub(/([a-z\d])([A-Z])/, '\1_\2').tr("-", "_").downcase
+      end
+
+      # https://github.com/jeremyevans/sequel/blob/58dd8d6e17d86cbf8809467c339be59aad54d5bf/lib/sequel/extensions/inflector.rb#L170
+      def demodulize
+        gsub(/^.*::/, "")
+      end
+    end
+  end
+end

data/lib/wolflow/multi_choice.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class MultiChoice < TaskSpec
+    attr_reader :condition_next_tasks
+
+    def initialize(condition_next_tasks: [], **kwargs)
+      super(**kwargs)
+      @condition_next_tasks = condition_next_tasks
+    end
+
+    def next_tasks
+      @condition_next_tasks.flat_map { |_, tasks| tasks }
+    end
+
+    def on_complete(task)
+      task.mark_as_complete!
+
+      succ_next_tasks = @condition_next_tasks.filter_map do |cond, next_tasks|
+        next_tasks if cond.call(task)
+      end.flatten
+      predict(task, succ_next_tasks)
+    end
+
+    def connect(condition, *task_specs)
+      raise ArgumentError, "condition must response to #call" unless condition.respond_to?(:call)
+
+      connect_cond(condition, task_specs)
+
+      if block_given?
+        yield(*task_specs)
+        return self
+      end
+
+      return task_specs.first if task_specs.size <= 1
+
+      task_specs
+    end
+
+    def build_next_tasks(task, **); end
+
+    def precedes?(task_spec)
+      @condition_next_tasks.one? { |_, tspecs| tspecs.include?(task_spec) }
+    end
+
+    def to_hash
+      {
+        id: @id,
+        name: @name,
+        condition_next_tasks: @condition_next_tasks.map do |condition, task_specs|
+          condition_hash = Hash.try_convert(condition)
+          raise Error, "can't convert #{condition} to a hash" unless condition_hash
+
+          [condition_hash, task_specs.map(&:id)]
+        end
+      }
+    end
+
+    def to_hash_tree
+      [to_hash, *@condition_next_tasks.flat_map { |_, ts| ts.flat_map(&:to_hash_tree) }]
+    end
+
+    def inspect
+      "#<#{self.class}:#{hash} " \
+        "@id=#{@id} " \
+        "@condition_next_tasks=#{@condition_next_tasks.map { |k, t| [k, t.map(&:id)] }}>"
+    end
+
+    def workflow_spec=(workflow_spec)
+      return if workflow_spec == @workflow_spec
+
+      super
+
+      @condition_next_tasks.each do |_, task_specs| # rubocop:disable Style/HashEachMethods
+        task_specs.each do |task_spec|
+          task_spec.workflow_spec = workflow_spec
+        end
+      end
+    end
+
+    # private-ish
+    def connects_with(tasks)
+      return unless @connects_to
+
+      @connects_to.fetch(:condition_next_tasks).each do |cond, ids|
+        cond = Operators.from_hash(cond)
+        connect(cond, *ids.map { |id| tasks[id] })
+      end
+
+      @connects_to = nil
+    end
+
+    private
+
+    def connect_cond(condition, task_specs)
+      @condition_next_tasks << [condition, task_specs]
+
+      task_specs.each { |task_spec| task_spec.prev_tasks << self }
+    end
+
+    def predict(task, next_tasks)
+      if task.children.empty?
+        super
+      else
+        task.children.delete_if { |child_task| !next_tasks.include?(child_task.task_spec) }
+      end
+    end
+
+    class << self
+      def from_hash(hash)
+        case hash
+        in {
+            condition_next_tasks: [[{ type: String, **}, [*, String, *]]] => cond_tasks,
+            **args
+           }
+          spec = super(**args)
+          spec.connects_to = {
+            condition_next_tasks: cond_tasks
+          }
+          spec
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/wolflow/multi_merge.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class MultiMerge < Simple
+    def join(*task_specs)
+      task_specs.each { |spec| spec.connect(self) }
+
+      self
+    end
+
+    def on_complete(task)
+      return super if task.parents.all?(&:completed?)
+
+      # build repeat tree
+      task.copy_task_tree(task.parents.size)
+
+      super
+    end
+  end
+end

data/lib/wolflow/operators/attribute.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Wolflow
+  module Operators
+    class Attribute < Base
+      def initialize(name:, **args)
+        @name = name
+        super(**args)
+      end
+
+      def call(task)
+        task.data.fetch(@name)
+      end
+
+      def to_hash
+        hs = super
+        hs[:name] = @name
+        hs
+      end
+    end
+  end
+end

data/lib/wolflow/operators/base.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Wolflow
+  module Operators
+    @op_types = {}
+
+    class << self
+      attr_reader :op_types
+
+      def from_hash(hash)
+        case hash
+        in { type: String => type, **args }
+          operator_class = Operators.op_types.fetch(type)
+          args = operator_class.from_hash(args)
+          operator_class.new(**args)
+        else
+          raise TaskSpecError, "can't deserialize #{hash} to an operator"
+        end
+      end
+    end
+
+    class Base
+      using StringExtensions unless ::String.method_defined?(:underscore)
+
+      def initialize(type: self.class.op_type)
+        @type = type
+      end
+
+      def to_hash
+        {
+          type: @type
+        }
+      end
+
+      class << self
+        attr_reader :op_type
+
+        def inherited(subclass)
+          super
+
+          return unless self == Base
+
+          name = subclass.name
+
+          return unless name # anon class
+
+          tag = name.demodulize.underscore
+
+          raise Error, "operation type for #{tag} already exists" if Operators.op_types.key?(tag)
+
+          subclass.instance_variable_set(:@op_type, tag)
+          subclass.instance_variable_get(:@op_type).freeze
+
+          Operators.op_types[tag] = subclass
+        end
+
+        def from_hash(hash)
+          hash
+        end
+      end
+    end
+  end
+end
+
+require_relative "literal"
+require_relative "attribute"
+require_relative "operation"

data/lib/wolflow/operators/literal.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Wolflow
+  module Operators
+    class Literal < Base
+      def initialize(value:, **args)
+        @value = value
+        super(**args)
+      end
+
+      def call(*)
+        @value
+      end
+
+      def to_hash
+        hs = super
+        hs[:value] = @value
+        hs
+      end
+    end
+  end
+end

data/lib/wolflow/operators/operation.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Wolflow
+  module Operators
+    class Operation < Base
+      def initialize(op:, members:, **args)
+        @op = op
+        @members = Array(members)
+        super(**args)
+      end
+
+      def call(task)
+        reducer, *members = @members
+
+        return unless reducer
+
+        reducer = reducer.call(task)
+
+        members.reduce(reducer) do |acc, member|
+          acc.__send__(@op, member.call(task))
+        end
+      end
+
+      def to_hash
+        hs = super
+        hs[:op] = @op
+        hs[:members] = @members.map(&:to_hash)
+        hs
+      end
+
+      def self.from_hash(hash)
+        case hash
+        in { op: String, members: [*, Hash, *] => members }
+          members.map! { |m| Operators.from_hash(m) }
+          super(hash.merge(members: members))
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/wolflow/recursion.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Wolflow
+  class Recursion < Simple
+    def on_complete(task)
+      return if task.completed?
+
+      return unless task.children.empty?
+
+      super
+    end
+
+    def predict(task, next_tasks)
+      build_next_tasks(task, next_tasks: next_tasks)
+    end
+
+    def build_next_tasks(task, **)
+      super if task.completed?
+    end
+  end
+end