flow_core 0.0.1

data/lib/flow_core/definition/net.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module FlowCore::Definition
+  class Net
+    attr_reader :attributes, :places, :transitions, :start_tag, :end_tag
+
+    def initialize(attributes = {})
+      @attributes = attributes.with_indifferent_access.except(FlowCore::Workflow::FORBIDDEN_ATTRIBUTES)
+      @places = []
+      @transitions = []
+      @start_tag = nil
+      @end_tag = nil
+
+      yield(self)
+    end
+
+    def add_place(tag_or_place, attributes = {})
+      entity =
+        if tag_or_place.is_a? FlowCore::Definition::Place
+          tag_or_place
+        else
+          attributes[:name] ||= tag_or_place.to_s
+          FlowCore::Definition::Place.new(tag_or_place, attributes)
+        end
+
+      @places << entity unless @places.include?(entity)
+      entity
+    end
+
+    def start_place(tag, attributes = {})
+      raise "`start_place` can only call once" if @start_tag
+
+      place = FlowCore::Definition::Place.new(tag, attributes.merge(type: FlowCore::StartPlace.to_s))
+      @places << place
+      @start_tag = place.tag
+      place
+    end
+
+    def end_place(tag, attributes = {})
+      raise "`end_place` can only call once" if @end_tag
+
+      place = FlowCore::Definition::Place.new(tag, attributes.merge(type: FlowCore::EndPlace.to_s))
+      @places << place
+      @end_tag = place.tag
+      place
+    end
+
+    def transition(tag, options = {}, &block)
+      raise TypeError unless tag.is_a? Symbol
+      raise ArgumentError if @transitions.include? tag
+
+      @transitions << FlowCore::Definition::Transition.new(self, tag, options, &block)
+    end
+
+    def compile
+      {
+        attributes: @attributes,
+        start_tag: @start_tag,
+        end_tag: @end_tag,
+        places: @places.map(&:compile),
+        transitions: @transitions.map(&:compile)
+      }
+    end
+
+    def deploy!
+      # TODO: Simple validation
+
+      workflow = nil
+      FlowCore::ApplicationRecord.transaction do
+        workflow = FlowCore::Workflow.create! attributes
+
+        # Places
+        place_records = {}
+        places.each do |pd|
+          place_records[pd.tag] =
+            workflow.places.create! pd.attributes
+        end
+
+        # Transitions
+        transition_records = {}
+        transitions.each do |td|
+          transition_records[td.tag] =
+            workflow.transitions.create! td.attributes
+
+          if td.trigger
+            transition_records[td.tag].create_trigger! td.trigger.compile
+          end
+
+          td.callbacks.each do |cb|
+            transition_records[td.tag].callbacks.create! cb.compile
+          end
+
+          td.input_tags.each do |place_tag|
+            workflow.arcs.in.create! transition: transition_records[td.tag],
+                                     place: place_records[place_tag]
+          end
+
+          td.output_tags.each do |output|
+            arc = workflow.arcs.out.create! transition: transition_records[td.tag],
+                                            place: place_records[output[:tag]]
+            if output[:guard]
+              arc.guards.create! output[:guard].compile
+            end
+          end
+        end
+      end
+      workflow&.verify!
+      workflow
+    end
+  end
+end

data/lib/flow_core/definition/place.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FlowCore::Definition
+  class Place
+    attr_reader :tag, :attributes
+
+    def initialize(tag, attributes = {})
+      raise TypeError unless tag.is_a? Symbol
+
+      @tag = tag
+      @attributes = attributes.with_indifferent_access.except(FlowCore::Place::FORBIDDEN_ATTRIBUTES)
+      @attributes[:name] ||= tag.to_s
+      @attributes[:tag] ||= tag.to_s
+    end
+
+    def compile
+      {
+        tag: @tag,
+        attributes: @attributes
+      }
+    end
+
+    def eql?(other)
+      if other.is_a? FlowCore::Definition::Place
+        @tag == other.tag
+      else
+        false
+      end
+    end
+
+    alias == eql?
+  end
+end

