mini_camel 0.5.8

data/lib/mini_camel/processor_definition/pipeline.rb

@@ -0,0 +1,17 @@
+module MiniCamel
+  module ProcessorDefinition
+    class Pipeline < Base
+
+      values do
+        attribute :routes, [Symbol]
+        validates :routes, presence: true
+      end
+
+      def generate_processor(env)
+        Processor::Pipeline.new(env: env, routes: routes)
+      end
+
+    end
+  end
+end
+

data/lib/mini_camel/processor_definition/process.rb

@@ -0,0 +1,19 @@
+module MiniCamel
+  module ProcessorDefinition
+    class Process < Base
+
+      values do
+        attribute :fields, [Symbol]
+        validates :fields, presence: true
+
+        attribute :with_class, Class
+        validates :with_class, presence: true
+      end
+
+      def generate_processor(env)
+        Processor::Process.new(env: env, fields: fields, with_class: with_class)
+      end
+
+    end
+  end
+end

data/lib/mini_camel/processor_definition/process_each.rb

@@ -0,0 +1,14 @@
+module MiniCamel
+  module ProcessorDefinition
+    class ProcessEach < Each
+
+      def generate_processor(env)
+        Processor::ProcessEach.new(
+          env: env, field: field, in_field: in_field, with_class: with_class,
+          additional_fields: additional_fields
+        )
+      end
+
+    end
+  end
+end

data/lib/mini_camel/processor_definition/produce.rb

@@ -0,0 +1,20 @@
+module MiniCamel
+  module ProcessorDefinition
+    class Produce < Base
+
+      values do
+        attribute :field, Symbol
+        validates :field, presence: true
+
+        attribute :with_class, Class
+        validates :with_class, presence: true
+      end
+
+      def generate_processor(env)
+        Processor::Produce.new(env: env, field: field, with_class: with_class)
+      end
+
+    end
+  end
+end
+

data/lib/mini_camel/processor_definition/to.rb

@@ -0,0 +1,17 @@
+module MiniCamel
+  module ProcessorDefinition
+    class To < Base
+
+      values do
+        attribute :route, Symbol
+        validates :route, presence: true
+      end
+
+      def generate_processor(env)
+        Processor::To.new(env: env, route: route)
+      end
+
+    end
+  end
+end
+

data/lib/mini_camel/processor_definition/transform.rb

@@ -0,0 +1,17 @@
+module MiniCamel
+  module ProcessorDefinition
+    class Transform < Process
+
+      values do
+        attribute :to, Symbol
+        validates :to, presence: true
+      end
+
+      def generate_processor(env)
+        Processor::Transform.new(env: env, fields: fields, to: to, with_class: with_class)
+      end
+
+    end
+  end
+end
+

data/lib/mini_camel/processor_definition/transform_each.rb

@@ -0,0 +1,20 @@
+module MiniCamel
+  module ProcessorDefinition
+    class TransformEach < ProcessEach
+
+      values do
+        attribute :to, Symbol
+        validates :to, presence: true
+      end
+
+      def generate_processor(env)
+        Processor::TransformEach.new(
+          env: env, field: field, in_field: in_field, with_class: with_class,
+          additional_fields: additional_fields, to: to
+        )
+      end
+
+    end
+  end
+end
+

data/lib/mini_camel/processor_definition/validate.rb

@@ -0,0 +1,26 @@
+module MiniCamel
+  module ProcessorDefinition
+    class Validate < Base
+
+      values do
+        attribute :field, Symbol
+        validates :field, presence: true
+
+        attribute :message, String
+        validates :message, presence: true
+
+        attribute :raise_error, Class
+        validates :raise_error, presence: true
+      end
+
+      def generate_processor(env)
+        Processor::Validate.new(env: env, field: field, message: message, raise_error: raise_error)
+      end
+
+      def message
+        @message ||= "'#{field}' is invalid."
+      end
+
+    end
+  end
+end

data/lib/mini_camel/processor_definition/wrap_in_dto.rb

@@ -0,0 +1,21 @@
+module MiniCamel
+  module ProcessorDefinition
+    class WrapInDto < Base
+
+      values do
+        attribute :field, Symbol
+        validates :field, presence: true
+
+        attribute :as, Symbol
+        validates :as, presence: true
+      end
+
+      def generate_processor(env)
+        Processor::WrapInDto.new(env: env, field: field, as: as)
+      end
+
+    end
+  end
+end
+
+

data/lib/mini_camel/route.rb

@@ -0,0 +1,21 @@
+module MiniCamel
+  class Route
+    include Virtus.value_object
+
+    attribute :env, Environment
+
+    values do
+      attribute :route_name, Symbol
+      attribute :processors, Array, default: []
+    end
+
+    def call(exchange)
+      raise EnvironmentNotFinalized, "Please finalize the environment." unless env.finalized?
+
+      processors.each do |processor|
+        processor.call(exchange)
+      end
+    end
+
+  end
+end

data/lib/mini_camel/route_builder.rb

