bpmn 0.0.1

data/lib/spot_flow/bpmn/extensions.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SpotFlow
+  module Bpmn
+    class Extension
+      include ActiveModel::Model
+    end
+  end
+
+  module Zeebe
+    class AssignmentDefinition < Bpmn::Extension
+      attr_accessor :assignee, :candidate_groups, :candidate_users
+    end
+
+    class CalledElement < Bpmn::Extension
+      attr_accessor :process_id, :propagate_all_child_variables, :propagate_all_parent_variables
+
+      def initialize(attributes = {})
+        super(attributes.except(:propagate_all_child_variables))
+
+        @propagate_all_parent_variables = true
+        @propagate_all_parent_variables = attributes[:propagate_all_parent_variables] == "true" if attributes[:propagate_all_parent_variables].present?
+        @propagate_all_child_variables = attributes[:propagate_all_child_variables] == "true"
+      end
+    end
+
+    class CalledDecision < Bpmn::Extension
+      attr_accessor :decision_id, :result_variable
+    end
+
+    class FormDefinition < Bpmn::Extension
+      attr_accessor :form_key
+    end
+
+    class IoMapping < Bpmn::Extension
+      attr_reader :inputs, :outputs
+
+      def initialize(attributes = {})
+        super(attributes.except(:input, :output))
+
+        @inputs = Array.wrap(attributes[:input]).map { |atts| Parameter.new(atts) } if attributes[:input].present?
+        @outputs = Array.wrap(attributes[:output]).map { |atts| Parameter.new(atts) } if attributes[:output].present?
+      end
+    end
+
+    class Parameter < Bpmn::Extension
+      attr_accessor :source, :target
+    end
+
+    class Script < Bpmn::Extension
+      attr_accessor :expression, :result_variable
+    end
+
+    class Subscription < Bpmn::Extension
+      attr_accessor :correlation_key
+    end
+
+    class TaskDefinition < Bpmn::Extension
+      attr_accessor :type, :retries
+    end
+
+    class TaskHeaders < Bpmn::Extension
+      attr_accessor :headers
+
+      def initialize(attributes = {})
+        super(attributes.except(:header))
+
+        @headers = HashWithIndifferentAccess.new
+        Array.wrap(attributes[:header]).each { |header| @headers[header[:key]] = header[:value] }
+      end
+    end
+
+    class TaskSchedule < Bpmn::Extension
+      attr_accessor :due_date, :follow_up_date
+    end
+  end
+end

data/lib/spot_flow/bpmn/flow.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SpotFlow
+  module Bpmn
+    class Flow < Element
+      attr_accessor :source_ref, :target_ref
+      attr_accessor :source, :target
+
+      def initialize(attributes = {})
+        super(attributes.except(:source_ref, :target_ref))
+
+        @source_ref = attributes[:source_ref]
+        @target_ref = attributes[:target_ref]
+        @source = nil
+        @target = nil
+      end
+
+      def inspect
+        parts = ["#<#{self.class.name.gsub(/SpotFlow::/, "")} @id=#{id.inspect}"]
+        parts << "@source_ref=#{source_ref.inspect}" if source_ref
+        parts << "@target_ref=#{target_ref.inspect}" if target_ref
+        parts.join(" ") + ">"
+      end
+    end
+
+    class Association < Flow
+    end
+
+    class SequenceFlow < Flow
+      attr_accessor :condition
+
+      def initialize(attributes = {})
+        super(attributes.except(:condition))
+
+        @condition = attributes[:condition_expression]
+      end
+
+      def evaluate(execution)
+        return true unless condition
+        execution.evaluate_condition(condition)
+      end
+    end
+
+    class TextAnnotation < Flow
+    end
+  end
+end