data/lib/flow_core/definition/transition.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module FlowCore::Definition
+  class Transition
+    attr_reader :net, :tag, :attributes, :trigger, :callbacks, :input_tags, :output_tags
+    private :net
+
+    def initialize(net, tag, attributes = {}, &block)
+      raise TypeError unless net.is_a? FlowCore::Definition::Net
+      raise TypeError unless tag.is_a? Symbol
+
+      @net = net
+      @tag = tag
+      @input_tags = []
+      @output_tags = []
+      @callbacks = []
+
+      input = attributes.delete(:input)
+      output = attributes.delete(:output)
+      raise ArgumentError, "Require `input`" unless input
+
+      self.input input
+      self.output output if output
+
+      trigger = attributes.delete :with_trigger
+      @trigger =
+        if trigger
+          FlowCore::Definition::Trigger.new trigger
+        end
+
+      callbacks = []
+      callbacks.concat Array.wrap(attributes.delete(:with_callbacks))
+      callbacks.concat Array.wrap(attributes.delete(:with_callback))
+      @callbacks = callbacks.map { |cb| FlowCore::Definition::Callback.new cb }
+
+      @attributes = attributes.with_indifferent_access.except(FlowCore::Transition::FORBIDDEN_ATTRIBUTES)
+      @attributes[:name] ||= tag.to_s
+      @attributes[:tag] ||= tag.to_s
+
+      block&.call(self)
+    end
+
+    def with_trigger(type, attributes = {})
+      @trigger = FlowCore::Definition::Trigger.new attributes.merge(type: type)
+    end
+
+    def with_callback(type, attributes = {})
+      @callbacks << FlowCore::Definition::Callback.new(attributes.merge(type: type))
+    end
+
+    def with_callbacks(*callbacks)
+      callbacks.each do |cb|
+        with_callback(*cb)
+      end
+    end
+
+    def input(tag)
+      places = Array.wrap(tag)
+      places.each do |place|
+        case place
+        when Symbol
+          net.add_place(place)
+          tag = place
+        when Array # Expect `[:p1, {name: "Place 1"}]`
+          net.add_place(*place)
+          tag = place.first
+        else
+          raise TypeError, "Unknown pattern - #{place}"
+        end
+
+        @input_tags << tag
+      end
+    end
+
+    def output(tag, attributes = {})
+      guard = attributes.delete :with_guard
+      guard = FlowCore::Definition::Guard.new(guard) if guard&.is_a?(Hash)
+
+      places = Array.wrap(tag)
+      places.each do |place|
+        case place
+        when Symbol
+          net.add_place(place)
+          tag = place
+        when Array # Expect `[:p1, {name: "Place 1"}]`
+          net.add_place(*place)
+          tag = place.first
+        else
+          raise TypeError, "Unknown pattern - #{place}"
+        end
+
+        @output_tags << { tag: tag, guard: guard }
+      end
+    end
+
+    def compile
+      {
+        tag: @tag,
+        attributes: @attributes,
+        trigger: @trigger&.compile,
+        callbacks: @callbacks.map(&:compile),
+        input_tags: @input_tags,
+        output_tags: @output_tags.map { |output| { tag: output[:tag], guard: output[:guard]&.compile } }
+      }
+    end
+  end
+end

data/lib/flow_core/definition/trigger.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FlowCore::Definition
+  class Trigger
+    def initialize(attributes)
+      constant_or_klass = attributes.is_a?(Hash) ? attributes.delete(:type) : attributes
+      @klass =
+        if constant_or_klass.is_a? String
+          constant_or_klass.safe_constantize
+        else
+          constant_or_klass
+        end
+      unless @klass && @klass < FlowCore::TransitionTrigger
+        raise TypeError, "First argument expect `FlowCore::TransitionTrigger` subclass or its constant name - #{constant_or_klass}"
+      end
+
+      @configuration = attributes.is_a?(Hash) ? attributes : nil
+    end
+
+    def compile
+      if @configuration&.any?
+        {
+          type: @klass.to_s,
+          configuration: @configuration
+        }
+      else
+        {
+          type: @klass.to_s
+        }
+      end
+    end
+  end
+end

data/lib/flow_core/engine.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module FlowCore
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/flow_core/errors.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module FlowCore
+  # Generic base class for all Workflow Core exceptions.
+  class Error < StandardError; end
+
+  class UnverifiedWorkflow < Error; end
+
+  class InvalidTransition < Error; end
+
+  class NoNewTokenCreated < Error; end
+
+  class ForbiddenOperation < Error; end
+end

data/lib/flow_core/locale/en.yml

@@ -0,0 +1,26 @@
+en:
+  activerecord:
+    models:
+      flow_core/workflow: Workflow
+      flow_core/place: Place
+      flow_core/start_place: Start Place
+      flow_core/end_place: End Place
+      flow_core/transition: Workflow
+      flow_core/transition_trigger: Transition Trigger
+      flow_core/transition_callback: Trasition Callback
+      flow_core/arc: Arc
+      flow_core/arc_guard: Arc Guard
+      flow_core/instance: Instance
+      flow_core/token: Token
+      flow_core/task: Task
+  flow_core:
+    verify_status:
+      unverify: Unverify
+      verified: Verified
+      invalid: Invalid
+    violations:
+      format: "%{model} %{name} %{message}"
+      unreachable: "Unreachable from start place"
+      impassable: "Impassable to end place"
+      trigger_unconfigure: "Trigger not configured yet"
+      callback_unconfigure: "Callback not configured yet"