@@ -0,0 +1,24 @@
+module MiniCamel
+  class RouteBuilder
+    include Virtus.value_object
+
+    values do
+      attribute :route_collection
+    end
+
+    def configure
+      raise NotImplementedError
+    end
+
+    def route_collection
+      @route_collection ||= RouteCollection.new
+    end
+
+    private
+
+    def from(route_name)
+      route_collection.from(route_name)
+    end
+
+  end
+end

data/lib/mini_camel/route_collection.rb

@@ -0,0 +1,16 @@
+module MiniCamel
+  class RouteCollection
+    include Virtus.value_object
+
+    values do
+      attribute :routes, Array, default: []
+    end
+
+    def from(route_name)
+      route_definition = RouteDefinition.new(route_name: route_name)
+      routes << route_definition
+      route_definition
+    end
+
+  end
+end

data/lib/mini_camel/route_definition.rb

@@ -0,0 +1,146 @@
+module MiniCamel
+  class RouteDefinition
+    include Virtus.value_object
+    include ActiveModel::Validations
+
+    values do
+      attribute :route_name, Symbol
+      validates :route_name, presence: true
+
+      attribute :description, String
+      validates :description, presence: true
+
+      attribute :processor_definitions, Array, default: []
+      validates :processor_definitions, presence: true
+    end
+
+    def from(route_name)
+      self.route_name = route_name
+    end
+
+    def desc(description)
+      self.description = description
+      self
+    end
+
+    def to(route)
+      definition = ProcessorDefinition::To.new(route: route)
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def pipeline(*routes)
+      definition = ProcessorDefinition::Pipeline.new(routes: routes)
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def process(*fields, **options)
+      definition = ProcessorDefinition::Process.new(options.merge(fields: fields))
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def process_each(field, **options)
+      options[:in_field] = options.delete(:in)
+      definition = ProcessorDefinition::ProcessEach.new(options.merge(field: field))
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def transform(*fields, **options)
+      definition = ProcessorDefinition::Transform.new(options.merge(fields: fields))
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def transform_each(field, **options)
+      options[:in_field] = options.delete(:in)
+      definition = ProcessorDefinition::TransformEach.new(options.merge(field: field))
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def mutate(field, **options)
+      definition = ProcessorDefinition::Mutate.new(options.merge(field: field))
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def mutate_each(field, **options)
+      options[:in_field] = options.delete(:in)
+      definition = ProcessorDefinition::MutateEach.new(options.merge(field: field))
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def produce(field, **options)
+      definition = ProcessorDefinition::Produce.new(options.merge(field: field))
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def expose_field(field, **options)
+      definition = ProcessorDefinition::ExposeField.new(options.merge(field: field))
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def expose_fields(*fields, **options)
+      definition = ProcessorDefinition::ExposeFields.new(options.merge(fields: fields))
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def wrap_in_dto(field, **options)
+      definition = ProcessorDefinition::WrapInDto.new(options.merge(field: field))
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def extract_result(**options)
+      definition = ProcessorDefinition::ExtractResult.new(options)
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def validate(field, **options)
+      definition = ProcessorDefinition::Validate.new(options.merge(field: field))
+
+      add_processor_definition(definition)
+
+      self
+    end
+
+    def add_processor_definition(processor_definition)
+      processor_definitions << processor_definition
+    end
+
+  end
+end

data/lib/mini_camel/route_dispatcher.rb

@@ -0,0 +1,37 @@
+module MiniCamel
+  class RouteDispatcher
+    include Virtus.value_object
+
+    attribute :env, Environment
+
+    values do
+      attribute :route, Symbol
+      attribute :with_data, Object
+    end
+
+    def dispatch
+      raise EnvironmentNotFinalized, "Please finalize the environment." unless env.finalized?
+
+      exchange = Exchange.new(context: Context.new(with_data))
+
+      env.call_route(route, exchange)
+
+      exchange
+    rescue Exception => error
+      rescue_error(error, exchange)
+
+      exchange
+    end
+
+    private
+
+    def rescue_error(error, exchange)
+      error_handler.call(error, exchange)
+    end
+
+    def error_handler
+      env.error_handler
+    end
+
+  end
+end

data/lib/mini_camel/route_finalizer.rb

@@ -0,0 +1,38 @@
+module MiniCamel
+  class RouteFinalizer
+    include Virtus.value_object
+
+    attribute :env, Environment
+
+    values do
+      attribute :route_generator_class, Class
+    end
+
+    def finalize
+      env.route_builders.each(&:configure)
+
+      route_collections = env.route_builders.map(&:route_collection)
+
+      route_collections.each do |route_collection|
+        route_definitions = route_collection.routes
+
+        route_definitions.each do |route_definition|
+          env.add_route(generate_route(route_definition))
+        end
+      end
+
+      env.finalized!
+    end
+
+    def route_generator_class
+      @route_generator_class ||= RouteGenerator
+    end
+
+    private
+
+    def generate_route(route_definition)
+      route_generator_class.new(env: env, route_definition: route_definition).generate_route
+    end
+
+  end
+end