bpmn 0.0.1 → 0.0.3

data/lib/bpmn/flow.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+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(/BPMN::/, "")} @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

data/lib/bpmn/gateway.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+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

data/lib/bpmn/process.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+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(/BPMN::/, "")} @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 = DMN.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

data/lib/bpmn/step.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+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

data/lib/bpmn/task.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+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)
+      DMN.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)
+      DMN.decide(decision_id, definitions: execution.context.dmn_definitions_by_decision_id(decision_id), variables: execution.parent.variables)
+    end
+  end
+end

data/lib/bpmn/version.rb

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

data/lib/{spot_flow.rb → bpmn.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "spot_flow/version"
+require "bpmn/version"
 
 require "active_support"
 require "active_support/time"
@@ -9,13 +9,24 @@ require "active_support/core_ext/object/json"
 require "active_support/configurable"
 require "active_model"
 
-require "spot_feel"
+require "dmn"
 
-require "spot_flow/bpmn"
-require "spot_flow/context"
-require "spot_flow/execution"
+require "bpmn/element"
+require "bpmn/extensions"
+require "bpmn/extension_elements"
+require "bpmn/step"
+require "bpmn/flow"
+require "bpmn/event_definition"
+require "bpmn/event"
+require "bpmn/gateway"
+require "bpmn/task"
+require "bpmn/process"
+require "bpmn/definitions"
 
-module SpotFlow
+require "bpmn/context"
+require "bpmn/execution"
+
+module BPMN
   include ActiveSupport::Configurable
 
   #
@@ -36,14 +47,14 @@ module SpotFlow
   # Extract processes from a BMPN XML file.
   #
   def self.processes_from_xml(xml)
-    Bpmn::Definitions.from_xml(xml)&.processes || []
+    Definitions.from_xml(xml)&.processes || []
   end
 
   #
   # Extract decisions from a DMN XML file.
   #
   def self.decisions_from_xml(xml)
-    definitions = SpotFeel.definitions_from_xml(xml)
+    definitions = DMN.definitions_from_xml(xml)
     definitions.decisions
   end
 end

metadata

@@ -1,15 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: bpmn
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Connected Bits
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-30 00:00:00.000000000 Z
+date: 2025-03-03 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: dmn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.3
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
@@ -189,29 +202,27 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- lib/spot_flow.rb
-- lib/spot_flow/bpmn.rb
-- lib/spot_flow/bpmn/definitions.rb
-- lib/spot_flow/bpmn/element.rb
-- lib/spot_flow/bpmn/event.rb
-- lib/spot_flow/bpmn/event_definition.rb
-- lib/spot_flow/bpmn/extension_elements.rb
-- lib/spot_flow/bpmn/extensions.rb
-- lib/spot_flow/bpmn/flow.rb
-- lib/spot_flow/bpmn/gateway.rb
-- lib/spot_flow/bpmn/process.rb
-- lib/spot_flow/bpmn/step.rb
-- lib/spot_flow/bpmn/task.rb
-- lib/spot_flow/context.rb
-- lib/spot_flow/execution.rb
-- lib/spot_flow/version.rb
+- lib/bpmn.rb
+- lib/bpmn/context.rb
+- lib/bpmn/definitions.rb
+- lib/bpmn/element.rb
+- lib/bpmn/event.rb
+- lib/bpmn/event_definition.rb
+- lib/bpmn/execution.rb
+- lib/bpmn/extension_elements.rb
+- lib/bpmn/extensions.rb
+- lib/bpmn/flow.rb
+- lib/bpmn/gateway.rb
+- lib/bpmn/process.rb
+- lib/bpmn/step.rb
+- lib/bpmn/task.rb
+- lib/bpmn/version.rb
 homepage: https://www.connectedbits.com
 licenses:
 - MIT
 metadata:
   homepage_uri: https://www.connectedbits.com
   source_code_uri: https://github.com/connectedbits/process_pilot
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -226,8 +237,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.21
-signing_key:
+rubygems_version: 3.6.5
 specification_version: 4
 summary: A BPMN workflow engine in Ruby
 test_files: []

data/lib/spot_flow/bpmn/definitions.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module SpotFlow
-  module Bpmn
-    class Definitions
-      include ActiveModel::Model
-
-      attr_accessor :id, :name, :target_namespace, :exporter, :exporter_version, :execution_platform, :execution_platform_version
-      attr_reader :messages, :signals, :errors, :processes
-
-      def self.from_xml(xml)
-        XmlHasher.configure do |config|
-          config.snakecase = true
-          config.ignore_namespaces = true
-          config.string_keys = false
-        end
-        hash = XmlHasher.parse(xml)
-        Definitions.new(hash[:definitions].except(:bpmn_diagram)).tap do |definitions|
-          definitions.processes.each do |process|
-            process.wire_references(definitions)
-          end
-        end
-      end
-
-      def initialize(attributes={})
-        super(attributes.except(:message, :signal, :error, :process))
-
-        @messages = Array.wrap(attributes[:message]).map { |atts| Message.new(atts) }
-        @signals = Array.wrap(attributes[:signal]).map { |atts| Signal.new(atts) }
-        @errors = Array.wrap(attributes[:error]).map { |atts| Error.new(atts) }
-        @processes = Array.wrap(attributes[:process]).map { |atts| Process.new(atts) }
-      end
-
-      def message_by_id(id)
-        messages.find { |message| message.id == id }
-      end
-
-      def signal_by_id(id)
-        signals.find { |signal| signal.id == id }
-      end
-
-      def error_by_id(id)
-        errors.find { |error| error.id == id }
-      end
-
-      def process_by_id(id)
-        processes.find { |process| process.id == id }
-      end
-
-      def inspect
-        "#<Bpmn::Definitions @id=#{id.inspect} @name=#{name.inspect} @messages=#{messages.inspect} @signals=#{signals.inspect} @errors=#{errors.inspect} @processes=#{processes.inspect}>"
-      end
-    end
-  end
-end