mini_camel 0.5.8

data/lib/mini_camel.rb

@@ -0,0 +1,63 @@
+require "active_support"
+require "active_support/core_ext"
+require "active_model"
+require "virtus"
+require "hashie/mash"
+require 'multi_json'
+
+require "mini_camel/version"
+require "mini_camel/dto"
+require "mini_camel/strict_dto"
+require "mini_camel/context"
+require "mini_camel/exchange_error"
+require "mini_camel/exchange_result"
+require "mini_camel/exchange"
+require "mini_camel/environment"
+require "mini_camel/error"
+require "mini_camel/default_error_handler"
+require "mini_camel/route"
+require "mini_camel/route_builder"
+require "mini_camel/route_collection"
+require "mini_camel/route_definition"
+require "mini_camel/route_dispatcher"
+require "mini_camel/route_finalizer"
+require "mini_camel/route_generator"
+require "mini_camel/interactor"
+
+require 'mini_camel/processor/base'
+require 'mini_camel/processor/each'
+require 'mini_camel/processor/process'
+require 'mini_camel/processor/process_each'
+require 'mini_camel/processor/expose_field'
+require 'mini_camel/processor/expose_fields'
+require 'mini_camel/processor/extract_result'
+require 'mini_camel/processor/pipeline'
+require 'mini_camel/processor/to'
+require 'mini_camel/processor/transform'
+require 'mini_camel/processor/transform_each'
+require 'mini_camel/processor/mutate'
+require 'mini_camel/processor/mutate_each'
+require 'mini_camel/processor/produce'
+require 'mini_camel/processor/wrap_in_dto'
+require 'mini_camel/processor/validate'
+
+require 'mini_camel/processor_definition/base'
+require 'mini_camel/processor_definition/each'
+require 'mini_camel/processor_definition/process'
+require 'mini_camel/processor_definition/process_each'
+require 'mini_camel/processor_definition/expose_field'
+require 'mini_camel/processor_definition/expose_fields'
+require 'mini_camel/processor_definition/extract_result'
+require 'mini_camel/processor_definition/pipeline'
+require 'mini_camel/processor_definition/to'
+require 'mini_camel/processor_definition/transform'
+require 'mini_camel/processor_definition/transform_each'
+require 'mini_camel/processor_definition/mutate'
+require 'mini_camel/processor_definition/mutate_each'
+require 'mini_camel/processor_definition/produce'
+require 'mini_camel/processor_definition/wrap_in_dto'
+require 'mini_camel/processor_definition/validate'
+
+module MiniCamel
+
+end

data/lib/mini_camel/context.rb

@@ -0,0 +1,5 @@
+module MiniCamel
+  class Context < StrictDto
+
+  end
+end

data/lib/mini_camel/default_error_handler.rb

@@ -0,0 +1,37 @@
+module MiniCamel
+  class DefaultErrorHandler
+    include Virtus.value_object
+
+    values do
+      attribute :registered_errors, Array, default: []
+    end
+
+    def call(error, exchange)
+      raise error unless error.class.in? registered_errors
+
+      exchange.set_error(assemble_exchange_error(error))
+    end
+
+    private
+
+    def assemble_exchange_error(error)
+      ExchangeError.new(
+        error_class: error.class,
+        message: error.message,
+        details: Dto.new(details(error)),
+        backtrace: error.backtrace || []
+      )
+    end
+
+    def details(error)
+      if error.respond_to?(:internal_errors)
+        error.internal_errors
+      else
+        {}
+      end
+    end
+
+
+  end
+end
+

data/lib/mini_camel/dto.rb

