opera 0.1.0

data/lib/opera/operation/base.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    class Base
+      extend Gem::Deprecate
+      include Opera::Operation::Builder
+
+      attr_accessor :context
+      attr_reader :params, :dependencies, :result
+
+      def initialize(params: {}, dependencies: {})
+        @context = {}
+        @finished = false
+        @result = Result.new
+        @params = params.freeze
+        @dependencies = dependencies.freeze
+      end
+
+      def config
+        self.class.config
+      end
+
+      def finish
+        finish!
+      end
+
+      deprecate :finish, :finish!, 2019, 6
+
+      def finish!
+        @finished = true
+      end
+
+      def finished?
+        @finished
+      end
+
+      class << self
+        def call(args = {})
+          operation = new(params: args.fetch(:params, {}), dependencies: args.fetch(:dependencies, {}))
+          executor = Executor.new(operation)
+          executor.evaluate_instructions(instructions)
+          executor.result
+        end
+
+        def config
+          @config ||= Config.new
+        end
+
+        def configure
+          yield config
+        end
+
+        def reporter
+          config.reporter
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    module Builder
+      INSTRUCTIONS = %I[validate transaction benchmark step success operation operations].freeze
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def instructions
+          @instructions ||= []
+        end
+
+        INSTRUCTIONS.each do |instruction|
+          define_method instruction do |method = nil, &blk|
+            instructions.concat(InnerBuilder.new.send(instruction, method, &blk))
+          end
+        end
+      end
+
+      class InnerBuilder
+        attr_reader :instructions
+
+        def initialize(&block)
+          @instructions = []
+          instance_eval(&block) if block_given?
+        end
+
+        INSTRUCTIONS.each do |instruction|
+          define_method instruction do |method = nil, &blk|
+            instructions << if !blk.nil?
+                              {
+                                kind: instruction,
+                                instructions: InnerBuilder.new(&blk).instructions
+                              }
+                            else
+                              {
+                                kind: instruction,
+                                method: method
+                              }
+                            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/config.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    class Config
+      attr_accessor :transaction_class, :transaction_method, :reporter
+
+      def initialize
+        @transaction_class = self.class.transaction_class
+        @transaction_method = self.class.transaction_method || :transaction
+        @reporter = custom_reporter || self.class.reporter
+      end
+
+      def configure
+        yield self
+      end
+
+      def custom_reporter
+        Rails.application.config.x.reporter.presence if defined?(Rails)
+      end
+
+      class << self
+        attr_accessor :transaction_class, :transaction_method, :reporter
+
+        def configure
+          yield self
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/executor.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    class Executor
+      attr_reader :operation
+
+      def initialize(operation)
+        @operation = operation
+      end
+
+      def call(instruction)
+        instructions = instruction[:instructions]
+
+        if instructions
+          evaluate_instructions(instructions)
+        else
+          evaluate_instruction(instruction)
+        end
+      end
+
+      def evaluate_instructions(instructions = [])
+        instruction_copy = Marshal.load(Marshal.dump(instructions))
+
+        while instruction_copy.any?
+          instruction = instruction_copy.shift
+          evaluate_instruction(instruction)
+          break if break_condition
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+      def evaluate_instruction(instruction)
+        case instruction[:kind]
+        when :step
+          Instructions::Executors::Step.new(operation).call(instruction)
+        when :operation
+          Instructions::Executors::Operation.new(operation).call(instruction)
+        when :operations
+          Instructions::Executors::Operations.new(operation).call(instruction)
+        when :success
+          Instructions::Executors::Success.new(operation).call(instruction)
+        when :validate
+          Instructions::Executors::Validate.new(operation).call(instruction)
+        when :transaction
+          Instructions::Executors::Transaction.new(operation).call(instruction)
+        when :benchmark
+          Instructions::Executors::Benchmark.new(operation).call(instruction)
+        else
+          raise(UnknownInstructionError, "Unknown instruction #{instruction[:kind]}")
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+      def result
+        operation.result
+      end
+
+      def config
+        operation.config
+      end
+
+      def context
+        operation.context
+      end
+
+      def reporter
+        config.reporter
+      end
+
+      def break_condition
+        operation.finished? || result.failure?
+      end
+
+      def add_instruction_output(instruction, output = {})
+        context["#{instruction[:method]}_output".to_sym] = output
+      end
+    end
+  end
+end