data/lib/flow_core/task_executable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module FlowCore
+  module TaskExecutable
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :task, as: :executable, required: true, class_name: "FlowCore::Task"
+      has_one :instance, through: :task, class_name: "FlowCore::Instance"
+      has_one :transition, -> { readonly }, through: :task, class_name: "FlowCore::Transition"
+
+      after_save :notify_workflow_task_finished!, if: :implicit_notify_workflow_task_finished
+    end
+
+    # For automatic task
+    def run!
+      raise NotImplementedError
+    end
+
+    def finished?
+      raise NotImplementedError
+    end
+
+    def implicit_notify_workflow_task_finished
+      true
+    end
+
+    protected
+
+      def notify_workflow_task_finished!
+        task.finish! if finished?
+      end
+  end
+end

data/lib/flow_core/transition_callbackable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FlowCore
+  module TransitionCallbackable
+    extend ActiveSupport::Concern
+
+    included do
+      private :_call
+    end
+
+    # Should in
+    # :created, :enabled, :finished, :terminated,
+    # :errored, :rescued :suspended, :resumed
+    def on
+      []
+    end
+
+    def callable?(_task)
+      true
+    end
+
+    def _call(_task)
+      raise NotImplementedError
+    end
+
+    def call(task)
+      return unless on.include? task.stage.to_sym
+      return unless callable? task
+
+      _call task
+    end
+  end
+end

data/lib/flow_core/transition_triggerable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FlowCore
+  module TransitionTriggerable
+    extend ActiveSupport::Concern
+
+    def on_verify(_transition, _violations); end
+
+    def on_task_created(_task); end
+
+    def on_task_enabled(_task); end
+
+    def on_task_finished(_task); end
+
+    def on_task_terminated(_task); end
+
+    def on_task_suspended(_task); end
+
+    def on_task_resumed(_task); end
+
+    def on_task_errored(_task, error)
+      raise error
+    end
+
+    def on_task_rescued(_task); end
+  end
+end

data/lib/flow_core/version.rb

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

