rails_workflow 0.3.9 → 0.4.0

data/app/concerns/rails_workflow/operation_templates/default_builder.rb

@@ -1,56 +0,0 @@
-module RailsWorkflow
-  module OperationTemplates
-    module DefaultBuilder
-      extend ActiveSupport::Concern
-
-      def build_operation(operation)
-        # for customization
-      end
-
-      def build_operation!(process, completed_dependencies = [])
-        attrs = attributes
-                .with_indifferent_access
-                .slice(:title, :async, :is_background)
-                .merge(template: self,
-                       process: process,
-                       status: Operation::NOT_STARTED,
-                       manager: process.manager)
-
-        attrs[:dependencies] = completed_dependencies.map do |dep|
-          {
-            operation_id: dep.id,
-            status: dep.status
-          }
-        end
-
-        operation = operation_class.create(attrs) do |op|
-          op.context = RailsWorkflow::OperationTemplate.build_context! op, completed_dependencies
-
-          build_operation op
-        end
-
-        if child_process.present?
-          operation.child_process = RailsWorkflow::ProcessManager
-                                    .build_process(
-                                      child_process.id,
-                                      operation.context.data
-                                    )
-        end
-        operation
-      end
-
-      module ClassMethods
-        def build_context(dependencies)
-          dependencies.first.try(:context).try(:data)
-        end
-
-        def build_context!(operation, dependencies)
-          RailsWorkflow::Context.new(
-            parent: operation,
-            data: build_context(dependencies) || operation.process.data
-          )
-        end
-      end
-    end
-  end
-end

data/app/concerns/rails_workflow/operations/default_runner.rb

@@ -1,121 +0,0 @@
-module RailsWorkflow
-  module Operations
-    #
-    # = Workflow::Operations::DefaultRunner contains operation starting,
-    # completing etc logic.
-    #
-    module DefaultRunner
-      extend ActiveSupport::Concern
-
-      included do
-        # in this default operation runner we don't need to wait anything
-        # so we just can run operation. If you need to gather some other
-        # information - feel free to redefine operation start logic but
-        # try to gather all your custom logic in operation build method.
-        # operation start can be usefull if you need to send some notifications
-        # to external systems that operation is tarted etc...
-        def start
-          can_start? ? starting : waiting
-        rescue => exception
-          RailsWorkflow::Error.create_from exception, parent: self
-        end
-
-        def starting
-          update_attribute(:status, self.class::IN_PROGRESS)
-
-          is_background && RailsWorkflow.config.activejob_enabled ?
-              OperationExecutionJob.perform_later(id) :
-              OperationExecutionJob.perform_now(id)
-        end
-
-        # This method allows you to add requirements for operation to start. For example
-        # some operation can't start because of some process or overal system conditions.
-        # By default any operation can start :)
-        def can_start?
-          status == Operation::NOT_STARTED
-        end
-
-        # move operation to waiting status. for example - for user operations
-        def waiting
-          update_attribute(:status, self.class::WAITING)
-          start_waiting if respond_to? :start_waiting
-        rescue => exception
-          RailsWorkflow::Error.create_from exception, parent: self
-        end
-
-        def execute_in_transaction
-          status = nil
-          self.class.transaction(requires_new: true) do
-            begin
-              child_process.start if child_process.present?
-              status = execute
-            rescue ActiveRecord::Rollback
-              status = nil
-            end
-
-            raise ActiveRecord::Rollback unless status
-          end
-
-          if status
-            context.save
-            complete
-          end
-
-        rescue ActiveRecord::Rollback => exception
-          # In case of rollback exception we do nothing -
-          # this may be caused by usual validations
-        rescue => exception
-          RailsWorkflow::Error.create_from(
-            exception, parent: self,
-                       target: self,
-                       method: :execute_in_transaction
-          )
-        end
-
-        def execute
-          true
-        end
-
-        def completed?
-          completed_statuses.include? status
-        end
-
-        def can_complete?
-          child_process.present? ?
-              child_process.status == RailsWorkflow::Process::DONE :
-              true
-        end
-
-        def complete(to_status = nil)
-          if can_complete?
-
-            on_complete if to_status.blank? && respond_to?(:on_complete)
-
-            update_attributes(
-              status: to_status || self.class::DONE,
-              completed_at: Time.zone.now
-            )
-            manager.operation_completed self
-          end
-        rescue => exception
-          RailsWorkflow::Error.create_from(
-            exception,                 parent: self,
-                                       target: self,
-                                       method: :complete,
-                                       args: [to_status]
-          )
-        end
-
-        def cancel
-          on_cancel if respond_to? :on_cancel
-          complete self.class::CANCELED
-        end
-
-        def skip
-          on_cancel if respond_to? :on_skip
-          complete self.class::SKIPPED
-        end
-      end
-    end
-  end
-end