data/lib/spot_flow/bpmn/gateway.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module SpotFlow
+  module Bpmn
+    class Gateway < Step
+
+      def execute(execution)
+        if converging?
+          if is_enabled?(execution)
+            return leave(execution)
+          else
+            execution.wait
+          end
+        else
+          return leave(execution)
+        end
+      end
+
+      #
+      # Algorithm from https://researcher.watson.ibm.com/researcher/files/zurich-hvo/bpm2010-1.pdf
+      #
+      def is_enabled?(execution)
+        filled = []
+        empty = []
+
+        incoming.each { |flow| execution.tokens_in.include?(flow.id) ? filled.push(flow) : empty.push(flow) }
+
+        # Filled slots don't need to be searched for tokens
+        index = 0
+        while (index < filled.length)
+          current_flow = filled[index]
+          current_flow.source.incoming.each do |incoming_flow|
+            filled.push(incoming_flow) unless filled.include?(incoming_flow) || incoming_flow.target == self
+          end
+          index = index + 1
+        end
+
+        # Empty slots need to be searched for tokens
+        index = 0
+        while (index < empty.length)
+          current_flow = empty[index]
+          current_flow.source.incoming.each do |incoming_flow|
+            empty.push(incoming_flow) unless filled.include?(incoming_flow) || empty.include?(incoming_flow) || incoming_flow.target == self
+          end
+          index = index + 1
+        end
+
+        empty_ids = empty.map { |g| g.id }
+
+        # If there are empty slots with tokens we need to wait
+        return false if (empty_ids & execution.parent.tokens).length > 0
+        return true
+      end
+    end
+
+    class ExclusiveGateway < Gateway
+      # RULE: Only one flow is taken
+      def outgoing_flows(step_execution)
+        flows = super
+        return [flows.first]
+      end
+    end
+
+    class ParallelGateway < Gateway
+      # RULE: All flows are taken
+    end
+
+    class InclusiveGateway < Gateway
+      # RULE: All valid flows are taken
+      # NOTE: Camunda 8 only support diverging but not converging inclusive gateways
+    end
+
+    class EventBasedGateway < Gateway
+      #
+      # RULE: when an event created from an event gateway is caught,
+      # all other waiting events must be canceled.
+      #
+      def cancel_waiting_events(execution)
+        execution.targets.each do |target_execution|
+          target_execution.terminate unless target_execution.ended?
+        end
+      end
+    end
+  end
+end