data/lib/opera/operation/instructions/executors/benchmark.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    module Instructions
+      module Executors
+        class Benchmark < Executor
+          def call(instruction)
+            benchmark = ::Benchmark.measure do
+              super
+            end
+
+            result.add_information(real: benchmark.real, total: benchmark.total)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/instructions/executors/operation.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    module Instructions
+      module Executors
+        class Operation < Executor
+          def call(instruction)
+            instruction[:kind] = :step
+            operation_result = super
+
+            if operation_result.success?
+              add_instruction_output(instruction, operation_result.output)
+              execution = result.executions.pop
+              result.executions << { execution => operation_result.executions }
+            else
+              result.add_errors(operation_result.errors)
+              result.add_exceptions(operation_result.exceptions)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/instructions/executors/operations.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    module Instructions
+      module Executors
+        class Operations < Executor
+          class WrongOperationsResultError < Opera::Error; end
+
+          # rubocop:disable Metrics/MethodLength
+          def call(instruction)
+            instruction[:kind] = :step
+            operations_results = super
+
+            return if result.exceptions.any?
+
+            case operations_results
+            when Array
+              operations_results.each do |operation_result|
+                raise_error unless operation_result.is_a?(Opera::Operation::Result)
+              end
+
+              failures = operations_results.select(&:failure?)
+
+              if failures.any?
+                add_failures(failures)
+              else
+                add_results(instruction, operations_results)
+              end
+            else
+              raise_error
+            end
+          end
+          # rubocop:enable Metrics/MethodLength
+
+          private
+
+          def add_failures(failures)
+            failures.each do |failure|
+              result.add_errors(failure.errors)
+              result.add_exceptions(failure.exceptions)
+            end
+          end
+
+          def add_results(instruction, results)
+            add_instruction_output(instruction, results.map(&:output))
+            execution = result.executions.pop
+            result.executions << { execution => results.map(&:executions) }
+          end
+
+          def raise_error
+            raise WrongOperationsResultError, 'Have to return array of Opera::Operation::Result'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/instructions/executors/step.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    module Instructions
+      module Executors
+        class Step < Executor
+          def call(instruction)
+            method = instruction[:method]
+
+            operation.result.add_execution(method)
+            operation.send(method)
+          rescue StandardError => exception
+            reporter&.error(exception)
+            operation.result.add_exception(method, exception.message, classname: operation.class.name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/instructions/executors/success.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    module Instructions
+      module Executors
+        class Success < Executor
+          def call(instruction)
+            instruction[:kind] = :step
+            super
+          end
+
+          def break_condition
+            operation.finished?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/instructions/executors/transaction.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    module Instructions
+      module Executors
+        class Transaction < Executor
+          class RollbackTransactionError < Opera::Error; end
+
+          def call(instruction)
+            transaction_class.send(transaction_method) do
+              super
+
+              return if !operation.finished? && result.success?
+
+              raise(RollbackTransactionError)
+            end
+          rescue RollbackTransactionError
+            nil
+          end
+
+          def transaction_class
+            config.transaction_class
+          end
+
+          def transaction_method
+            config.transaction_method
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/instructions/executors/validate.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    module Instructions
+      module Executors
+        class Validate < Executor
+          def break_condition
+            operation.finished?
+          end
+
+          private
+
+          def evaluate_instruction(instruction)
+            instruction[:kind] = :step
+            dry_result = super
+            add_instruction_output(instruction, dry_result.output)
+            result.add_errors(dry_result.errors) unless dry_result.success?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opera/operation/result.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Opera
+  module Operation
+    class Result
+      attr_reader :errors, # Acumulator of errors in validation + steps
+                  :exceptions, # Acumulator of exceptions in steps
+                  :information, # Temporal object to store related information
+                  :executions # Stacktrace or Pipe of the methods evaludated
+
+      attr_accessor :output # Final object returned if success?
+
+      def initialize(output: nil, errors: {})
+        @errors = errors
+        @exceptions = {}
+        @information = {}
+        @executions = []
+        @output = output
+      end
+
+      def failure?
+        errors.any? || exceptions.any?
+      end
+
+      def success?
+        !failure?
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def add_error(field, message)
+        @errors[field] ||= []
+        if message.is_a?(Hash)
+          if @errors[field].first&.is_a?(Hash)
+            @errors[field].first.merge!(message)
+          else
+            @errors[field].push(message)
+          end
+        else
+          @errors[field].concat(Array(message))
+        end
+        @errors[field].uniq!
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def add_errors(errors)
+        errors.each_pair do |key, value|
+          add_error(key, value)
+        end
+      end
+
+      def add_exception(method, message, classname: nil)
+        key = [classname, Array(method).first].compact.join('#')
+        @exceptions[key] ||= []
+        @exceptions[key].push(message)
+      end
+
+      def add_exceptions(exceptions)
+        exceptions.each_pair do |key, value|
+          add_exception(key, value)
+        end
+      end
+
+      def add_information(hash)
+        @information.merge!(hash)
+      end
+
+      def add_execution(step)
+        @executions << step
+      end
+    end
+  end
+end