flow_core 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d31b83d470547f95bbe973b6376c596a2d2ebe7c5d15efe569452a4342cfe5b8
-  data.tar.gz: 1b7ae085f8487d2d6765cb946435b5f83c1d32bbea26e625303ee8941ec2efa1
+  metadata.gz: 743fbfab50000cf6b47c17fe0d90d962faad47fb8eeb0cb44df1e777b56fff0d
+  data.tar.gz: 67d9e0a9f7e7f47d0d958116f4e10d5e885e80ce6b929aa49c49ae844cdc2c18
 SHA512:
-  metadata.gz: 1765159897d571c89c05b3cca8f3d30229a13e6511a3797f8bfda0620540ac97940132bcc019a80fd371b1db8680bba91cca27927c841a54e0c4f48f88ad80ca
-  data.tar.gz: c6d354ddecbdda0596132ad83d56fce39bcbb9ab05a7a642e4c20bfa557ef792a0932156d6be195d8a66ff7e6143fc076a46a166e62be6cc77e33152a888d1de
+  metadata.gz: e7b941b64b50e8d083832c3faf1c22f729473fbf1ac7ed1a0ba67f0831bb9d1a7078f95c008f18ae77138358be376124c47c094fb97d6b41ecf18e99f78a0c68
+  data.tar.gz: 35f944cd17e0b9d07afc0903198ffa9cc43f7d74858fa778112ae4a7c69a0de6a59e21354ab9c4460e2eafb8800f790aa12270dce06ffc85e1bfcafd643e5fca

data/README.md

@@ -92,6 +92,13 @@ Import sample workflow
 $ bin/rails db:seed
 ```
 
+Build Script Core
+
+```sh
+$ bin/rails app:script_core:engine:build
+$ bin/rails app:script_core:engine:compile_lib
+```
+
 Start the Rails server
 
 ```sh

data/app/models/flow_core/arc.rb

@@ -19,6 +19,14 @@ module FlowCore
               uniqueness: {
                 scope: %i[workflow transition direction]
               }
+    validates :fallback_arc,
+              uniqueness: {
+                scope: %i[workflow transition direction]
+              }, if: :fallback_arc?
+
+    before_validation on: :create do
+      self.workflow ||= place&.workflow || transition&.workflow
+    end
 
     before_destroy :prevent_destroy
     after_create :reset_workflow_verification

data/app/models/flow_core/arc_guard.rb

@@ -4,13 +4,38 @@ module FlowCore
   class ArcGuard < FlowCore::ApplicationRecord
     self.table_name = "flow_core_arc_guards"
 
-    belongs_to :workflow, class_name: "FlowCore::Workflow"
-    belongs_to :arc, class_name: "FlowCore::Arc"
+    belongs_to :workflow, class_name: "FlowCore::Workflow", optional: true
+    belongs_to :arc, class_name: "FlowCore::Arc", optional: true
 
     has_one :transition, through: :arc, class_name: "FlowCore::Transition"
 
+    belongs_to :pipeline, class_name: "FlowCore::Pipeline", optional: true
+    belongs_to :branch, class_name: "FlowCore::Branch", optional: true
+
+    validates :arc,
+              presence: true,
+              if: ->(r) { r.workflow }
+    validates :branch,
+              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 ||= arc&.workflow
+      self.pipeline ||= branch&.pipeline
+    end
+
+    def configurable?
+      false
+    end
+
+    def type_key
+      self.class.to_s.split("::").last.underscore
     end
 
     include FlowCore::ArcGuardable

data/app/models/flow_core/branch.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module FlowCore
+  class Branch < FlowCore::ApplicationRecord
+    self.table_name = "flow_core_branches"
+
+    belongs_to :pipeline, class_name: "FlowCore::Pipeline"
+    belongs_to :step, class_name: "FlowCore::Step"
+
+    has_many :arc_guards, class_name: "FlowCore::ArcGuard", dependent: :destroy
+
+    has_many :steps, -> { order(position: :asc) },
+             class_name: "FlowCore::Step", inverse_of: :branch,
+             dependent: :destroy
+
+    validates :name,
+              presence: true
+
+    validates :fallback_branch,
+              uniqueness: {
+                scope: %i[step_id]
+              }, if: :fallback_branch?
+
+    before_validation do
+      self.pipeline ||= step.pipeline
+    end
+
+    def user_destroyable?
+      !fallback_branch || (fallback_branch? && !step.fallback_branch_required?)
+    end
+
+    def arc_guard_attachable?
+      !fallback_branch? && step.branch_arc_guard_attachable?
+    end
+
+    def copy_arc_guards_to(arc)
+      return unless arc_guard_attachable?
+
+      arc_guards.find_each do |arc_guard|
+        new_guard = arc_guard.dup
+        new_guard.arc = arc
+        new_guard.pipeline = nil
+        new_guard.branch = nil
+        new_guard.save!
+      end
+    end
+  end
+end