data/app/concerns/rails_workflow/process_templates/default_builder.rb

@@ -1,52 +0,0 @@
-require 'active_support/concern'
-module RailsWorkflow
-  module ProcessTemplates
-    # = DefaultBuilder
-    #
-    # Process Builder is used to build new process. All process building logic should be
-    # gathered here. It defines how process is build using template (for example it can used
-    # to gather some additional information from system - for example some information from
-    # existing processes or it can handle hierarchical processes logic for parent / child
-    # processes).
-    #
-    module DefaultBuilder
-      def build_process!(context)
-        process = process_class.create template: self
-
-        process.class.transaction do
-          process.update_attributes(title: title, status: Process::NOT_STARTED)
-          process.create_context(data: context, parent: process)
-
-          build_independent_operations process
-          process
-        end
-      end
-
-      # Independent operations is template operations that have no dependencies from
-      # any other operations
-      def build_independent_operations(process)
-        independent_operations.each do |operation_template|
-          build_operation process, operation_template
-        end
-      end
-
-      # Important note: operation template contains Operation Class.
-      # You can specify custom class on template
-
-      def build_operation(process, template, completed_dependencies = [])
-        operation = template.build_operation! process, completed_dependencies
-
-        process.operations << operation if operation.present?
-
-        operation
-      rescue => exception
-        RailsWorkflow::Error.create_from(
-          exception, parent: process,
-                     target: process.template,
-                     method: :build_operation,
-                     args: [process, template, completed_dependencies]
-        )
-      end
-    end
-  end
-end

data/app/concerns/rails_workflow/processes/default_runner.rb

@@ -1,64 +0,0 @@
-module RailsWorkflow
-  module Processes
-    #= DefaultRunner
-    #
-    # This module contains logic of process start, stop, cancel etc.
-    #
-    module DefaultRunner
-      def can_start?
-        !operations.empty?
-      end
-
-      def start
-        if can_start?
-          update_attribute(:status, self.class::IN_PROGRESS)
-          operations.where(status: RailsWorkflow::Operation::NOT_STARTED).map(&:start)
-        end
-      end
-
-      def operation_exception
-        self.status = self.class::ERROR
-      end
-
-      # Process can be completed if all sync operations is complete.
-
-      def can_complete?
-        if incomplete_statuses.include? status
-          incompleted_operations.size.zero? &&
-            workflow_errors.unresolved.size.zero?
-        else
-          false
-        end
-      end
-
-      # Returns set or operation that not yet completed.
-      # Operation complete in DONE, SKIPPED, CANCELED, etc many other statuses
-      def incompleted_operations
-        operations.reject(&:completed?)
-      end
-
-      # If operation is completed process is responsible for building new operations.
-      # We need to calculate operations, depends on completed one and detect ones we
-      # can build.
-      def operation_complete(operation)
-        build_dependencies operation
-      end
-
-      def set_done_status
-        self.status = self.class::DONE
-        save
-      end
-
-      def complete_parent_operation
-        parent_operation.complete if parent_operation.present?
-      end
-
-      def complete
-        if can_complete?
-          set_done_status
-          complete_parent_operation
-        end
-     end
-    end
-  end
-end

data/app/concerns/rails_workflow/processes/dependency_resolver.rb