data/lib/flow_core/violations.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/conversions"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/object/deep_dup"
+require "active_support/core_ext/string/filters"
+
+module FlowCore
+  class Violations
+    include Enumerable
+
+    MESSAGE_OPTIONS = %i[message].freeze
+
+    attr_reader :messages, :details, :records
+
+    def initialize
+      @messages = apply_default_array({})
+      @details = apply_default_array({})
+      @records = apply_default_array({})
+    end
+
+    def initialize_dup(other) # :nodoc:
+      @messages = other.messages.dup
+      @details  = other.details.deep_dup
+      @records = other.records.deep_dup
+      super
+    end
+
+    def copy!(other) # :nodoc:
+      @messages = other.messages.dup
+      @details  = other.details.dup
+      @records  = other.records.dup
+    end
+
+    def merge!(other)
+      @messages.merge!(other.messages) { |_, ary1, ary2| ary1 + ary2 }
+      @details.merge!(other.details) { |_, ary1, ary2| ary1 + ary2 }
+      @records.merge!(other.records) { |_, ary1, ary2| ary1 + ary2 }
+    end
+
+    def slice!(*keys)
+      keys = keys.map(&:to_sym)
+      @details.slice!(*keys)
+      @messages.slice!(*keys)
+      @records.slice!(*keys)
+    end
+
+    def clear
+      messages.clear
+      details.clear
+      records.clear
+    end
+
+    def include?(record)
+      record = "#{record.class}/#{record.id}"
+      messages.key?(record) && messages[record].present?
+    end
+    alias has_key? include?
+    alias key? include?
+
+    def delete(record)
+      record = "#{record.class}/#{record.id}"
+      details.delete(record)
+      messages.delete(record)
+      records.delete(record)
+    end
+
+    def [](record)
+      record = "#{record.class}/#{record.id}"
+      messages[record]
+    end
+
+    def each
+      messages.each_key do |record_key|
+        model = records[record_key][:model]
+        id = records[record_key][:id]
+        name = records[record_key][:name]
+        messages[record_key].each { |error| yield record_key, model, id, name, error }
+      end
+    end
+
+    def size
+      values.flatten.size
+    end
+    alias count size
+
+    def values
+      messages.reject do |_key, value|
+        value.empty?
+      end.values
+    end
+
+    def keys
+      messages.reject do |_key, value|
+        value.empty?
+      end.keys
+    end
+
+    def empty?
+      size.zero?
+    end
+    alias blank? empty?
+
+    def to_xml(options = {})
+      to_a.to_xml({ root: "errors", skip_types: true }.merge!(options))
+    end
+
+    def as_json(options = nil)
+      to_hash(options && options[:full_messages])
+    end
+
+    def to_hash(full_messages = false)
+      if full_messages
+        messages.each_with_object({}) do |(record_key, array), messages|
+          messages[record_key] = array.map { |message| full_message(record_key, message) }
+        end
+      else
+        without_default_proc(messages)
+      end
+    end
+
+    def add(record, message = :invalid, options = {})
+      message = message.call if message.respond_to?(:call)
+      detail  = normalize_detail(message, options)
+      message = normalize_message(record, message, options)
+      n_record = normalize_record(record)
+
+      record_key = "#{record.class}/#{record.id}"
+      details[record_key] << detail
+      messages[record_key] << message
+      records[record_key] = n_record
+
+      if exception = options[:strict]
+        exception = FlowCore::StrictViolationFailed if exception == true
+        raise exception, full_message(record_key, message)
+      end
+    end
+
+    def added?(record, message = :invalid, options = {})
+      message = message.call if message.respond_to?(:call)
+
+      record_key = "#{record.class}/#{record.id}"
+      if message.is_a? Symbol
+        details[record_key].include? normalize_detail(message, options)
+      else
+        self[record_key].include? message
+      end
+    end
+
+    def of_kind?(record, message = :invalid)
+      message = message.call if message.respond_to?(:call)
+
+      record_key = "#{record.class}/#{record.id}"
+      if message.is_a? Symbol
+        details[record_key].map { |e| e[:error] }.include? message
+      else
+        self[record_key].include? message
+      end
+    end
+
+    def full_messages
+      map do |record_key, _, _, _, message|
+        full_message(record_key, message)
+      end
+    end
+    alias to_a full_messages
+
+    def full_messages_for(record)
+      record_key = "#{record.class}/#{record.id}"
+      messages[record].map { |message| full_message(record_key, message) }
+    end
+
+    def full_message(record_key, message)
+      model = records[record_key][:model]
+      model_name = records[record_key][:model].model_name.human
+      id = records[record_key][:id]
+      name = records[record_key][:name]
+
+      defaults = [:"flow_core.violations.format"]
+      defaults << "%{name} %{message}"
+
+      I18n.t(defaults.shift,
+             default: defaults, model: model, model_name: model_name, id: id, name: name, message: message)
+    end
+
+    def generate_message(record, type = :invalid, options = {})
+      type = options.delete(:message) if options[:message].is_a?(Symbol)
+
+      options = {
+        model: record.class,
+        model_name: record.model_name.human,
+        id: record.id,
+        name: record.name
+      }.merge!(options)
+
+      options[:default] = options.delete(:message) if options[:message]
+
+      I18n.translate("flow_core.violations.#{type}", options)
+    end
+
+    def marshal_dump # :nodoc:
+      [without_default_proc(@messages), without_default_proc(@details), without_default_proc(@records)]
+    end
+
+    def marshal_load(array) # :nodoc:
+      @messages, @details, @records = array
+      apply_default_array(@messages)
+      apply_default_array(@details)
+      apply_default_array(@records)
+    end
+
+    def init_with(coder) # :nodoc:
+      coder.map.each { |k, v| instance_variable_set(:"@#{k}", v) }
+      @details ||= {}
+      apply_default_array(@messages)
+      apply_default_array(@details)
+      apply_default_array(@records)
+    end
+
+    private
+
+      def normalize_message(record, message, options)
+        case message
+        when Symbol
+          generate_message(record, message, options)
+        else
+          message
+        end
+      end
+
+      def normalize_detail(message, options)
+        { error: message }.merge(options.except(*MESSAGE_OPTIONS))
+      end
+
+      def normalize_record(record)
+        { model: record.class, id: record.id, name: record.name }
+      end
+
+      def without_default_proc(hash)
+        hash.dup.tap do |new_h|
+          new_h.default_proc = nil
+        end
+      end
+
+      def apply_default_array(hash)
+        hash.default_proc = proc { |h, key| h[key] = [] }
+        hash
+      end
+  end
+
+  class StrictViolationFailed < StandardError
+  end
+end