data/app/models/flow_core/instance.rb

@@ -27,6 +27,8 @@ module FlowCore
     scope :errored, -> { where.not(errored_at: nil) }
     scope :suspended, -> { where.not(suspended_at: nil) }
 
+    validate :on_create_validation, on: :create
+
     after_initialize do
       self.payload ||= {}
     end
@@ -66,10 +68,11 @@ module FlowCore
       return false unless can_activate?
 
       with_transaction_returning_status do
-        tokens.create! place: workflow.start_place
         update! stage: :activated, activated_at: Time.zone.now
         workflow.on_instance_activate(self)
 
+        tokens.create! place: workflow.start_place
+
         true
       end
     end
@@ -117,5 +120,11 @@ module FlowCore
     def terminate!(reason:)
       terminate(reason: reason) || raise(FlowCore::InvalidTransition, "Can't terminate Instance##{id}")
     end
+
+    private
+
+      def on_create_validation
+        workflow.on_instance_create_validation(self)
+      end
   end
 end

data/app/models/flow_core/pipeline.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module FlowCore
+  class Pipeline < FlowCore::ApplicationRecord
+    self.table_name = "flow_core_pipelines"
+
+    has_many :generated_workflows,
+             class_name: "FlowCore::Workflow", foreign_key: :generated_by_pipeline_id,
+             inverse_of: :generated_by, dependent: :nullify
+
+    has_many :steps, -> { where(branch_id: nil).order(position: :asc) },
+             class_name: "FlowCore::Step", inverse_of: :pipeline,
+             dependent: :destroy
+
+    has_many :branches, class_name: "FlowCore::Branch", dependent: :restrict_with_exception
+    has_many :whole_steps, class_name: "FlowCore::Step", inverse_of: :pipeline, dependent: :restrict_with_exception
+
+    validates :name,
+              presence: true
+
+    def deploy_workflow
+      return if steps.empty?
+      return if whole_steps.exists? verified: false
+
+      workflow = nil
+      transaction do
+        workflow = generated_workflows.new name: name, type: workflow_class.to_s
+        on_build_workflow(workflow)
+        workflow.save!
+
+        end_place = workflow.create_end_place!
+
+        place_or_transition = nil
+        steps.each do |step|
+          place_or_transition = step.deploy_to_workflow!(workflow, place_or_transition)
+        end
+
+        if place_or_transition.is_a? FlowCore::Place
+          place_or_transition.input_arcs.update place: end_place
+          place_or_transition.reload.destroy!
+        else
+          end_place.input_transitions << place_or_transition
+        end
+      end
+      workflow&.verify!
+
+      workflow
+    end
+
+    private
+
+      def on_build_workflow(_workflow); end
+
+      def workflow_class
+        FlowCore::Workflow
+      end
+  end
+end

data/app/models/flow_core/place.rb

@@ -10,10 +10,11 @@ module FlowCore
 
     # NOTE: Place - out -> Transition - in -> Place
     has_many :input_arcs, -> { where direction: :out },
-             class_name: "FlowCore::Arc", inverse_of: :place, dependent: :delete_all
+             class_name: "FlowCore::Arc", inverse_of: :place, dependent: :destroy
     has_many :output_arcs, -> { where direction: :in },
              class_name: "FlowCore::Arc", inverse_of: :place, dependent: :delete_all
 
+    has_many :input_transitions, through: :input_arcs, class_name: "FlowCore::Transition", source: :transition
     has_many :output_transitions, through: :output_arcs, class_name: "FlowCore::Transition", source: :transition
 
     before_destroy :prevent_destroy