@@ -1,54 +0,0 @@
-module RailsWorkflow
-  module Processes
-    # = DependencyResolver
-    #
-    # New operation can be added to process if all it's dependencies are satisfied.
-    # For example current operation can depend on some existing process operation which
-    # should be completed - then current operation can be build
-
-    module DependencyResolver
-      extend ActiveSupport::Concern
-
-      included do
-        # This methods get's operations that depends on given one.
-        # Operation::DependencyResolver resolves operation template dependencies
-        # but we can define dependencies not only by template but by some other
-        # business logic on process level. That is why I splitted operation
-        # dependencies on process and operation level
-        #
-        def build_dependencies(operation)
-          new_operations = []
-
-          matched_templates(operation).each do |operation_template|
-            completed_dependencies = [operation]
-
-            if operation_template.resolve_dependency operation
-              new_operations << operation_template.build_operation!(self, completed_dependencies)
-            end
-          end
-
-          new_operations.each do |new_operation|
-            if incomplete_statuses.include?(status)
-              operations << new_operation
-              new_operation.start
-            end
-          end
-
-        rescue => exception
-          RailsWorkflow::Error.create_from(
-            exception, parent: self,
-                       target: self,
-                       method: :build_dependencies,
-                       args: [operation]
-          )
-        end
-
-        private
-
-        def matched_templates(operation)
-          template.dependent_operations(operation) - operations.map(&:template)
-        end
-      end
-    end
-  end
-end

data/app/concerns/rails_workflow/reset_cache.rb

@@ -1,13 +0,0 @@
-module RailsWorkflow::ResetCache
-  extend ActiveSupport::Concern
-
-  included do
-    after_commit :reset_cache
-
-    def reset_cache
-      RailsWorkflow.config.cache.clear
-    end
-
-  end
-
-end

data/app/jobs/rails_workflow/operation_error_job.rb

@@ -1,40 +0,0 @@
-module RailsWorkflow
-  # When some operation fails due to some exceptions this job
-  # is responsible for setting operation to error status. Also it
-  # check if there is parent processes / operations and set it
-  # to error status.
-  class OperationErrorJob < ActiveJob::Base
-    queue_as :default
-
-    def perform(*args)
-      @target_id, @target_class = args
-
-      target.status = target.class::ERROR
-      target.save
-
-      process_parents
-    end
-
-    private
-
-    # Target is either operation or process
-    def target
-      @target ||= @target_class.constantize.find(@target_id)
-    end
-
-    # Target operation have parent process and target process may have
-    # parent operation and they should also be moved to ERROR status
-    def process_parents
-      parent_methods.each do |parent_method|
-        parent_target = target.public_send(parent_method)
-        perform(parent_target.id, parent_target.class.to_s) if parent_target
-      end
-    end
-
-    # Target operation respond to process, process respond to parent_operation
-    def parent_methods
-      [:parent_operation, :process]
-        .select { |method_name| target.respond_to?(method_name) }
-    end
-  end
-end

data/app/managers/rails_workflow/process_manager.rb

@@ -1,40 +0,0 @@
-module RailsWorkflow
-  # ProcessManager should be used to build and start processes.
-  # It is top level hierarchy class that also can be used
-  # to build enhancements. For example they can be used to implement
-  # processes communications.
-  class ProcessManager
-    attr_accessor :process
-    delegate :template, :operation_exception, to: :process
-    delegate :complete, to: :process, prefix: true
-
-    def initialize(process = nil)
-      @process = process
-    end
-
-    def self.build_process(template_id, context)
-      RailsWorkflow.config.template(template_id).build_process!(context)
-    end
-
-    def self.start_process(template_id, context)
-      process = build_process template_id, context
-      new(process).start_process
-      process
-    end
-
-    def start_process
-      process.start
-    rescue => exception
-      RailsWorkflow::Error.create_from exception, parent: process
-    end
-
-    def operation_completed(operation)
-      process.operation_complete operation
-      process_complete
-    end
-
-    def complete_process
-      process.complete
-    end
-  end
-end