@@ -0,0 +1,55 @@
+module MiniCamel
+
+  class Dto < OpenStruct
+
+    delegate :to_json, :as_json, :to_hash, :keys, :to_ary, to: :table
+
+    def self.empty
+      new
+    end
+
+    # ensures that every hash like object is a dto
+    def self.build(hash_object)
+      hash_object = MultiJson.load(MultiJson.dump(self.new(hash_object)))
+      deep_build(hash_object)
+    end
+
+    # @private
+    def self.deep_build(hash_object)
+      case hash_object
+      when Hash
+        hash_object.each do |k, v|
+          hash_object[k] = deep_build(v)
+        end
+        self.new(hash_object)
+      when Array
+        hash_object.map{|item| deep_build(item)}
+      else
+        hash_object
+      end
+    end
+
+    def initialize(hash = {})
+      super
+      @table = Hashie::Mash.new(hash)
+    end
+
+    def update(data = {})
+      modifiable.update(data)
+    end
+
+    def [](key)
+      fetch(key)
+    end
+
+    def fetch(key, default: nil)
+      if @table.has_key?(key)
+        @table.fetch(key, default)
+      else
+        return default unless default.nil?
+      end
+    end
+
+  end
+end
+

data/lib/mini_camel/environment.rb

@@ -0,0 +1,66 @@
+module MiniCamel
+  class Environment
+    include Virtus.value_object
+
+    values do
+      attribute :route_builders, Array, default: []
+      attribute :routes, Array, default: []
+      attribute :finalized, Boolean, default: false
+
+      attribute :finalizer_class, Class
+      attribute :error_handler, Object
+    end
+
+    def dispatch_route(route_name, options = {})
+      with_data = options[:with_data] || Dto.new
+      RouteDispatcher.new(route: route_name, with_data: with_data, env: self).dispatch
+    end
+
+    def register_route_builder(*builders)
+      @route_builders += builders
+      self
+    end
+
+    def register_error_handler(handler)
+      @error_handler = handler
+      self
+    end
+
+    def add_route(route)
+      routes << route
+    end
+
+    def finalize
+      finalizer_class.new(env: self).finalize
+      self
+    end
+
+    def finalized!
+      @finalized = true
+    end
+
+    # @internal
+    def call_route(route_name, exchange)
+      if route = routes_by_name[route_name]
+        route.call(exchange)
+      else
+        raise UnknownRouteError, route_name
+      end
+    end
+
+    def finalizer_class
+      @finalizer_class ||= RouteFinalizer
+    end
+
+    def error_handler
+      @error_handler ||= DefaultErrorHandler.new
+    end
+
+    private
+
+    def routes_by_name
+      @routes_by_name ||= routes.index_by(&:route_name)
+    end
+
+  end
+end

data/lib/mini_camel/error.rb

@@ -0,0 +1,57 @@
+module MiniCamel
+
+  class CamelError < StandardError; end
+
+  class EnvironmentNotFinalized < CamelError; end
+
+  class InvalidInteractor < CamelError; end
+
+  class InvalidRouteDefinition < CamelError
+
+    attr_reader :route_definition
+
+    def initialize(message, route_definition)
+      @route_definition = route_definition
+      super("#{message}: #{route_definition.class} #{route_definition.errors.full_messages}")
+    end
+
+  end
+
+  class InvalidProcessorDefinition < CamelError
+
+    attr_reader :processor_definition
+
+    def initialize(message, processor_definition)
+      @processor_definition = processor_definition
+      super("#{message}: #{processor_definition.class} #{processor_definition.errors.full_messages}")
+    end
+
+  end
+
+  class ExchangeFailure < CamelError
+    attr_reader :exchange_error
+
+    def initialize(message, exchange_error)
+      @exchange_error = exchange_error
+      super(message)
+    end
+  end
+
+  class ReRaisedError < CamelError
+    attr_reader :original_error_class
+
+    def initialize(message, original_error_class)
+      @original_error_class = original_error_class
+      super("[#{original_error_class}]: #{message}")
+    end
+  end
+
+  class UnknownRouteError < CamelError
+    attr_reader :route_name
+
+    def initialize(route_name)
+      super("Route not found: '#{route_name}'")
+    end
+  end
+
+end

data/lib/mini_camel/exchange.rb

