substation 0.0.9 → 0.0.10.beta2

data/lib/substation/dispatcher.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Substation
 
   # Encapsulates all registered actions and their observers
@@ -251,7 +249,7 @@ module Substation
     #
     # @api public
     def call(name, input)
-      fetch(name).call(Request.new(name, env, input))
+      fetch(name).call(Request.new(env, input))
     end
 
     # The names of all registered actions

data/lib/substation/environment.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Substation
 
   # The environment holding all registered {Chain} processors
@@ -17,9 +15,7 @@ module Substation
     #
     # @api private
     def self.build(&block)
-      registry  = DSL.registry(&block)
-      chain_dsl = Chain::DSL::Builder.call(registry)
-      new(registry, chain_dsl)
+      new(DSL.registry(&block))
     end
 
     # Initialize a new instance
@@ -30,8 +26,9 @@ module Substation
     # @return [undefined]
     #
     # @api private
-    def initialize(registry, chain_dsl)
-      @registry, @chain_dsl = registry, chain_dsl
+    def initialize(registry)
+      @registry  = registry
+      @chain_dsl = Chain::DSL::Builder.call(@registry)
     end
 
     # Build a new {Chain} instance
@@ -45,8 +42,8 @@ module Substation
     # @return [Chain]
     #
     # @api private
-    def chain(other = Chain::EMPTY, failure_chain = Chain::EMPTY, &block)
-      @chain_dsl.build(other, failure_chain, &block)
+    def chain(other = Chain::EMPTY, &block)
+      Chain.new(processors(other, &block))
     end
 
     protected
@@ -58,5 +55,22 @@ module Substation
     # @api private
     attr_reader :registry
 
+    private
+
+    # The processors collected via the chain dsl instance
+    #
+    # @param [Chain] other
+    #   another chain to build upon
+    #
+    # @param [Proc] block
+    #   the block to pass to {Chain::DSL#processors}
+    #
+    # @return [Hash<Symbol, #call>]
+    #
+    # @api private
+    def processors(other, &block)
+      @chain_dsl.processors(self, other, &block)
+    end
+
   end # class Environment
 end # module Substation

data/lib/substation/environment/dsl.rb

@@ -1,9 +1,7 @@
-# encoding: utf-8
-
 module Substation
   class Environment
 
-    # The DSL class used to register processors
+    # The DSL class used to define register processors
     class DSL
 
       # The registry of processors
@@ -13,6 +11,7 @@ module Substation
       # @api private
       attr_reader :registry
 
+
       # The registry of processors
       #
       # @param [Proc] block
@@ -50,7 +49,7 @@ module Substation
       #
       # @api private
       def register(name, processor)
-        @registry[name.to_sym] = processor
+        @registry[name] = processor
         self
       end
 

data/lib/substation/observer.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module Substation
 
   # Abstract observer base class
@@ -22,7 +20,7 @@ module Substation
 
     # Coerce +input+ to an instance of {Observer}
     #
-    # @param [NilClass, String, Array<String>] input
+    # @param [nil, String, Array<String>] input
     #   0..n observer class names
     #
     # @return [Observer::NULL, Object, Observer::Chain]
@@ -31,7 +29,7 @@ module Substation
     # @api private
     def self.coerce(input)
       case input
-      when NilClass
+      when nil
         NULL
       when Array
         Chain.new(input.map { |item| coerce(item) })

data/lib/substation/processor.rb

@@ -1,122 +1,23 @@
-# encoding: utf-8
-
 module Substation
 
   # Namespace for chain processors
   module Processor
 
-    # Test wether chain processing should continue
-    #
-    # @param [Response] response
-    #   the response returned from invoking the processor
-    #
-    # @return [true] for a successful response
-    # @return [false] otherwise
-    #
-    # @api private
-    def success?(response)
-      response.success?
-    end
-
-    # The response passed on to the next processor in a {Chain}
-    #
-    # @param [Response] response
-    #   the response returned from invoking the processor
-    #
-    # @return [Response]
-    #   the response passed on to the next processor in a {Chain}
-    #
-    # @api private
-    def result(response)
-      response
-    end
-
-    module Fallible
-      include Concord.new(:name, :handler, :failure_chain)
-
-      # This processor's name
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      attr_reader :name
+    include AbstractType
+    include Adamantium::Flat
 
-      # Return a new processor with +chain+ as failure_chain
-      #
-      # @param [#call] chain
-      #   the failure chain to use for the new processor
-      #
-      # @return [#call]
-      #
-      # @api private
-      def with_failure_chain(chain)
-        self.class.new(name, handler, chain)
-      end
-    end
+    abstract_method :call
+    abstract_method :result
 
     module Incoming
       include Processor
-      include Fallible
-
-      # The request passed on to the next processor in a {Chain}
-      #
-      # @param [Response] _response
-      #   the response returned from invoking this processor
-      #
-      # @return [Request]
-      #   the request passed on to the next processor in a {Chain}
-      #
-      # @api private
-      def result(_response)
-        super.to_request
-      end
-    end
-
-    module Pivot
-      include Processor
-      include Fallible
+      include Chain::Incoming
     end
 
     module Outgoing
-      include Concord.new(:name, :handler)
       include Processor