data/lib/spot_flow/bpmn/process.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module SpotFlow
+  module Bpmn
+    class Process < Step
+      attr_accessor :is_executable
+
+      attr_accessor :start_events, :end_events, :intermediate_catch_events, :intermediate_throw_events, :boundary_events
+      attr_accessor :tasks, :user_tasks, :service_tasks, :script_tasks, :send_tasks, :receive_tasks, :manual_tasks, :business_rule_tasks, :call_activities
+      attr_accessor :sub_processes, :ad_hoc_sub_processes
+      attr_accessor :sequence_flows, :message_flows, :associations, :data_associations, :data_inputs, :data_outputs
+      attr_accessor :data_objects, :data_stores, :data_stores_references
+      attr_accessor :gateways, :exclusive_gateways, :parallel_gateways, :inclusive_gateways, :event_based_gateways, :complex_gateways
+
+      attr_accessor :parent
+
+      def initialize(attributes = {})
+        super(attributes.slice(:id, :name, :extension_elements, :incoming, :outgoing, :default))
+
+        @is_executable = attributes[:is_executable] == ("true" || true)
+
+        @start_events = Array.wrap(attributes[:start_event]).map { |se| StartEvent.new(se) }
+        @end_events = Array.wrap(attributes[:end_event]).map { |ee| EndEvent.new(ee) }
+        @intermediate_catch_events = Array.wrap(attributes[:intermediate_catch_event]).map { |ice| IntermediateCatchEvent.new(ice) }
+        @intermediate_throw_events = Array.wrap(attributes[:intermediate_throw_event]).map { |ite| IntermediateThrowEvent.new(ite) }
+        @boundary_events = Array.wrap(attributes[:boundary_event]).map { |be| BoundaryEvent.new(be) }
+        @tasks = Array.wrap(attributes[:task]).map { |t| Task.new(t) }
+        @user_tasks = Array.wrap(attributes[:user_task]).map { |ut| UserTask.new(ut) }
+        @service_tasks = Array.wrap(attributes[:service_task]).map { |st| ServiceTask.new(st) }
+        @script_tasks = Array.wrap(attributes[:script_task]).map { |st| ScriptTask.new(st) }
+        @business_rule_tasks = Array.wrap(attributes[:business_rule_task]).map { |brt| BusinessRuleTask.new(brt) }
+        @call_activities = Array.wrap(attributes[:call_activity]).map { |ca| CallActivity.new(ca) }
+        @sub_processes = Array.wrap(attributes[:sub_process]).map { |sp| SubProcess.new(sp) }
+        @ad_hoc_sub_processes = Array.wrap(attributes[:ad_hoc_sub_processe]).map { |ahsp| AdHocSubProcess.new(ahsp) }
+        @exclusive_gateways = Array.wrap(attributes[:exclusive_gateway]).map { |eg| ExclusiveGateway.new(eg) }
+        @parallel_gateways = Array.wrap(attributes[:parallel_gateway]).map { |pg| ParallelGateway.new(pg) }
+        @inclusive_gateways = Array.wrap(attributes[:inclusive_gateway]).map { |ig| InclusiveGateway.new(ig) }
+        @event_based_gateways = Array.wrap(attributes[:event_based_gateway]).map { |ebg| EventBasedGateway.new(ebg) }
+        @sequence_flows = Array.wrap(attributes[:sequence_flow]).map { |sf| SequenceFlow.new(sf) }
+      end
+
+      def elements
+        @elements ||= {}.tap do |elements|
+          elements.merge!(start_events.index_by(&:id))
+          elements.merge!(end_events.index_by(&:id))
+          elements.merge!(intermediate_catch_events.index_by(&:id))
+          elements.merge!(intermediate_throw_events.index_by(&:id))
+          elements.merge!(boundary_events.index_by(&:id))
+          elements.merge!(tasks.index_by(&:id))
+          elements.merge!(user_tasks.index_by(&:id))
+          elements.merge!(service_tasks.index_by(&:id))
+          elements.merge!(script_tasks.index_by(&:id))
+          elements.merge!(business_rule_tasks.index_by(&:id))
+          elements.merge!(call_activities.index_by(&:id))
+          elements.merge!(sub_processes.index_by(&:id))
+          elements.merge!(ad_hoc_sub_processes.index_by(&:id))
+          elements.merge!(exclusive_gateways.index_by(&:id))
+          elements.merge!(parallel_gateways.index_by(&:id))
+          elements.merge!(inclusive_gateways.index_by(&:id))
+          elements.merge!(event_based_gateways.index_by(&:id))
+          elements.merge!(sequence_flows.index_by(&:id))
+        end
+      end
+
+      def wire_references(definitions)
+        elements.values.each do |element|
+          if element.is_a?(Step)
+            element.incoming = element.incoming.map { |id| element_by_id(id) }
+            element.outgoing = element.outgoing.map { |id| element_by_id(id) }
+
+            if element.is_a?(Event)
+
+              element.event_definitions.each do |event_definition|
+                if event_definition.is_a?(MessageEventDefinition)
+                  event_definition.message = definitions.message_by_id(event_definition.message_ref)
+                elsif event_definition.is_a?(SignalEventDefinition)
+                  event_definition.signal = definitions.signal_by_id(event_definition.signal_ref)
+                elsif event_definition.is_a?(ErrorEventDefinition)
+                  event_definition.error = definitions.error_by_id(event_definition.error_ref)
+                end
+              end
+
+              if element.is_a?(BoundaryEvent)
+                host_element = element_by_id(element.attached_to_ref)
+                host_element.attachments << element
+                element.attached_to = host_element
+              end
+
+            end
+
+            if element.is_a?(Gateway)
+              element.default = element_by_id(element.default_ref)
+            end
+
+            if element.is_a?(SubProcess)
+              element.wire_references(definitions)
+            end
+
+          elsif element.is_a?(SequenceFlow)
+            element.source = element_by_id(element.source_ref)
+            element.target = element_by_id(element.target_ref)
+          end
+
+          # Not handled participant process ref
+        end
+      end
+
+      def element_by_id(id)
+        elements[id]
+      end
+
+      def elements_by_type(type)
+        elements.select { |e| e.class == type }
+      end
+
+      def default_start_event
+        start_events.find { |se| se.event_definitions.empty? }
+      end
+
+      def execute(execution)
+        start_event = execution.start_event_id ? element_by_id(execution.start_event_id) : default_start_event
+        raise ExecutionErrorNew.new("Process must have at least one start event.") if start_event.blank?
+        execution.execute_step(start_event)
+      end
+
+      def inspect
+        parts = ["#<#{self.class.name.gsub(/SpotFlow::/, "")} @id=#{id.inspect} @name=#{name.inspect} @is_executable=#{is_executable.inspect}"]
+        parts << "@parent=#{parent.inspect}" if parent
+        event_attrs = (start_events + intermediate_catch_events + intermediate_throw_events + boundary_events + end_events).compact
+        parts << "@events=#{event_attrs.inspect}" unless event_attrs.blank?
+        activity_attrs = (tasks + user_tasks + service_tasks + script_tasks + business_rule_tasks + call_activities).compact
+        parts << "@activities=#{activity_attrs.inspect}" unless activity_attrs.blank?
+        gateway_attrs = (exclusive_gateways + parallel_gateways + inclusive_gateways + event_based_gateways).compact
+        parts << "@gateways=#{gateway_attrs.inspect}" unless gateway_attrs.blank?
+        sub_process_attrs = (sub_processes + ad_hoc_sub_processes).compact
+        parts << "@sub_processes=#{sub_process_attrs.inspect}" unless sub_process_attrs.blank? 
+        parts << "@sequence_flows=#{sequence_flows.inspect}" unless sequence_flows.blank?
+        parts.join(" ") + ">"
+      end
+    end
+
+    class SubProcess < Process
+      attr_accessor :triggered_by_event
+
+      def initialize(attributes = {})
+        super(attributes.except(:triggered_by_event))
+
+        @is_executable = false
+        @sub_processes = []
+        @triggered_by_event = attributes[:triggered_by_event]
+      end
+
+      def execution_ended(execution)
+        leave(execution)
+      end
+    end
+
+    class AdHocSubProcess < SubProcess
+
+    end
+
+    class CallActivity < Activity
+      attr_reader :process_id
+
+      def execute(execution)
+        if extension_elements&.called_element&.process_id&.start_with?("=")
+          @process_id = SpotFeel.evaluate(extension_elements&.called_element&.process_id, variables: execution.variables)
+        else
+          @process_id = extension_elements&.called_element&.process_id
+        end
+
+        execution.wait
+
+        process = execution.context.process_by_id(@process_id) if @process_id
+        execution.execute_step(process.default_start_event) if process
+      end
+    end
+  end
+end

