bpmn 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33862df282c4b5eae3fa1b4317e7762c299ace6ac8794f138efc86d6225645c0
-  data.tar.gz: 7f67bb1e73ee9020c5f5bb5f67ff29c2312f3412ae8ae77a3be142c1d12c6a1e
+  metadata.gz: 7ffd863edea8a05d607b816c4fc0464968a822db50e8389ccfd36cc68734e6ba
+  data.tar.gz: 624fc1a44f2b4c6c9c3dd1bd309ce6d0a2a381f74fe975a65c067616384d2af3
 SHA512:
-  metadata.gz: c4e9586ba65c154da496be6b5635000ab3f6e61624f8733a2b2fec87eecac5b193df176075d4db146d84e09d22e99fcce2090e559fd01ed8847d4399d3808b42
-  data.tar.gz: f995dbb81528b381e56d8cd74286ae273d8e890a4a2f2f35fca8de736169cce2eddec467148a48d4bd4943a8b8345bed2b2d99285921417a07457dc8adecfe8f
+  metadata.gz: 9581fe6232d79731cb29b5267afeced58fd5c8f817ba7e98ee77aadfb048ef8f05f0e0851010cce4f78e0de4b18beddfc812874ce0cf99e6b0ae46d6e43e6370
+  data.tar.gz: 338dad681a7d7ec6c67bb1a16b2cb42a0745575cb66fe23fbea2479eeee9b430248ed94a0bb6c0bbb49809eaa3c9494a3de028b381239a3ffd0d221b9d79b1d7

data/README.md

