flow_core 0.0.3 → 0.0.5

data/app/models/flow_core/steps/end.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module FlowCore::Steps
+  class End < FlowCore::Step
+    def deploy_to_workflow!(workflow, input_place_or_transition)
+      target_place = workflow.end_place || workflow.create_end_place!
+
+      if input_place_or_transition.is_a? FlowCore::Transition
+        target_place.input_transitions << input_place_or_transition
+      else
+        input_place_or_transition.input_arcs.update place: target_place
+        input_place_or_transition.reload.destroy!
+      end
+
+      nil
+    end
+
+    class << self
+      def creatable?
+        true
+      end
+
+      def redirection_step?
+        true
+      end
+
+      def redirection_configurable?
+        false
+      end
+    end
+  end
+end

data/app/models/flow_core/steps/exclusive_choice.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module FlowCore::Steps
+  class ExclusiveChoice < FlowCore::Step
+    after_create :auto_create_fallback_branch
+
+    def deploy_to_workflow!(workflow, input_transition)
+      return input_transition if branches.empty?
+
+      input_place = find_or_create_input_place(workflow, input_transition)
+      exclusive_choice_transition =
+        if transition_trigger
+          t = input_place.output_transitions.create! workflow: workflow,
+                                                     name: name,
+                                                     output_token_create_strategy: :match_one_or_fallback,
+                                                     generated_by_step_id: id
+          copy_transition_trigger_to t
+          copy_transition_callbacks_to t
+          t
+        else
+          input_place.output_transitions.create! workflow: workflow,
+                                                 name: name,
+                                                 output_token_create_strategy: :match_one_or_fallback,
+                                                 auto_finish_strategy: "synchronously",
+                                                 generated_by_step_id: id
+        end
+
+      simple_merge_place = workflow.places.create! workflow: workflow
+
+      deploy_branches_to(workflow, exclusive_choice_transition, simple_merge_place)
+
+      simple_merge_place
+    end
+
+    def transition_trigger_attachable?
+      true
+    end
+
+    def branch_arc_guard_attachable?
+      true
+    end
+
+    def fallback_branch_required?
+      true
+    end
+
+    class << self
+      def creatable?
+        true
+      end
+
+      def multi_branch_step?
+        true
+      end
+
+      def transition_callback_attachable?
+        true
+      end
+
+      def branch_configurable?
+        true
+      end
+    end
+
+    private
+
+      def auto_create_fallback_branch
+        branches.create! name: I18n.t("flow_core.pipeline.fallback_branch_name"),
+                         fallback_branch: true
+      end
+  end
+end

data/app/models/flow_core/steps/parallel_split.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module FlowCore::Steps
+  class ParallelSplit < FlowCore::Step
+    def deploy_to_workflow!(workflow, input_transition)
+      return input_transition if branches.empty?
+
+      input_place = find_or_create_input_place(workflow, input_transition)
+      parallel_split_transition =
+        input_place.output_transitions.create! workflow: workflow,
+                                               name: name,
+                                               auto_finish_strategy: "synchronously",
+                                               generated_by_step_id: id
+      synchronization_transition =
+        workflow.transitions.create! workflow: workflow,
+                                     name: I18n.t("flow_core.pipeline.synchronization_transition_name"),
+                                     auto_finish_strategy: "synchronously"
+
+      deploy_branches_to(workflow, parallel_split_transition, synchronization_transition)
+
+      synchronization_transition
+    end
+
+    class << self
+      def creatable?
+        true
+      end
+
+      def multi_branch_step?
+        true
+      end
+
+      def branch_configurable?
+        true
+      end
+
+      def barrier_step?
+        true
+      end
+    end
+  end
+end

data/app/models/flow_core/steps/redirection.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module FlowCore::Steps
+  class Redirection < FlowCore::Step
+    def deploy_to_workflow!(workflow, input_place_or_transition)
+      target_transition = workflow.transitions.find_by! generated_by_step_id: redirect_to_step_id
+      target_place = target_transition.input_places.first
+
+      if input_place_or_transition.is_a? FlowCore::Transition
+        target_place.input_transitions << input_place_or_transition
+      else
+        input_place_or_transition.input_arcs.update place: target_place
+        input_place_or_transition.reload.destroy!
+      end
+
+      nil
+    end
+
+    class << self
+      def creatable?
+        true
+      end
+
+      def redirection_step?
+        true
+      end
+
+      def redirection_configurable?
+        true
+      end
+    end
+
+    private
+
+      def update_verified
+        self.verified = valid? && redirect_to_step_id.present?
+      end
+  end
+end