data/lib/spot_flow/bpmn/step.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module SpotFlow
+  module Bpmn
+    class Step < Element
+      attr_accessor :incoming, :outgoing, :default, :default_ref
+
+      def initialize(attributes = {})
+        super(attributes.except(:incoming, :outgoing, :default))
+
+        @incoming = Array.wrap(attributes[:incoming]) || []
+        @outgoing = Array.wrap(attributes[:outgoing]) || []
+        @default_ref = attributes[:default]
+      end
+
+      def diverging?
+        outgoing.length > 1
+      end
+
+      def converging?
+        incoming.length > 1
+      end
+
+      def leave(execution)
+        execution.end(false)
+        execution.take_all(outgoing_flows(execution))
+      end
+
+      def outgoing_flows(execution)
+        flows = []
+        outgoing.each do |flow|
+          result = flow.evaluate(execution) unless default&.id == flow.id
+          flows.push flow if result
+        end
+        flows = [default] if flows.empty? && default
+        return flows
+      end
+
+      def input_mappings
+        extension_elements&.io_mapping&.inputs || []
+      end
+
+      def output_mappings
+        extension_elements&.io_mapping&.outputs || []
+      end
+    end
+
+    class Activity < Step
+      attr_accessor :attachments
+
+      def initialize(attributes = {})
+        super(attributes.except(:attachments))
+
+        @attachments = []
+      end
+    end
+  end
+end

data/lib/spot_flow/bpmn/task.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module SpotFlow
+  module Bpmn
+    class Task < Activity
+
+      def is_automated?
+        false
+      end
+
+      def is_manual?
+        true
+      end
+
+      def execute(execution)
+        execution.wait
+      end
+
+      def signal(execution)
+        leave(execution)
+      end
+
+      def result_to_variables(result)
+        if result_variable
+          return { "#{result_variable}": result }
+        else
+          if result.is_a? Hash
+            result
+          else
+            {}.tap { |h| h[id.underscore] = result }
+          end
+        end
+      end
+    end
+
+    class UserTask < Task
+
+      def form_key
+        extension_elements&.form_definition&.form_key
+      end
+
+      def assignee
+        extension_elements&.assignment_definition&.assignee
+      end
+
+      def candidate_groups
+        extension_elements&.assignment_definition&.candidate_groups
+      end
+
+      def candidate_users
+        extension_elements&.assignment_definition&.candidate_users
+      end
+
+      def due_date
+        extension_elements&.task_schedule&.due_date
+      end
+
+      def follow_up_date
+        extension_elements&.task_schedule&.follow_up_date
+      end
+    end
+
+    class ServiceTask < Task
+      attr_accessor :service
+
+      def is_automated?
+        true
+      end
+
+      def is_manual?
+        false
+      end
+
+      def execute(execution)
+        execution.wait
+      end
+
+      def task_type
+        extension_elements&.task_definition&.type
+      end
+
+      def task_retries
+        extension_elements&.task_definition&.retries
+      end
+
+      def headers
+        extension_elements&.task_headers&.headers
+      end
+
+      def run(execution)
+        if defined?(task_type)
+          klass = task_type.constantize
+          klass.new.call(execution.parent.variables, headers || {})
+        end
+      end
+    end
+
+    class ScriptTask < ServiceTask
+
+      def script
+        extension_elements&.script&.expression
+      end
+
+      def result_variable
+        extension_elements&.script&.result_variable
+      end
+
+      def run(execution)
+        SpotFeel.evaluate(script.delete_prefix("="), variables: execution.parent.variables)
+      end
+    end
+
+    class BusinessRuleTask < ServiceTask
+
+      def decision_id
+        extension_elements&.called_decision&.decision_id
+      end
+
+      def result_variable
+        extension_elements&.called_decision&.result_variable
+      end
+
+      def run(execution)
+        SpotFeel.decide(decision_id, definitions: execution.context.dmn_definitions_by_decision_id(decision_id), variables: execution.parent.variables)
+      end
+    end
+  end
+end