+      include Chain::Outgoing
+    end
 
-      # This processor's name
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      attr_reader :name
-
-      # Test wether chain processing should continue
-      #
-      # @param [Response] _response
-      #   the response returned from invoking the processor
-      #
-      # @return [false]
-      #
-      # @api private
-      def success?(_response)
-        true
-      end
-
-      private
-
-      # Build a new {Response} based on +response+ and +output+
-      #
-      # @param [Response] response
-      #   the original response
-      #
-      # @param [Object] output
-      #   the data to be wrapped within the new {Response}
-      #
-      # @return [Response]
-      #
-      # @api private
-      def respond_with(response, output)
-        response.class.new(response.request, output)
-      end
-
-    end # module Outgoing
   end # module Processor
 end # module Substation

data/lib/substation/processor/evaluator.rb

@@ -1,61 +1,30 @@
-# encoding: utf-8
-
 module Substation
   module Processor
 
-    # Abstract processor to evaluate a request coming into a chain
+    # A processor to evaluate a chain's request input data
     class Evaluator
 
-      # Processor to evaluate request input data
-      class Data < self
-        include Incoming
-
-        private
-
-        # Invoke the handler
-        #
-        # @param [Request] request
-        #   the request to evaluate
-        #
-        # @return [Response]
-        #
-        # @api private
-        def invoke(request)
-          handler.call(request.input)
-        end
-
-      end
-
-      # Processor to evaluate an incoming request
-      class Request < self
-        include Incoming
-      end
-
-      # Processor to evaluate a pivot chain handler
-      class Pivot < self
-        include Processor::Pivot
-
-        private
+      include Incoming
 
-        # Return a successful response
-        #
-        # @param [Request] _request
-        #   the evaluated request
-        #
-        # @param [#output] result
-        #   the evaluation result
-        #
-        # @return [Response::Success]
-        #
-        # @api private
-        def on_success(_request, response)
-          response
-        end
+      # Initialize a new instance
+      #
+      # @param [Environment] env
+      #   the substation environment used to build chains
+      #
+      # @param [#call] handler
+      #   the handler to perform evaluation
+      #
+      # @param [Proc] block
+      #   a block to construct a failure chain
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(env, handler, &block)
+        @env, @handler = env, handler
+        @failure_chain = block ? @env.chain(&block) : Undefined
       end
 
-      include Adamantium::Flat
-      include AbstractType
-
       # Evaluate a chain's request input data
       #
       # @param [Request] request
@@ -65,56 +34,46 @@ module Substation
       #
       # @api private
       def call(request)
-        result = invoke(request)
+        result = handler.call(request.input)
+        output = result.output
         if result.success?
-          on_success(request, result)
+          request.success(output)
         else
-          on_failure(request, result)
+          response = request.error(output)
+          if fail_safe?
+            failure_chain.call(response)
+          else
+            response
+          end
         end
       end
 
-      private
+      protected
 
-      # Invoke the handler
-      #
-      # @param [Request] request
-      #   the request to evaluate
+      # The handler used to perform evaluation
       #
-      # @return [Response]
+      # @return [#call]
       #
       # @api private
-      def invoke(request)
-        handler.call(request)
-      end
+      attr_reader :handler
 
-      # Return a successful response
-      #
-      # @param [Request] request
-      #   the evaluated request
-      #
-      # @param [#output] result
-      #   the evaluation result
+      private
+
+      # The chain to invoke if evaluation returned an error
       #
-      # @return [Response::Success]
+      # @return [Chain]
       #
       # @api private
-      def on_success(request, result)
-        request.success(result.output)
-      end
+      attr_reader :failure_chain
 
-      # Return a failure response by invoking a failure chain
-      #
-      # @param [Request] request
-      #   the evaluated request
-      #
-      # @param [#output] result
-      #   the evaluation result
+      # Test wether this evaluator has a failure chain
       #
-      # @return [Response::Failure]
+      # @return [TrueClass] if a failure chain is registered
+      # @return [FalseClass] otherwise
       #
       # @api private
-      def on_failure(request, result)
-        failure_chain.call(request.error(result.output))
+      def fail_safe?
+        !@failure_chain.equal?(Undefined)
       end
     end # class Evaluator
   end # module Processor

data/lib/substation/processor/pivot.rb

@@ -0,0 +1,25 @@
+module Substation
+  module Processor
+
+    # A processor to invoke a chain's pivot handler
+    class Pivot
+
+      include Processor
+      include Chain::Pivot
+      include Concord.new(:env, :handler)
+
+      # Invoke a chain's pivot handler
+      #
+      # @param [Request] request
+      #   the request to process
+      #
+      # @return [Response]
+      #
+      # @api private
+      def call(request)
+        handler.call(request)
+      end
+
+    end # class Caller
+  end # module Processor
+end # module Substation

data/lib/substation/processor/wrapper.rb

@@ -1,13 +1,11 @@
-# encoding: utf-8
-
 module Substation
   module Processor
 
     # A processor that wraps output data in a new handler instance
     class Wrapper
 
-      include Processor::Outgoing
-      include Adamantium::Flat
+      include Outgoing
+      include Concord.new(:env, :handler)
 
       # Wrap response data in an instance of {#handler}
       #