data/app/models/flow_core/steps/task.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module FlowCore::Steps
+  class Task < FlowCore::Step
+    def deploy_to_workflow!(workflow, input_place_or_transition)
+      input_place = find_or_create_input_place(workflow, input_place_or_transition)
+
+      transition = input_place.output_transitions.create! workflow: workflow, name: name, generated_by_step_id: id
+      copy_transition_trigger_to transition
+      copy_transition_callbacks_to transition
+
+      transition
+    end
+
+    class << self
+      def creatable?
+        true
+      end
+
+      def transition_trigger_required?
+        true
+      end
+    end
+  end
+end

data/app/models/flow_core/task.rb

@@ -80,15 +80,20 @@ module FlowCore
     def enable
       return false unless can_enable?
 
-      with_transaction_returning_status do
-        input_free_tokens.each(&:lock!)
-        update! stage: :enabled, enabled_at: Time.zone.now
+      status =
+        with_transaction_returning_status do
+          input_free_tokens.each(&:lock!)
+          update! stage: :enabled, enabled_at: Time.zone.now
 
-        transition.on_task_enable(self)
-        workflow.on_instance_task_enable(self)
+          transition.on_task_enable(self)
+          workflow.on_instance_task_enable(self)
 
-        true
-      end
+          true
+        end
+
+      try_auto_finish if status
+
+      status
     end
 
     def finish
@@ -170,7 +175,7 @@ module FlowCore
       return if output_token_created
 
       with_transaction_returning_status do
-        transition.create_tokens_for_output(task: self)
+        transition.create_output_tokens_for(self)
         update! output_token_created: true
 
         true
@@ -220,5 +225,13 @@ module FlowCore
       def same_origin_tasks
         instance.tasks.where(created_by_token: created_by_token)
       end
+
+      def try_auto_finish
+        return unless can_finish?
+
+        if transition.auto_finish_strategy == "synchronously"
+          finish
+        end
+      end
   end
 end

data/app/models/flow_core/transition.rb

@@ -6,19 +6,36 @@ module FlowCore
 
     FORBIDDEN_ATTRIBUTES = %i[workflow_id created_at updated_at].freeze
 
+    belongs_to :generated_by,
+               class_name: "FlowCore::Step", foreign_key: :generated_by_step_id,
+               inverse_of: :generated_transitions, optional: true
+
     belongs_to :workflow, class_name: "FlowCore::Workflow"
 
     # NOTE: Place - out -> Transition - in -> Place
     has_many :input_arcs, -> { where(direction: :in) },
-             class_name: "FlowCore::Arc", inverse_of: :transition, dependent: :delete_all
+             class_name: "FlowCore::Arc", inverse_of: :transition, dependent: :destroy
     has_many :output_arcs, -> { where(direction: :out) },
              class_name: "FlowCore::Arc", inverse_of: :transition, dependent: :destroy
 
     has_many :input_places, through: :input_arcs, class_name: "FlowCore::Place", source: :place
+    has_many :output_places, through: :output_arcs, class_name: "FlowCore::Place", source: :place
 
     has_one :trigger, class_name: "FlowCore::TransitionTrigger", dependent: :delete
     has_many :callbacks, class_name: "FlowCore::TransitionCallback", dependent: :delete_all
 
+    enum output_token_create_strategy: {
+      petri_net: 0,
+      match_one_or_fallback: 1
+    }, _suffix: :strategy
+
+    enum auto_finish_strategy: {
+      disabled: 0,
+      synchronously: 1
+    }, _prefix: :auto_finish
+
+    accepts_nested_attributes_for :trigger
+
     before_destroy :prevent_destroy
     after_create :reset_workflow_verification
     after_destroy :reset_workflow_verification
@@ -57,7 +74,7 @@ module FlowCore
       end
     end
 
-    def create_tokens_for_output(task:)
+    def create_output_tokens_for(task)
       instance = task.instance
       arcs = output_arcs.includes(:place, :guards).to_a
 
@@ -68,12 +85,18 @@ module FlowCore
           return
         end
 
-        arcs.delete(end_arc)
+        unless end_arc.fallback_arc?
+          arcs.delete(end_arc)
+        end
       end
 
-      candidate_arcs = arcs.select do |arc|
-        arc.guards.empty? || arc.guards.map { |guard| guard.permit? task }.reduce(&:&)
-      end
+      candidate_arcs =
+        case output_token_create_strategy
+        when "match_one_or_fallback"
+          find_output_arcs_with_match_one_or_fallback_strategy(arcs, task)
+        else
+          find_output_arcs_with_petri_net_strategy(arcs, task)
+        end
 
       if candidate_arcs.empty?
         # TODO: find a better way
@@ -127,6 +150,21 @@ module FlowCore
 
     private
 