data/lib/spot_flow/bpmn.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "bpmn/element"
+require_relative "bpmn/extensions"
+require_relative "bpmn/extension_elements"
+require_relative "bpmn/step"
+require_relative "bpmn/flow"
+require_relative "bpmn/event_definition"
+require_relative "bpmn/event"
+require_relative "bpmn/gateway"
+require_relative "bpmn/task"
+require_relative "bpmn/process"
+require_relative "bpmn/definitions"
+
+module SpotFlow
+  module Bpmn
+  end
+end

data/lib/spot_flow/context.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module SpotFlow
+  class Context
+    attr_reader :sources, :processes, :decisions, :services, :executions
+    attr_reader :bpmn_definitions, :dmn_definitions
+
+    def initialize(sources = [], processes:[], decisions:[], services: {})
+      @sources = Array.wrap(sources)
+      @processes = Array.wrap(processes)
+      @bpmn_definitions = []
+      @dmn_definitions = []
+      @decisions = Array.wrap(decisions)
+      @services = HashWithIndifferentAccess.new((SpotFlow.config.services || {}).merge(services))
+
+      @sources.each do |source|
+        if source.include?("http://www.omg.org/spec/DMN/20180521/DC/")
+          definitions = SpotFeel.definitions_from_xml(source)
+          @dmn_definitions << definitions
+          @decisions += definitions.decisions
+        else
+          @processes += SpotFlow.processes_from_xml(source)
+        end
+      end
+
+      @executions = []
+    end
+
+    def start(process_id: nil, start_event_id: nil, variables: {})
+      process = process_id ? process_by_id(process_id) : default_process
+      raise ExecutionError.new(process_id ? "Process #{process_id} not found." : "No default process found.") if process.blank?
+      execution = Execution.start(context: self, process: process, start_event_id: start_event_id, variables: variables)
+      executions << execution
+      execution
+    end
+
+    def start_with_message(message_name:, variables: {})
+      [].tap do |executions|
+        processes.map do |process|
+          process.start_events.map do |start_event|
+            start_event.message_event_definitions.map do |message_event_definition|
+              if message_name == message_event_definition.message_name
+                Execution.start(context: self, process: process, variables: variables, start_event_id: start_event.id).tap { |execution| executions.push execution }
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def restore(execution_state)
+      Execution.deserialize(execution_state, context: self).tap do |execution|
+        executions << execution
+      end
+    end
+
+    def notify_listener(*args)
+      SpotFlow.config.listener&.call(args)
+    end
+
+    def default_process
+      raise "Multiple processes defined, must identify process" if processes.size > 1
+      processes.first
+    end
+
+    def process_by_id(id)
+      processes.each do |process|
+        return process if process.id == id
+        process.sub_processes.each do |sub_process|
+          return sub_process if sub_process.id == id
+        end
+      end
+      nil
+    end
+
+    def element_by_id(id)
+      processes.each do |process|
+        element = process.element_by_id(id)
+        return element if element
+      end
+      nil
+    end
+
+    def execution_by_id(id)
+      executions.find { |e| e.id == id }
+    end
+
+    def execution_by_step_id(step_id)
+      executions.find { |e| e.step.id == step_id }
+    end
+
+    def decision_by_id(id)
+      decisions.find { |d| d.id == id }
+    end
+
+    def dmn_definitions_by_decision_id(decision_id)
+      dmn_definitions.find { |definitions| definitions.decisions.find { |decision| decision.id == decision_id } }
+    end
+
+    def inspect
+      parts = ["#<Context"]
+      parts << "@processes=#{processes.inspect}" if processes.present?
+      parts << "@decisions=#{decisions.inspect}" if decisions.present?
+      parts << "@executions=#{executions.inspect}" if executions.present?
+      parts.join(" ") + ">"
+    end
+  end
+end