rails_workflow 0.3.9 → 0.4.0

data/lib/rails_workflow/engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsWorkflow
   class Engine < ::Rails::Engine
     isolate_namespace RailsWorkflow
@@ -17,7 +19,7 @@ module RailsWorkflow
     end
 
     initializer 'rails_workflow.assets.precompile' do |app|
-      app.config.assets.precompile += %w(application.css application.js)
+      app.config.assets.precompile += %w[application.css application.js]
     end
   end
 end

data/lib/rails_workflow/error_builder.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RailsWorkflow
+  # Default error builder. Can be changed in configuration.
+  # Manages errors building
+  class ErrorBuilder
+    attr_accessor :exception, :context
+
+    def self.handle(exception, context)
+      new(exception, context).handle
+    end
+
+    def initialize(exception, context)
+      @exception = exception
+      @context = context
+    end
+
+    def handle
+      create_error(context)
+      process_parent(target)
+    end
+
+    private
+
+    def create_error(context)
+      error = RailsWorkflow::Error.create(
+        parent: target,
+        message: exception.message.first(250),
+        stack_trace: exception.backtrace.join("<br/>\n")
+      )
+
+      error.create_context(data: context)
+    end
+
+    # Changing custom process or operation classes to default classes.
+    # If we store error with a custom class and somebody will delete
+    # or rename this class - we will not be able to load error.
+    def target
+      @target ||= begin
+        parent = context[:parent]
+        if parent.is_a? RailsWorkflow::Operation
+          parent.becomes(RailsWorkflow::Operation)
+        elsif parent.is_a? RailsWorkflow::Process
+          parent.becomes(RailsWorkflow::Process)
+        end
+      end
+    end
+
+    def process_parent(subject)
+      return if subject.nil?
+
+      subject.status = Status::ERROR
+      subject.save
+      process_parent(subject.parent) if subject.parent.present?
+    end
+  end
+end

data/lib/rails_workflow/error_resolver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RailsWorkflow
+  # Default error resolver. Can be changed in configuration.
+  # Manages errors processing
+  class ErrorResolver
+    attr_accessor :error
+    delegate :update_attribute, :target, :operation, :process,
+             :data, :can_restart_process?, to: :error
+
+    def self.retry(error)
+      new(error).retry
+    end
+
+    def initialize(error)
+      @error = error
+    end
+
+    def retry
+      update_attribute(:resolved, true)
+      fix_status(error.parent)
+      prepared_target.send(data[:method], *data[:args])
+      try_restart_process unless target == 'process_manager'
+    end
+
+    def fix_status(subject)
+      subject.status = Status::IN_PROGRESS
+      subject.save
+      fix_status(subject.parent) if subject.parent.present?
+    end
+
+    def prepared_target
+      return operation_runner if target == 'operation_runner'
+      return operation_builder if target == 'operation_builder'
+      return dependency_resolver if target == 'dependency_resolver'
+      return process_manager if target == 'process_manager'
+      target
+    end
+
+    def try_restart_process
+      return unless process.present?
+      process.update_attribute(:status, Status::IN_PROGRESS)
+
+      process.reload
+      process_runner.start if can_restart_process?
+    end
+
+    def config
+      RailsWorkflow.config
+    end
+
+    def process_manager
+      config.process_manager.new(process)
+    end
+
+    def operation_runner
+      config.operation_runner.new(operation)
+    end
+
+    def operation_builder
+      config.operation_builder.new(*data[:args]).tap { data[:args] = nil }
+    end
+
+    def dependency_resolver
+      config.dependency_resolver.new(process)
+    end
+
+    def process_runner
+      config.process_runner.new(process)
+    end
+  end
+end

data/lib/rails_workflow/operation_builder.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RailsWorkflow
+  # Operation builder which creates new operaitons including
+  # their context, child processes etc... s
+  class OperationBuilder
+    attr_accessor :process, :template, :completed_dependencies
+    delegate :attributes, :operation_class, :child_process, to: :template
+
+    def initialize(process, template, completed_dependencies = [])
+      @process = process
+      @template = template
+      @completed_dependencies = completed_dependencies
+    end
+
+    def create_operation
+      create_operation!.tap { |operation| process.operations << operation }
+    rescue => exception
+      handle_exception(exception)
+    end
+
+    def create_operation!
+      operation = operation_class.create(prepared_attributes) do |op|
+        op.context = build_context(op, completed_dependencies)
+        # Can add OperationTemplate#after_operation_create callback
+        template.after_operation_create(op) if template.respond_to?(:after_operation_create)
+      end
+
+      build_child_process(operation)
+      operation
+    end
+
+    def prepared_dependencies
+      completed_dependencies.map do |dep|
+        {
+          operation_id: dep.id,
+          status: dep.status
+        }
+      end
+    end
+
+    private
+
+    def prepared_attributes
+      attributes.with_indifferent_access
+                .slice(:title, :async, :is_background)
+                .merge(template: template,
+                       process: process,
+                       status: Operation::NOT_STARTED,
+                       manager: process.manager,
+                       dependencies: prepared_dependencies)
+    end
+
+    def build_child_process(operation)
+      return unless child_process.present?
+
+      # TODO: replace with Process Builder or replace with
+      # config process manager
+      operation.child_process = RailsWorkflow::ProcessManager
+                                .create_process(
+                                  child_process.id,
+                                  operation.context.data
+                                )
+    end
+
+    def prepare_context_data(dependencies)
+      dependencies.first.try(:context).try(:data)
+    end
+
+    # TODO: move to ContextBuilder
+    def build_context(operation, dependencies)
+      RailsWorkflow::Context.new(
+        parent: operation,
+        data: prepare_context_data(dependencies) || operation.process.data
+      )
+    end
+
+    def handle_exception(exception)
+      error_builder.handle(
+        exception,
+        parent: process, target: :operation_builder, method: :create_operation,
+        args: [process, template, completed_dependencies]
+      )
+    end
+
+    def error_builder
+      config.error_builder
+    end
+
+    # TODO: move config
+    def config
+      RailsWorkflow.config
+    end
+  end
+end