data/app/models/flow_core/step.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+module FlowCore
+  class Step < FlowCore::ApplicationRecord
+    self.table_name = "flow_core_steps"
+
+    has_many :generated_transitions,
+             class_name: "FlowCore::Transition", foreign_key: :generated_by_step_id,
+             inverse_of: :generated_by, dependent: :nullify
+
+    belongs_to :pipeline, class_name: "FlowCore::Pipeline"
+    belongs_to :branch, class_name: "FlowCore::Branch", optional: true
+
+    has_many :branches, class_name: "FlowCore::Branch", inverse_of: :step, dependent: :destroy
+    belongs_to :redirect_to_step, class_name: "FlowCore::Step", optional: true
+    has_one :transition_trigger, class_name: "FlowCore::TransitionTrigger", dependent: :destroy
+    has_many :transition_callbacks, class_name: "FlowCore::TransitionCallback", dependent: :destroy
+
+    extend Ancestry::HasAncestry
+    has_ancestry orphan_strategy: :restrict
+
+    extend ActiveRecord::Acts::List::ClassMethods
+    acts_as_list scope: %i[pipeline_id branch_id]
+
+    validates :name,
+              presence: true
+
+    validates :type,
+              presence: true
+
+    validates :redirect_to_step,
+              inclusion: {
+                in: :redirectable_steps
+              },
+              allow_nil: true
+
+    validate do
+      if branch && branch.pipeline_id != pipeline_id
+        errors.add :branch, :invalid
+      end
+
+      if redirect_to_step && redirect_to_step.pipeline_id != pipeline_id
+        errors.add :redirect_to_step, :invalid
+      end
+
+      if redirection_step?
+        if !branch
+          errors.add :type, :invalid
+        elsif branch.fallback_branch?
+          errors.add :type, :invalid
+        end
+      end
+    end
+
+    before_validation do
+      self.pipeline ||= branch&.pipeline
+    end
+
+    before_save :update_parent
+    before_save :update_verified
+
+    after_create :reorder_by_append_to_on_create
+    after_destroy :recheck_redirection_steps_on_destroy
+
+    attr_accessor :append_to
+
+    def deploy_to_workflow!(_workflow, _input_place_or_transition)
+      raise NotImplementedError
+    end
+
+    def redirection_step?
+      self.class.redirection_step?
+    end
+
+    def multi_branch_step?
+      self.class.multi_branch_step?
+    end
+
+    def barrier_step?
+      self.class.barrier_step?
+    end
+
+    def transition_trigger_attachable?
+      self.class.transition_trigger_attachable?
+    end
+
+    def transition_callback_attachable?
+      self.class.transition_callback_attachable?
+    end
+
+    def branch_arc_guard_attachable?
+      self.class.branch_arc_guard_attachable?
+    end
+
+    def fallback_branch_required?
+      self.class.fallback_branch_required?
+    end
+
+    def transition_trigger_required?
+      self.class.transition_trigger_required?
+    end
+
+    def redirection_configurable?
+      self.class.redirection_configurable?
+    end
+
+    def branch_configurable?
+      self.class.branch_configurable?
+    end
+
+    def redirectable_steps
+      return [] unless redirection_step?
+
+      redirectable_steps = []
+
+      # Barrier step is the stop point, beyond if can't ensure the workflow valid
+      # e.g. consider there's a redirection step in one of branch of a parallel branch step,
+      # the parallel branch step is the barrier step, if redirect beyond the barrier step,
+      # it will multiplex all branches again and again
+      # Barrier step 是保障流程的边界，如果重定向到边界外的节点，就无法保证流程合法，
+      # 一个例子是假设并发分支步骤的某个分支里有一个重定向节点，并发分支步骤就是一个 Barrier Step，
+      # 如果可以重定向到并发分支步骤外，重定向到步骤后会重新执行这个并发分支步骤，导致其他分支的步骤会被无限重复执行
+      ancestors.reverse_each do |step|
+        break if step.barrier_step?
+
+        redirectable_steps << step
+      end
+
+      # return an empty array if there's no safe ancestor,
+      # redirect to steps which in current branch in not safe, because it will infinite loop
+      # 如果一个安全的祖先步骤都没有，就返回空集，跳到当前分支的步骤会导致死循环或者死代码，没有意义
+      return [] if redirectable_steps.empty?
+
+      # if the redirection step is the first step of a branch,
+      # avoiding redirect to parent and ancestors which are first step (of a branch) and without a transition trigger,
+      # because it will lead infinite loop,
+      # 如果重定向步骤是分支的第一步，那么父步骤和其他也是处于（分支）第一步的祖先，也都要避免跳转，因为会导致死循环
+      if position == 1 && redirectable_steps.any?
+        if redirectable_steps.first.multi_branch_step? && !redirectable_steps.first.transition_trigger
+          redirectable_steps.shift
+        end
+
+        while redirectable_steps.any?
+          step = redirectable_steps.first
+          if step.multi_branch_step? && !redirectable_steps.first.transition_trigger
+            redirectable_steps.shift
+
+            if step.position > 1
+              break
+            end
+          else
+            break
+          end
+        end
+      end
+
+      # It's safe to redirect to any top level (or main branch) steps,
+      # just avoiding the redirect step's ancestor, because it may lead infinite loop
+      # 跳到顶层（或者说主干）步骤都是安全的，只是要去掉跳转步骤的祖先，因为会导致死循环
+      if redirectable_steps.reject!(&:root?)
+        redirectable_steps.concat(pipeline.steps)
+      elsif redirectable_steps.empty?
+        redirectable_steps.concat(pipeline.steps - ancestors)
+      end
+
+      # It's also safe to redirect to any of children steps,
+      # just avoid current branch which the redirection step belongs to.
+      # 跳转到任何步骤的分支也都是安全的，就是要避免分支是当前跳转步骤的祖先步骤
+      redirectable_steps.map! do |s|
+        if s.parent_of? self
+          [s].concat s.children.where.not(branch_id: branch_id)
+        else
+          [s].concat s.children
+        end
+      end
+      redirectable_steps.flatten!
+      redirectable_steps.uniq!
+      redirectable_steps.reject!(&:redirection_step?)
+
+      redirectable_steps
+    end
+
+    class << self
+      def multi_branch_step?
+        false
+      end
+
+      def redirection_step?
+        false
+      end
+
+      def barrier_step?
+        false
+      end
+
+      def transition_trigger_attachable?
+        !multi_branch_step? && !redirection_step?
+      end
+
+      def transition_callback_attachable?
+        !multi_branch_step?
+      end
+
+      def branch_arc_guard_attachable?
+        false
+      end
+
+      def redirection_configurable?
+        false
+      end
+
+      def branch_configurable?
+        false
+      end
+
+      def transition_trigger_required?
+        false
+      end
+
+      def fallback_branch_required?
+        false
+      end
+    end
+
+    private
+
+      def update_verified
+        self.verified = valid?
+      end
+
+      def find_or_create_input_place(workflow, input_place_or_transition)
+        if input_place_or_transition.is_a? FlowCore::Transition
+          input_place_or_transition.output_places.create! workflow: workflow
+        elsif input_place_or_transition.is_a? FlowCore::Place
+          input_place_or_transition
+        elsif workflow.start_place
+          workflow.start_place
+        else
+          workflow.create_start_place!
+        end
+      end
+
+      def copy_transition_trigger_to(transition)
+        return unless transition_trigger_attachable?
+        return unless transition_trigger
+
+        trigger = transition_trigger.dup
+        trigger.transition = transition
+        trigger.pipeline = nil
+        trigger.step = nil
+
+        trigger.save!
+      end
+
+      def copy_transition_callbacks_to(transition)
+        return unless transition_callback_attachable?
+
+        transition_callbacks.find_each do |cb|
+          new_cb = cb.dup
+          new_cb.transition = transition
+          new_cb.pipeline = nil
+          new_cb.step = nil
+          new_cb.save!
+        end
+      end
+
+      def deploy_branches_to(workflow, input_transition, append_to_place_or_transition)
+        return unless multi_branch_step?
+
+        branches.includes(:steps, :arc_guards).find_each do |branch|
+          if branch.steps.empty?
+            if append_to_place_or_transition.is_a?(FlowCore::Place)
+              arc = input_transition.output_arcs.create! place: append_to_place_or_transition, fallback_arc: branch.fallback_branch?
+            else
+              place = workflow.places.create! workflow: workflow
+              arc = append_to_place_or_transition.input_arcs.create! place: place, fallback_arc: branch.fallback_branch?
+            end
+            branch.copy_arc_guards_to arc
+
+            next
+          end
+
+          place = workflow.places.create! workflow: workflow
+          arc = input_transition.output_arcs.create! place: place, fallback_arc: branch.fallback_branch?
+          branch.copy_arc_guards_to arc
+
+          place_or_transition = nil
+          branch.steps.each do |step|
+            place_or_transition = step.deploy_to_workflow!(workflow, place_or_transition || place)
+          end
+          next unless place_or_transition
+
+          if place_or_transition.is_a? FlowCore::Transition
+            if append_to_place_or_transition.is_a?(FlowCore::Place)
+              place_or_transition.output_places << append_to_place_or_transition
+            else
+              place = place_or_transition.output_places.create! workflow: workflow
+              place.output_transitions << append_to_place_or_transition
+            end
+          elsif append_to_place_or_transition.is_a?(FlowCore::Place)
+            place_or_transition.input_arcs.update place: append_to_place_or_transition
+            place_or_transition.reload.destroy!
+          else
+            place_or_transition.output_places << append_to_place_or_transition
+          end
+        end
+      end
+
+      def reorder_by_append_to_on_create
+        return unless append_to
+
+        if append_to.to_s == "start"
+          move_to_top
+          return
+        end
+
+        append_to_step = self.class.find_by id: append_to
+        return unless append_to_step && append_to_step.branch_id == branch_id
+
+        insert_at(append_to_step.position + 1)
+      end
+
+      def recheck_redirection_steps_on_destroy
+        return unless branch
+
+        branch.steps.to_a.select(&:redirection_step?).each do |step|
+          unless step.redirectable_steps.include? step.redirect_to_step
+            step.update! redirect_to_step: nil
+          end
+        end
+      end
+
+      def update_parent
+        self.parent = branch&.step
+      end
+  end
+end