@@ -0,0 +1,80 @@
+module MiniCamel
+  class Exchange
+    include Virtus.value_object
+
+    attribute :context, Context, reader: :private
+
+    values do
+      attribute :result, ExchangeResult, reader: :private
+      attribute :error,  ExchangeError, reader: :private
+    end
+
+    def success?
+      error.nil?
+    end
+
+    def failure?
+      !success?
+    end
+
+    def on(modifier)
+      raise ArgumentError, "Unkown modifier '#{modifier}'" unless modifier.in? [:success, :failure]
+
+      yield result if modifier == :success && success?
+      yield error  if modifier == :failure && failure?
+
+      self
+    end
+
+    def result_or_else(fallback)
+      if success?
+        result
+      else
+        ExchangeResult.new(fallback)
+      end
+    end
+
+    def result_or_else_nil
+      result if success?
+    end
+
+    def result_or_else_fail!
+      if success?
+        result
+      else
+        raise ExchangeFailure.new("Exchange failed!", error)
+      end
+    end
+
+    def result_or_else_try
+      if success?
+        result
+      else
+        yield error
+      end
+    end
+
+    def update_context(params = {})
+      context.update(params)
+    end
+
+    def context_fetch(field_name, default: nil)
+      context.fetch(field_name, default: default)
+    end
+
+    def set_result(exchange_result)
+      self.result = exchange_result
+    end
+
+    def set_error(exchange_error)
+      self.error = exchange_error
+    end
+
+    private
+
+    def context
+      @context ||= Context.empty
+    end
+
+  end
+end

data/lib/mini_camel/exchange_error.rb

@@ -0,0 +1,36 @@
+module MiniCamel
+  class ExchangeError
+    include Virtus.value_object
+
+    values do
+      attribute :error_class, Class, reader: :private
+      attribute :message, String, reader: :private
+      attribute :details, Dto, reader: :private
+    end
+
+    attribute :backtrace, Array, default: []
+
+    def on(check_error_class)
+      yield message, details if check_error_class == error_class
+
+      self
+    end
+
+    # This is just a helper method.
+    # Do not use it in production code!
+    def raise!
+      raise ReRaisedError.new(message, error_class)
+    end
+
+    def as_json(options = {})
+      {error_class: error_class.name, message: message, details: details}.as_json(options)
+    end
+
+    private
+
+    def details
+      @details ||= Dto.empty
+    end
+
+  end
+end

data/lib/mini_camel/exchange_result.rb

@@ -0,0 +1,5 @@
+module MiniCamel
+  class ExchangeResult < StrictDto
+
+  end
+end

data/lib/mini_camel/interactor.rb

@@ -0,0 +1,13 @@
+module MiniCamel
+  class Interactor
+    include Virtus.value_object
+    include ActiveModel::Validations
+
+    def call
+      raise InvalidInteractor, "Invalid interactor '#{self.class.name}': #{self.errors.full_messages}." if invalid?
+
+      run
+    end
+
+  end
+end

data/lib/mini_camel/processor/base.rb

@@ -0,0 +1,14 @@
+module MiniCamel
+  module Processor
+    class Base
+      include Virtus.value_object
+
+      attribute :env, Environment
+
+      def call(exchange)
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/mini_camel/processor/each.rb

@@ -0,0 +1,28 @@
+module MiniCamel
+  module Processor
+    class Each < Base
+
+      values do
+        attribute :field, Symbol
+        attribute :in_field, Symbol
+        attribute :additional_fields, [Symbol]
+        attribute :with_class, Class
+      end
+
+      private
+
+      def process(entry, additional_data)
+        with_class.new(additional_data.merge(field => entry)).call
+      end
+
+      def fetch_additional_data(exchange)
+        additional_fields.map{|f| {f => exchange.context_fetch(f)}}.reduce(&:merge) || {}
+      end
+
+      def fetch_collection(exchange)
+        exchange.context_fetch(in_field)
+      end
+
+    end
+  end
+end