data/lib/rails_workflow/operation_runner.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RailsWorkflow
+  # Workflow::OperationRunner responsible for operation execution
+  class OperationRunner
+    attr_accessor :operation
+    delegate :can_start?, :completed?, :completable?, :update_attribute,
+             :update_attributes, :is_background, :child_process, :context,
+             to: :operation
+
+    def self.start(operations)
+      operations.each do |operation|
+        new(operation).start
+      end
+    end
+
+    def initialize(operation)
+      @operation = operation
+    end
+
+    def start
+      can_start? ? starting : waiting
+    rescue => exception
+      error_builder.handle(
+        exception,
+        parent: operation, target: :operation_runner, method: :start
+      )
+    end
+
+    def starting
+      update_attribute(:status, Status::IN_PROGRESS)
+
+      if is_background && config.activejob_enabled
+        OperationExecutionJob.perform_later(operation.id)
+      else
+        OperationExecutionJob.perform_now(operation.id)
+      end
+    end
+
+    def waiting
+      update_attribute(:status, Status::WAITING)
+      start_waiting if respond_to? :start_waiting
+    rescue => exception
+      error_builder.handle(
+        exception,
+        parent: operation,
+        target: :operation_runner,
+        method: :waiting
+      )
+    end
+
+    def execute_in_transaction
+      with_transaction do
+        child_process_runner.start if child_process.present?
+        operation.execute if operation.respond_to?(:execute)
+        complete
+      end
+    rescue => exception
+      handle_exception(exception)
+    end
+
+    def complete(to_status = Status::DONE)
+      return unless completable?
+
+      context&.save
+      update_attributes(
+        status: to_status,
+        completed_at: Time.zone.now
+      )
+      process_runner.operation_completed(operation)
+    end
+
+    def cancel
+      complete Status::CANCELED
+    end
+
+    def skip
+      complete Status::SKIPPED
+    end
+
+    private
+
+    def error_builder
+      config.error_builder
+    end
+
+    def handle_exception(exception)
+      error_builder.handle(
+        exception,
+        parent: operation, target: :operation_runner,
+        method: :execute_in_transaction
+      )
+    end
+
+    def with_transaction
+      operation.class.transaction(requires_new: true) do
+        yield
+      end
+    end
+
+    def child_process_runner
+      @child_process_runner ||= config.process_runner.new(child_process)
+    end
+
+    def process_runner
+      @process_runner ||= config.process_runner.new(operation.process)
+    end
+
+    def config
+      RailsWorkflow.config
+    end
+  end
+end

data/lib/rails_workflow/process_builder.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RailsWorkflow
+  # = 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).
+  class ProcessBuilder
+    attr_accessor :template, :context
+
+    delegate :process_class, :title, :independent_operations, to: :template
+
+    def initialize(template, context)
+      @template = template
+      @context = context
+    end
+
+    def create_process!
+      process = process_class.create(template: template)
+
+      process.update_attributes(title: title, status: Process::NOT_STARTED)
+      process.create_context(data: context, parent: process)
+
+      build_independent_operations process
+      process
+    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
+
+    def build_operation(process, template, completed_dependencies = [])
+      operation_builder.new(
+        process, template, completed_dependencies
+      ).create_operation
+    end
+
+    def error_builder
+      config.error_builder
+    end
+
+    def config
+      RailsWorkflow.config
+    end
+
+    def operation_builder
+      config.operation_builder
+    end
+  end
+end

data/lib/rails_workflow/process_manager.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+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, :template, :context
+    # delegate :template, :operation_exception, to: :process
+    delegate :complete, to: :process, prefix: true
+
+    class << self
+      def create_process(template_id, context)
+        new(template_id: template_id, context: context).create_process
+      end
+    end
+
+    def initialize(process = nil, template_id: nil, context: nil)
+      @process = process
+      @template = ProcessTemplate.find(template_id) if template_id
+      @context = context
+    end
+
+    def create_process
+      self.process = process_builder.new(template, context).create_process!
+    end
+
+    def self.start_process(template_id, context)
+      process = create_process template_id, context
+      new(process).start_process
+      process
+    end
+
+    def start_process
+      process_runner.start
+    rescue => exception
+      error_builder.handle(
+        exception,
+        parent: process,
+        target: :process_manager,
+        method: :start_process
+      )
+    end
+
+    def complete_process
+      process_runner.complete
+    end
+
+    def error_builder
+      config.error_builder
+    end
+
+    def process_builder
+      config.process_builder
+    end
+
+    def process_runner
+      @process_runner ||= config.process_runner.new(process)
+    end
+
+    def config
+      RailsWorkflow.config
+    end
+  end
+end