bpmn 0.0.1 → 0.0.2

data/lib/spot_flow/bpmn/element.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module SpotFlow
-  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(/SpotFlow::/, "")} @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
-end

data/lib/spot_flow/bpmn/event.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-module SpotFlow
-  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
-end

data/lib/spot_flow/bpmn/event_definition.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-module SpotFlow
-  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
-end

data/lib/spot_flow/bpmn/extension_elements.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module SpotFlow
-  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
-end

data/lib/spot_flow/bpmn/extensions.rb

@@ -1,77 +0,0 @@
-# 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

@@ -1,47 +0,0 @@
-# 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

@@ -1,85 +0,0 @@
-# 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