@@ -15,14 +15,14 @@ Processes are made of a series of tasks. Tasks can be manual (require `signal` t
 - BusinessRuleTask (automated): evaluates the decision_id (expects dmn source to be included in the context).
 - ScriptTask (automated): evaluates the FEEL expression in the script property.
 
-To start the process, initialize SpotFlow with the BPMN and DMN source files, then call `start`.
+To start the process, initialize with the BPMN and DMN source files, then call `start`.
 
 ```ruby
 sources = [
   File.read("hello_world.bpmn"),
   File.read("choose_greeting.dmn")
 ]
-execution = SpotFlow.new(sources).start
+execution = BPMN.new(sources).start
 ```
 
 It's often useful to print the process state to the console.
@@ -39,7 +39,7 @@ HelloWorld started * Flow_080794y
 2 BoundaryEvent EggTimer: waiting
 ```
 
-The HelloWorld process began at the Start event and is _waiting_ at the IntroduceYourself user task. This is an important concept in the SpotFlow engine. It's designed to be used in a Rails application where a process might be waiting for a user to complete a form, or a background job to complete. It's common to save the state the process until a task is complete. Calling `serialize` on a process will return the execution state so it can be continued later.
+The HelloWorld process began at the Start event and is _waiting_ at the IntroduceYourself user task. This is an important concept in the BPMN engine. It's designed to be used in a Rails application where a process might be waiting for a user to complete a form, or a background job to complete. It's common to save the state the process until a task is complete. Calling `serialize` on a process will return the execution state so it can be continued later.
 
 ```ruby
 # Returns a hash of the process state.
@@ -49,7 +49,7 @@ execution_state = execution.serialize
 # or a background job completes (ServiceTask)
 
 # Restores the process from the execution state.
-execution = SpotFlow.restore(sources, execution_state:)
+execution = BPMN.restore(sources, execution_state:)
 
 # Now we can continue the process by `signaling` the waiting task.
 step = execution.step_by_element_id("IntroduceYourself")
@@ -162,13 +162,13 @@ HelloWorld completed *
 Execute:
 
 ```bash
-$ bundle add spot_flow
+$ bundle add bpmn
 ```
 
 Or install it directly:
 
 ```bash
-$ gem install spot_flow
+$ gem install bpmn
 ```
 
 ## Development

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SpotFlow
+module BPMN
   class Context
     attr_reader :sources, :processes, :decisions, :services, :executions
     attr_reader :bpmn_definitions, :dmn_definitions
@@ -11,15 +11,15 @@ module SpotFlow
       @bpmn_definitions = []
       @dmn_definitions = []
       @decisions = Array.wrap(decisions)
-      @services = HashWithIndifferentAccess.new((SpotFlow.config.services || {}).merge(services))
+      @services = HashWithIndifferentAccess.new((BPMN.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)
+          definitions = DMN.definitions_from_xml(source)
           @dmn_definitions << definitions
           @decisions += definitions.decisions
         else
-          @processes += SpotFlow.processes_from_xml(source)
+          @processes += BPMN.processes_from_xml(source)
         end
       end
 
@@ -55,7 +55,7 @@ module SpotFlow
     end
 
     def notify_listener(*args)
-      SpotFlow.config.listener&.call(args)
+      BPMN.config.listener&.call(args)
     end
 
     def default_process

data/lib/bpmn/definitions.rb

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

data/lib/bpmn/element.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module BPMN
+  class Element
+    include ActiveModel::Model
+
+    attr_accessor :id, :name, :extension_elements
+
+    def initialize(attributes = {})
+      super(attributes.slice(:id, :name))
+
+      @extension_elements = ExtensionElements.new(attributes[:extension_elements]) if attributes[:extension_elements].present?
+    end
+
+    def inspect
+      "#<#{self.class.name.gsub(/BPMN::/, "")} @id=#{id.inspect} @name=#{name.inspect}>"
+    end
+  end
+
+  class Message < Element
+  end
+
+  class Signal < Element
+  end
+
+  class Error < Element
+  end
+
+  class Collaboration < Element
+  end
+
+  class LaneSet < Element
+  end
+
+  class Participant < Element
+    attr_accessor :process_ref, :process
+
+    def initialize(attributes = {})
+      super(attributes.except(:process_ref))
+    end
+  end
+end

data/lib/bpmn/event.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module BPMN
+  class Event < Step
+    attr_accessor :event_definitions
+
+    def initialize(attributes = {})
+      super(attributes.except(:message_event_definition, :signal_event_definition, :error_event_definition, :terminate_event_definition, :timer_event_definition))
+
+      @event_definitions = []
+
+      Array.wrap(attributes[:message_event_definition]).each do |med|
+        @event_definitions.push MessageEventDefinition.new(med)
+      end if attributes[:message_event_definition].present?
+
+      Array.wrap(attributes[:signal_event_definition]).each do |sed|
+        @event_definitions.push SignalEventDefinition.new(sed)
+      end if attributes[:signal_event_definition].present?
+
+      Array.wrap(attributes[:error_event_definition]).each do |eed|
+        @event_definitions.push ErrorEventDefinition.new(eed)
+      end if attributes[:error_event_definition].present?
+
+      Array.wrap(attributes[:terminate_event_definition]).each do |ted|
+        @event_definitions.push TerminateEventDefinition.new(ted)
+      end if attributes[:terminate_event_definition].present?
+
+      Array.wrap(attributes[:timer_event_definition]).each do |ted|
+        @event_definitions.push TimerEventDefinition.new(ted)
+      end if attributes[:timer_event_definition].present?
+    end
+
+    def event_definition_ids
+      event_definitions.map(&:id)
+    end
+
+    def is_catching?
+      false
+    end
+
+    def is_throwing?
+      false
+    end
+
+    def is_none?
+      event_definitions.empty?
+    end
+
+    def is_conditional?
+      conditional_event_definition.present?
+    end
+
+    def is_escalation?
+      escalation_event_definition.present?
+    end
+
+    def is_error?
+      error_event_definition.present?
+    end
+
+    def is_message?
+      !message_event_definitions.empty?
+    end
+
+    def is_signal?
+      !signal_event_definitions.empty?
+    end
+
+    def is_terminate?
+      terminate_event_definition.present?
+    end
+
+    def is_timer?
+      timer_event_definition.present?
+    end
+
+    def conditional_event_definition
+      event_definitions.find { |ed| ed.is_a?(ConditionalEventDefinition) }
+    end
+
+    def escalation_event_definition
+      event_definitions.find { |ed| ed.is_a?(EscalationEventDefinition) }
+    end
+
+    def error_event_definitions
+      event_definitions.select { |ed| ed.is_a?(ErrorEventDefinition) }
+    end
+
+    def error_event_definition
+      event_definitions.find { |ed| ed.is_a?(ErrorEventDefinition) }
+    end
+
+    def message_event_definitions
+      event_definitions.select { |ed| ed.is_a?(MessageEventDefinition) }
+    end
+
+    def signal_event_definitions
+      event_definitions.select { |ed| ed.is_a?(SignalEventDefinition) }
+    end
+
+    def terminate_event_definition
+      event_definitions.find { |ed| ed.is_a?(TerminateEventDefinition) }
+    end
+
+    def timer_event_definition
+      event_definitions.find { |ed| ed.is_a?(TimerEventDefinition) }
+    end
+
+    def execute(execution)
+      event_definitions.each { |event_definition| event_definition.execute(execution) }
+    end
+  end
+
+  class StartEvent < Event
+
+    def is_catching?
+      true
+    end
+
+    def execute(execution)
+      super
+      leave(execution)
+    end
+  end
+
+  class IntermediateThrowEvent < Event
+
+    def is_throwing?
+      true
+    end
+
+    def execute(execution)
+      super
+      leave(execution)
+    end
+  end
+
+  class IntermediateCatchEvent < Event
+
+    def is_catching?
+      true
+    end
+
+    def execute(execution)
+      super
+      execution.wait
+    end
+
+    def signal(execution)
+      leave(execution)
+    end
+  end
+
+  class BoundaryEvent < Event
+    attr_accessor :attached_to_ref, :attached_to, :cancel_activity
+
+    def initialize(attributes = {})
+      super(attributes.except(:attached_to_ref, :cancel_activity))
+
+      @attached_to_ref = attributes[:attached_to_ref]
+      @cancel_activity = true
+      if attributes[:cancel_activity].present?
+        @cancel_activity = attributes[:cancel_activity] == "false" ? false : true
+      end
+    end
+
+    def is_catching?
+      true
+    end
+
+    def execute(execution)
+      super
+      execution.wait
+    end
+
+    def signal(execution)
+      execution.attached_to.terminate if cancel_activity
+      leave(execution)
+    end
+  end
+
+  class EndEvent < Event
+
+    def is_throwing?
+      true
+    end
+
+    def execute(execution)
+      super
+      execution.end(true)
+    end
+  end
+end

data/lib/bpmn/event_definition.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module BPMN
+  class EventDefinition < Element
+    def execute(execution)
+    end
+  end
+
+  class ConditionalEventDefinition < EventDefinition
+    attr_accessor :variable_name, :variable_events, :condition
+
+    def initialize(attributes = {})
+      super(attributes.except(:variable_name, :variable_events, :condition))
+
+      @variable_name = moddle[:variable_name] # "var1"
+      @variable_events = moddle[:variable_events] # "create, update"
+      @condition = moddle[:condition] # var1 = 1
+    end
+  end
+
+  class EscalationEventDefinition < EventDefinition
+  end
+
+  class ErrorEventDefinition < EventDefinition
+    attr_accessor :error_ref, :error
+    attr_accessor :error_code_variable, :error_message_variable
+
+    def initialize(attributes = {})
+      super(attributes.except(:error_ref, :error_code_variable, :error_message_variable))
+
+      @error_ref = attributes[:error_ref]
+      @error_code_variable = attributes[:error_code_variable]
+      @error_message_variable = attributes[:error_message_variable]
+    end
+
+    def execute(execution)
+      if execution.step.is_throwing?
+        execution.throw_error(error_name)
+      else
+        execution.error_names.push error_name
+      end
+    end
+
+    def error_id
+      error&.id
+    end
+
+    def error_name
+      error&.name
+    end
+  end
+
+  class MessageEventDefinition < EventDefinition
+    attr_accessor :message_ref, :message
+
+    def initialize(attributes = {})
+      super(attributes.except(:message_ref))
+
+      @message_ref = attributes[:message_ref]
+    end
+
+    def execute(execution)
+      if execution.step.is_throwing?
+        execution.throw_message(message_name)
+      else
+        execution.message_names.push message_name
+      end
+    end
+
+    def message_id
+      message&.id
+    end
+
+    def message_name
+      message&.name
+    end
+  end
+
+  class SignalEventDefinition < EventDefinition
+    attr_accessor :signal_ref, :signal
+
+    def initialize(attributes = {})
+      super(attributes.except(:signal_ref))
+
+      @signal_ref = moddle[:signal_ref]
+    end
+
+    def signal_id
+      signal&.id
+    end
+
+    def signal_name
+      signal&.name
+    end
+  end
+
+  class TerminateEventDefinition < EventDefinition
+
+    def execute(execution)
+      execution.parent&.terminate
+    end
+  end
+
+  class TimerEventDefinition < EventDefinition
+    attr_accessor :time_date, :time_duration_type, :time_duration, :time_cycle
+
+    def initialize(attributes = {})
+      super(attributes.except(:time_date, :time_duration, :time_cycle))
+
+      @time_duration_type = attributes[:time_duration_type]
+      @time_duration = attributes[:time_duration]
+    end
+
+    def execute(execution)
+      if execution.step.is_catching?
+        execution.timer_expires_at = time_due
+      end
+    end
+
+    private
+
+    def time_due
+      # Return the next time the timer is due
+      if time_date
+        return Date.parse(time_date)
+      elsif time_duration
+        return Time.zone.now + ActiveSupport::Duration.parse(time_duration)
+      else
+        return Time.zone.now # time_cycle not yet implemented
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SpotFlow
+module BPMN
   class Execution
     attr_accessor :id, :status, :started_at, :ended_at, :variables, :tokens_in, :tokens_out, :start_event_id, :timer_expires_at, :message_names, :error_names, :condition
     attr_accessor :step, :parent, :children, :context, :attached_to_id
@@ -97,7 +97,7 @@ module SpotFlow
       @started_at = Time.zone.now
       map_input_variables if step&.input_mappings&.present?
       context.notify_listener(:execution_started, execution: self)
-      step.attachments.each { |attachment| parent.execute_step(attachment, attached_to: self) } if step.is_a?(SpotFlow::Bpmn::Activity)
+      step.attachments.each { |attachment| parent.execute_step(attachment, attached_to: self) } if step.is_a?(BPMN::Activity)
       continue
     end
 
@@ -147,7 +147,7 @@ module SpotFlow
     def throw_message(message_name, variables: {})
       waiting_children.each do |child|
         step = child.step
-        if step.is_a?(SpotFlow::Bpmn::Event) && step.message_event_definitions.any? { |message_event_definition| message_event_definition.message_name == message_name }
+        if step.is_a?(BPMN::Event) && step.message_event_definitions.any? { |message_event_definition| message_event_definition.message_name == message_name }
           child.signal(variables)
           break
         end
@@ -158,7 +158,7 @@ module SpotFlow
     def throw_error(error_name, variables: {})
       waiting_children.each do |child|
         step = child.step
-        if step.is_a?(SpotFlow::Bpmn::Event) && step.error_event_definitions.any? { |error_event_definition| error_event_definition.error_name == error_name }
+        if step.is_a?(BPMN::Event) && step.error_event_definitions.any? { |error_event_definition| error_event_definition.error_name == error_name }
           child.signal(variables)
           break
         end
@@ -175,7 +175,7 @@ module SpotFlow
     end
 
     def evaluate_expression(expression, variables: parent&.variables || {}.with_indifferent_access)
-      SpotFeel.evaluate(expression.delete_prefix("="), variables:)
+      DMN.evaluate(expression.delete_prefix("="), variables:)
     end
 
     def run_automated_tasks
@@ -202,7 +202,7 @@ module SpotFlow
     # Called by the child step executors when they have ended
     #
     def has_ended(_child)
-      step.leave(self) if step.is_a?(SpotFlow::Bpmn::SubProcess) || step.is_a?(SpotFlow::Bpmn::CallActivity)
+      step.leave(self) if step.is_a?(BPMN::SubProcess) || step.is_a?(BPMN::CallActivity)
       self.end(true)
     end
 
@@ -219,7 +219,7 @@ module SpotFlow
     end
 
     def waiting_tasks
-      waiting_children.select { |child| child.step.is_a?(SpotFlow::Bpmn::Task) }
+      waiting_children.select { |child| child.step.is_a?(BPMN::Task) }
     end
 
     def waiting_automated_tasks

data/lib/bpmn/extension_elements.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module BPMN
+  class ExtensionElements
+    VALID_EXTENSION_NAMESPACES = %w[zeebe]
+
+    attr_accessor :assignment_definition, :called_element, :called_decision, :form_definition, :io_mapping, :properties, :script, :subscription, :task_definition, :task_headers, :task_schedule
+
+    def initialize(attributes = {})
+      if attributes[:properties].present?
+        @properties = HashWithIndifferentAccess.new
+        Array.wrap(attributes[:properties][:property]).each { |property_moddle| @properties[property_moddle[:name]] = property_moddle[:value] }
+      end
+
+      @assignment_definition = Zeebe::AssignmentDefinition.new(attributes[:assignment_definition]) if attributes[:assignment_definition].present?
+      @called_element = Zeebe::CalledElement.new(attributes[:called_element]) if attributes[:called_element].present?
+      @called_decision = Zeebe::CalledDecision.new(attributes[:called_decision]) if attributes[:called_decision].present?
+      @form_definition = Zeebe::FormDefinition.new(attributes[:form_definition]) if attributes[:form_definition].present?
+      @io_mapping = Zeebe::IoMapping.new(attributes[:io_mapping]) if attributes[:io_mapping].present?
+      @script = Zeebe::Script.new(attributes[:script]) if attributes[:script].present?
+      @subscription = Zeebe::Subscription.new(attributes[:subscription]) if attributes[:subscription].present?
+      @task_definition = Zeebe::TaskDefinition.new(attributes[:task_definition]) if attributes[:task_definition].present?
+      @task_headers = Zeebe::TaskHeaders.new(attributes[:task_headers]) if attributes[:task_headers].present?
+      @task_schedule = Zeebe::TaskSchedule.new(attributes[:task_schedule]) if attributes[:task_schedule].present?
+    end
+  end
+end

data/lib/bpmn/extensions.rb

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