+      def find_output_arcs_with_petri_net_strategy(arcs, task)
+        arcs.select do |arc|
+          arc.guards.empty? || arc.guards.map { |guard| guard.permit? task }.reduce(&:&)
+        end
+      end
+
+      def find_output_arcs_with_match_one_or_fallback_strategy(arcs, task)
+        fallback_arc = arcs.find(&:fallback_arc?)
+        candidate_arcs = arcs.select do |arc|
+          !arc.fallback_arc? && (arc.guards.empty? || arc.guards.map { |guard| guard.permit? task }.reduce(&:&))
+        end
+
+        [candidate_arcs.first || fallback_arc]
+      end
+
       def reset_workflow_verification
         workflow.reset_workflow_verification!
       end

data/app/models/flow_core/transition_callback.rb

@@ -4,11 +4,28 @@ module FlowCore
   class TransitionCallback < FlowCore::ApplicationRecord
     self.table_name = "flow_core_transition_callbacks"
 
-    belongs_to :workflow, class_name: "FlowCore::Workflow"
-    belongs_to :transition, class_name: "FlowCore::Transition"
+    belongs_to :workflow, class_name: "FlowCore::Workflow", optional: true
+    belongs_to :transition, class_name: "FlowCore::Transition", optional: true
+
+    belongs_to :pipeline, class_name: "FlowCore::Pipeline", optional: true
+    belongs_to :step, class_name: "FlowCore::Step", optional: true
+
+    validates :transition,
+              presence: true,
+              if: ->(r) { r.workflow }
+    validates :step,
+              presence: true,
+              if: ->(r) { r.pipeline }
+    validates :workflow,
+              presence: true,
+              if: ->(r) { !r.pipeline }
+    validates :pipeline,
+              presence: true,
+              if: ->(r) { !r.workflow }
 
     before_validation do
       self.workflow ||= transition&.workflow
+      self.pipeline ||= step&.pipeline
     end
 
     def configurable?

data/app/models/flow_core/transition_trigger.rb

@@ -4,11 +4,28 @@ module FlowCore
   class TransitionTrigger < FlowCore::ApplicationRecord
     self.table_name = "flow_core_transition_triggers"
 
-    belongs_to :workflow, class_name: "FlowCore::Workflow"
-    belongs_to :transition, class_name: "FlowCore::Transition"
+    belongs_to :workflow, class_name: "FlowCore::Workflow", optional: true
+    belongs_to :transition, class_name: "FlowCore::Transition", optional: true
+
+    belongs_to :pipeline, class_name: "FlowCore::Pipeline", optional: true
+    belongs_to :step, class_name: "FlowCore::Step", optional: true
+
+    validates :transition,
+              presence: true,
+              if: ->(r) { r.workflow }
+    validates :step,
+              presence: true,
+              if: ->(r) { r.pipeline }
+    validates :workflow,
+              presence: true,
+              if: ->(r) { !r.pipeline }
+    validates :pipeline,
+              presence: true,
+              if: ->(r) { !r.workflow }
 
     before_validation do
       self.workflow ||= transition&.workflow
+      self.pipeline ||= step&.pipeline
     end
 
     def configurable?

data/app/models/flow_core/workflow.rb

@@ -6,6 +6,10 @@ module FlowCore
 
     FORBIDDEN_ATTRIBUTES = %i[verified verified_at created_at updated_at].freeze
 
+    belongs_to :generated_by,
+               class_name: "FlowCore::Pipeline", foreign_key: :generated_by_pipeline_id,
+               inverse_of: :generated_workflows, optional: true
+
     has_many :instances, class_name: "FlowCore::Instance", dependent: :destroy
 
     has_many :arcs, class_name: "FlowCore::Arc", dependent: :destroy
@@ -53,10 +57,10 @@ module FlowCore
       violations.clear
 
       unless start_place
-        violations.add(:start_place, :presence)
+        violations.add(self, :no_start_place)
       end
       unless end_place
-        violations.add(:end_place, :presence)
+        violations.add(self, :no_end_place)
       end
 
       return false unless start_place && end_place
@@ -69,7 +73,7 @@ module FlowCore
       end_place_code = "P_#{end_place.id}"
 
       unless rgl.path?(start_place_code, end_place_code)
-        violations.add :end_place, :unreachable
+        violations.add end_place, :unreachable
       end
 
       places.find_each do |p|
@@ -119,15 +123,18 @@ module FlowCore
 
     def verify!
       update! verified: verify?, verified_at: Time.zone.now
-      violations.empty?
+      verified
     end
 
     def reset_workflow_verification!
+      return unless verified?
+
       update! verified: false, verified_at: nil
     end
 
     def fork
       new_workflow = dup
+
       transaction do
         yield new_workflow if block_given?
         new_workflow.save!