substation 0.0.7 → 0.0.8

data/.ruby-gemset

@@ -0,0 +1 @@
+substation

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3

data/.travis.yml

@@ -4,13 +4,8 @@ bundler_args: --without yard guard benchmarks
 script: "bundle exec rake ci"
 rvm:
   - 1.9.3
-  - 1.9.2
-  - 1.8.7
-  - ree
-  - ruby-head
   - 2.0.0
+  - ruby-head
   - jruby-19mode
-  - jruby-18mode
   - jruby-head
   - rbx-19mode
-  - rbx-18mode

data/Changelog.md

@@ -1,3 +1,43 @@
+# v0.0.9 (not yet released)
+
+*
+
+[Compare v0.0.8..master](https://github.com/snusnu/substation/compare/v0.0.8...master)
+
+# v0.0.8 2013-06-19
+
+* [feature] Add the following chain processors
+  * `Substation::Processor::Evaluator`
+  * `Substation::Processor::Pivot`
+  * `Substation::Processor::Wrapper`
+
+* [feature] Add `Substation::Environment` for registering processors by name
+
+        env = Substation::Environment.build do
+          register :authenticate, My::Authenticator # implemented by you
+          register :authorize,    My::Authorizer    # implemented by you
+          register :evaluate,     Substation::Processor::Evaluator
+          register :call,         Substation::Processor::Pivot
+          register :wrap,         Substation::Processor::Wrapper
+        end
+
+* [feature] Add a DSL for constructing `Substation::Chain` instances
+
+        AUTHENTICATED = env.chain { authenticate }
+        AUTHORIZED    = env.chain(AUTHENTICATED) { authorize }
+
+        CREATE_PERSON = env.chain(AUTHORIZED) do
+          evaluate Sanitizers::NEW_PERSON
+          evaluate Validators::NEW_PERSON
+
+          call Actions::CreatePerson
+
+          wrap Presenters::Person
+          wrap Views::Person
+        end
+
+[Compare v0.0.7..v0.0.8](https://github.com/snusnu/substation/compare/v0.0.7...v0.0.8)
+
 # v0.0.7 2013-06-14
 
 * [feature] Make `Substation::Response#request` part of the public API (snusnu)
@@ -17,15 +57,14 @@
 
 * [feature] Shorter action config when no observers are needed (snusnu)
 
-```ruby
-dispatcher = Substation::Dispatcher.coerce({
-  :some_use_case => App::SomeUseCase
-}, env)
+        dispatcher = Substation::Dispatcher.coerce({
+          :some_use_case => App::SomeUseCase
+        }, env)
+
+        dispatcher = Substation::Dispatcher.coerce({
+          :some_use_case => Proc.new { |request| request.success(:data) }
+        }, env)
 
-dispatcher = Substation::Dispatcher.coerce({
-  :some_use_case => Proc.new { |request| request.success(:data) }
-}, env)
-```
 [Compare v0.0.4..v0.0.5](https://github.com/snusnu/substation/compare/v0.0.4...v0.0.5)
 
 # v0.0.4 2013-05-15

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 6
-total_score: 69
+total_score: 82

data/config/flog.yml

@@ -1,2 +1,2 @@
 ---
-threshold: 10.9
+threshold: 13.3

data/config/reek.yml

@@ -26,6 +26,8 @@ FeatureEnvy:
   exclude:
   - Substation::Chain#call # loops over instance state
   - Substation::Chain::Incoming#result # defined in a module
+  - Substation::Chain::Outgoing#respond_with #defined in a module
+  - Substation::Processor::Evaluator#call # method object
 IrresponsibleModule:
   enabled: true
   exclude: []
@@ -33,6 +35,7 @@ LongParameterList:
   enabled: true
   exclude:
   - Substation::Dispatcher#call
+  - Substation::Chain::DSL::Builder#define_dsl_method
   max_params: 2
 LongYieldList:
   enabled: true
@@ -40,7 +43,8 @@ LongYieldList:
   max_params: 2
 NestedIterators:
   enabled: true
-  exclude: []
+  exclude:
+  - Substation::Chain::DSL::Builder#define_dsl_method
   max_allowed_nesting: 1
   ignore_iterators: []
 NilCheck:
@@ -67,6 +71,7 @@ TooManyStatements:
   - Substation::Dispatcher::Action#self.coerce
   - Substation::Chain#call
   - Substation::Utils#self.coerce_callable
+  - Substation::Processor::Evaluator#call
   max_statements: 3
 UncommunicativeMethodName:
   enabled: true
@@ -106,4 +111,5 @@ UtilityFunction:
   enabled: true
   exclude:
   - Substation::Chain::Incoming#result # defined in a module
+  - Substation::Chain::Outgoing#respond_with # defined in a module
   max_helper_calls: 0

data/lib/substation.rb

@@ -33,9 +33,16 @@ require 'concord'
 module Substation
 end
 
+require 'substation/utils'
 require 'substation/request'
 require 'substation/response'
 require 'substation/observer'
 require 'substation/chain'
+require 'substation/chain/dsl'
+require 'substation/processor'
+require 'substation/processor/evaluator'
+require 'substation/processor/pivot'
+require 'substation/processor/wrapper'
+require 'substation/environment'
+require 'substation/environment/dsl'
 require 'substation/dispatcher'
-require 'substation/support/utils'

data/lib/substation/chain.rb

@@ -72,8 +72,6 @@ module Substation
 
       # The request passed on to the next handler in a {Chain}
       #
-      # @example
-      #
       # @param [Response] response
       #   the response returned from the previous handler in a {Chain}
       #
@@ -101,15 +99,36 @@ module Substation
       def result(response)
         response
       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
 
     # Supports chaining the {Pivot} handler
     Pivot = Outgoing
 
+    include Enumerable
     include Concord.new(:handlers)
     include Adamantium::Flat
     include Pivot # allow nesting of chains
 
+    # Empty chain
+    EMPTY = Class.new(self).new([])
+
     # Call the chain
     #
     # Invokes all handlers and returns either the first
@@ -160,5 +179,23 @@ module Substation
       }
     end
 
+    # Iterate over all processors
+    #
+    # @param [Proc] block
+    #   a block passed to {#handlers} each method
+    #
+    # @yield [handler]
+    #
+    # @yieldparam [#call] handler
+    #   each handler in the chain
+    #
+    # @return [self]
+    #
+    # @api private
+    def each(&block)
+      return to_enum unless block
+      handlers.each(&block)
+      self
+    end
   end # class Chain
 end # module Substation

data/lib/substation/chain/dsl.rb

@@ -0,0 +1,165 @@
+module Substation
+
+  class Chain
+
+    # Build a new chain instance
+    #
+    # @param [DSL] dsl
+    #   the dsl klass to use for defining the chain
+    #
+    # @param [Chain] other
+    #   another chain to build on top of
+    #
+    # @param [Proc] block
+    #   a block to instance_eval in the context of +dsl+
+    #
+    # @return [Chain]
+    #
+    # @api private
+    def self.build(dsl, other, &block)
+      new(dsl.processors(other, &block))
+    end
+
+    # The DSL class used to define chains in an {Environment}
+    class DSL
+
+      # The class that builds a DSL class suitable for an {Environment}
+      class Builder
+        include Adamantium::Flat
+
+        # Build a new {DSL} subclass targeted for an {Environment}
+        #
+        # @param [Hash<Symbol, #call>] registry
+        #   the registry of processors used in an {Environment}
+        #
+        # @return [Class<DSL>]
+        #
+        # @api private
+        def self.call(registry)
+          new(registry).dsl
+        end
+
+        # The built DSL subclass
+        #
+        # @return [Class<DSL>]
+        #
+        # @api private
+        attr_reader :dsl
+
+        # Initialize a new instance
+        #
+        # @param [Hash<Symbol, #call>] registry
+        #   the registry of processors used in an {Environment}
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(registry)
+          @registry = registry
+          @dsl      = compile_dsl
+        end
+
+        private
+
+        # Compile a new DSL class
+        #
+        # @return [Class<DSL>]
+        #
+        # @api private
+        def compile_dsl
+          @registry.each_with_object(Class.new(DSL)) { |(name, processor), dsl|
+            define_dsl_method(name, processor, dsl)
+          }
+        end
+
+
+        # Define a new instance method on the +dsl+ class
+        #
+        # @param [Symbol] name
+        #   the name of the method
+        #
+        # @param [#call] processor
+        #   the processor to use within the chain
+        #
+        # @param [Class<DSL>] dsl
+        #   the {DSL} subclass to define the method on
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def define_dsl_method(name, processor, dsl)
+          dsl.class_eval do
+            define_method(name) { |*args| use(processor.new(*args)) }
+          end
+        end
+
+      end # class Builder
+
+      # The processors to be used within a {Chain}
+      #
+      # @return [Array<#call>]
+      #
+      # @api private
+      attr_reader :processors
+
+      # The processors to be used within a {Chain}
+      #
+      # @param [Chain] chain
+      #   the chain to build on top of
+      #
+      # @param [Proc] block
+      #   a block to be instance_eval'ed
+      #
+      # @return [Array<#call>]
+      #
+      # @api private
+      def self.processors(chain, &block)
+        new(chain, &block).processors
+      end
+
+      # Initialize a new instance
+      #
+      # @param [#each<#call>] processors
+      #   an enumerable of processors to build on top of
+      #
+      # @param [Proc] block
+      #   a block to be instance_eval'ed
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(processors, &block)
+        @processors = []
+        chain(processors)
+        instance_eval(&block) if block
+      end
+
+      # Use the given +processor+ within a chain
+      #
+      # @param [#call] processor
+      #   a processor to use within a chain
+      #
+      # @return [self]
+      #
+      # @api private
+      def use(processor)
+        @processors << processor
+        self
+      end
+
+      # Nest the given chain within another one
+      #
+      # @param [#each<#call>] other
+      #   another chain to be nested within a chain
+      #
+      # @return [self]
+      #
+      # @api private
+      def chain(other)
+        other.each { |handler| use(handler) }
+        self
+      end
+
+    end # class DSL
+  end # class Chain
+end # module Substation

data/lib/substation/environment.rb

@@ -0,0 +1,59 @@
+module Substation
+
+  # The environment holding all registered {Chain} processors
+  class Environment
+
+    include Equalizer.new(:registry)
+    include Adamantium::Flat
+
+    # Build a new {Environment} instance
+    #
+    # @param [Proc] block
+    #   a block to be instance_eval'ed with {DSL}
+    #
+    # @return [Environment]
+    #
+    # @api private
+    def self.build(&block)
+      new(DSL.registry(&block))
+    end
+
+    # Initialize a new instance
+    #
+    # @param [Hash<Symbol, #call>] registry
+    #   the registry of processors
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(registry)
+      @registry  = registry
+      @chain_dsl = Chain::DSL::Builder.call(@registry)
+    end
+
+    # Build a new {Chain} instance
+    #
+    # @param [Chain] other
+    #   the optional chain to build on top of
+    #
+    # @param [Proc] block
+    #   a block to be instance_eval'ed in {Chain::DSL}
+    #
+    # @return [Chain]
+    #
+    # @api private
+    def chain(other = Chain::EMPTY, &block)
+      Chain.build(@chain_dsl, other, &block)
+    end
+
+    protected
+
+    # The registry used by this {Environment}
+    #
+    # @return [Hash<Symbol, #call>]
+    #
+    # @api private
+    attr_reader :registry
+
+  end # class Environment
+end # module Substation

data/lib/substation/environment/dsl.rb

@@ -0,0 +1,58 @@
+module Substation
+  class Environment
+
+    # The DSL class used to define register processors
+    class DSL
+
+      # The registry of processors
+      #
+      # @return [Hash<Symbol, #call>]
+      #
+      # @api private
+      attr_reader :registry
+
+
+      # The registry of processors
+      #
+      # @param [Proc] block
+      #   a block to be instance_eval'ed
+      #
+      # @return [Hash<Symbol, #call>]
+      #
+      # @api private
+      def self.registry(&block)
+        new(&block).registry
+      end
+
+      # Initialize a new instance
+      #
+      # @param [Proc] block
+      #   a block to be instance_eval'ed
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(&block)
+        @registry = {}
+        instance_eval(&block) if block
+      end
+
+      # Register a new +processor+ using the given +name+
+      #
+      # @param [#to_sym] name
+      #   the name to register the +processor+ for
+      #
+      # @param [#call] processor
+      #   the processor to register for +name+
+      #
+      # @return [self]
+      #
+      # @api private
+      def register(name, processor)
+        @registry[name] = processor
+        self
+      end
+
+    end # class DSL
+  end # class Environment
+end # module Substation

data/lib/substation/processor.rb

@@ -0,0 +1,23 @@
+module Substation
+
+  # Namespace for chain processors
+  module Processor
+
+    include AbstractType
+    include Adamantium::Flat
+
+    abstract_method :call
+    abstract_method :result
+
+    module Incoming
+      include Processor
+      include Chain::Incoming
+    end
+
+    module Outgoing
+      include Processor
+      include Chain::Outgoing
+    end
+
+  end # module Processor
+end # module Substation

data/lib/substation/processor/evaluator.rb

@@ -0,0 +1,30 @@
+module Substation
+  module Processor
+
+    # A processor to evaluate a chain's request input data
+    class Evaluator
+
+      include Incoming
+      include Concord.new(:handler)
+
+      # Evaluate a chain's request input data
+      #
+      # @param [Request] request
+      #   the request to process
+      #
+      # @return [Response]
+      #
+      # @api private
+      def call(request)
+        result = handler.call(request.input)
+        output = result.output
+        if result.success?
+          request.success(output)
+        else
+          request.error(output)
+        end
+      end
+
+    end # class Evaluator
+  end # module Processor
+end # module Substation

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(: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

@@ -0,0 +1,24 @@
+module Substation
+  module Processor
+
+    # A processor that wraps output data in a new handler instance
+    class Wrapper
+
+      include Outgoing
+      include Concord.new(:handler)
+
+      # Wrap response data in an instance of {#handler}
+      #
+      # @param [Response] response
+      #   the response to process
+      #
+      # @return [Response]
+      #
+      # @api private
+      def call(response)
+        respond_with(response, handler.new(response.output))
+      end
+
+    end # class Wrapper
+  end # module Processor
+end # module Substation

data/lib/substation/version.rb

@@ -1,4 +1,4 @@
 module Substation
   # Gem version
-  VERSION = '0.0.7'.freeze
+  VERSION = '0.0.8'.freeze
 end

data/spec/spec_helper.rb

@@ -1,5 +1,7 @@
 require 'devtools/spec_helper'
 
+require 'concord' # makes spec setup easier
+
 module Spec
 
   def self.response_data
@@ -25,6 +27,61 @@ module Spec
     end
   end
 
+  class Processor
+    include Concord.new(:handler)
+  end
+
+  module Handler
+
+    class Evaluator
+      class Result
+
+        include Concord::Public.new(:output)
+
+        class Success < self
+          def success?
+            true
+          end
+        end
+
+        class Failure < self
+          def success?
+            false
+          end
+        end
+      end
+
+      def call(data)
+        if data == :success
+          Result::Success.new(data)
+        else
+          Result::Failure.new(:failure)
+        end
+      end
+    end
+
+    class Pivot
+      def call(request)
+        request.success(request.input)
+      end
+    end
+
+    class Wrapper
+      class Presenter
+        include Concord.new(:data)
+      end
+
+      include Concord.new(:data)
+
+      def call(data)
+        Presenter.new(data)
+      end
+    end
+  end
+
+  FAKE_HANDLER   = Object.new
+  FAKE_PROCESSOR = Processor.new(FAKE_HANDLER)
+
 end
 
 if ENV['COVERAGE'] == 'true'

data/spec/unit/substation/chain/class_methods/build_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Chain, '.build' do
+
+  context "when a block is given" do
+    subject { described_class.build(dsl, other, &block) }
+
+    let(:dsl)       { Chain::DSL::Builder.call(registry) }
+    let(:registry)  { { :test => Spec::Processor } }
+    let(:other)     { [ processor ] }
+    let(:processor) { Spec::FAKE_PROCESSOR }
+    let(:block)     { lambda { |_| test(Spec::FAKE_HANDLER) } }
+
+    let(:expected)  { Chain.new(dsl.processors(other, &block)) }
+
+    it { should eql(expected) }
+  end
+
+  context "when no block is given" do
+    subject { described_class.build(dsl, other) }
+
+    let(:dsl)       { Chain::DSL::Builder.call(registry) }
+    let(:registry)  { { :test => Spec::Processor } }
+    let(:other)     { [ processor ] }
+    let(:processor) { Spec::FAKE_PROCESSOR }
+
+    let(:expected)  { Chain.new(dsl.processors(other)) }
+
+    it { should eql(expected) }
+  end
+end

data/spec/unit/substation/chain/dsl/builder/class_methods/call_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL::Builder, '.call' do
+  subject { described_class.call(registry) }
+
+  let(:registry) { { :test => Spec::Processor } }
+
+  let(:builder) { mock(:dsl => dsl) }
+  let(:dsl)     { mock }
+
+  before do
+    described_class.should_receive(:new).with(registry).and_return(builder)
+    builder.should_receive(:dsl).and_return(dsl)
+  end
+
+  it { should be(dsl) }
+end

data/spec/unit/substation/chain/dsl/builder/dsl_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL::Builder, '#dsl' do
+  subject { dsl.new(processors, &block) }
+
+  let(:dsl)        { builder.dsl }
+  let(:builder)    { described_class.new(registry) }
+  let(:registry)   { { :test => Spec::Processor } }
+  let(:processors) { [] }
+  let(:block)      { lambda { |_| test(Spec::FAKE_HANDLER) } }
+  let(:processor)  { Spec::FAKE_PROCESSOR }
+
+  its(:processors) { should include(processor) }
+
+  it "should create a subclass of Chain::DSL" do
+    subject.class.should be < Chain::DSL
+  end
+end

data/spec/unit/substation/chain/dsl/chain_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL, '#chain' do
+  subject { object.chain(other) }
+
+  let(:object)    { described_class.new(chain) }
+  let(:chain)     { Chain::EMPTY }
+  let(:other)     { [ processor ] }
+  let(:processor) { Spec::FAKE_PROCESSOR }
+
+  its(:processors) { should include(processor) }
+end

data/spec/unit/substation/chain/dsl/class_methods/processors_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL, '.processors' do
+
+  let(:chain) { Chain::EMPTY }
+
+  context "and a block is given" do
+    subject { described_class.processors(chain, &block) }
+
+    let(:block)     { lambda { |_| use(Spec::FAKE_PROCESSOR) } }
+    let(:processor) { Spec::FAKE_PROCESSOR }
+
+    it { should include(processor) }
+  end
+
+  context "and no block is given" do
+    subject { described_class.processors(chain) }
+
+    it { should be_empty }
+  end
+end

data/spec/unit/substation/chain/dsl/processors_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL, '#processors' do
+  subject { object.processors }
+
+  let(:processor) { Spec::FAKE_PROCESSOR }
+
+  context "and a block is given" do
+    let(:object)    { described_class.new(chain, &block) }
+    let(:chain) { Chain::EMPTY }
+    let(:block)     { lambda { |_| use(Spec::FAKE_PROCESSOR) } }
+
+    it { should include(processor) }
+
+    its(:length) { should == 1 }
+  end
+
+  context "and no block is given" do
+    let(:object) { described_class.new(chain) }
+    let(:chain)  { Chain.new([ processor ]) }
+
+    it { should include(processor) }
+
+    its(:length) { should == 1 }
+  end
+end

data/spec/unit/substation/chain/dsl/use_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::DSL, '#use' do
+  subject { object.use(processor) }
+
+  let(:object)    { described_class.new(chain) }
+  let(:chain)     { Chain::EMPTY }
+  let(:processor) { Spec::FAKE_PROCESSOR }
+
+  its(:processors) { should include(processor) }
+end

data/spec/unit/substation/chain/each_spec.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain, '#each' do
+  subject { object.each { |tuple| yields << processor } }
+
+  let(:object)     { described_class.new(processors) }
+  let(:processors) { [ processor ] }
+  let(:processor)  { Spec::FAKE_PROCESSOR }
+  let(:yields)     { [] }
+
+  before do
+    object.should be_instance_of(described_class)
+  end
+
+  it_should_behave_like 'an #each method'
+
+  it 'yields only processors' do
+    subject
+    yields.each { |processor| processor.should be_instance_of(Spec::Processor) }
+  end
+
+  it 'yields only processors with the expected handler' do
+    expect { subject }.to change { yields.dup }.
+      from([]).
+      to([ processor ])
+  end
+end
+
+describe Chain do
+  subject { described_class.new(processors) }
+
+  let(:processors) { [ processor ] }
+  let(:processor)  { Spec::FAKE_PROCESSOR }
+
+  before do
+    subject.should be_instance_of(described_class)
+  end
+
+  it { should be_kind_of(Enumerable) }
+
+  it 'case matches Enumerable' do
+    (Enumerable === subject).should be(true)
+  end
+end

data/spec/unit/substation/chain/outgoing/call_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::Outgoing, '#call' do
+
+  subject { object.call(request) }
+
+  let(:object) {
+    Class.new {
+      include Substation::Chain::Outgoing
+      def call(request)
+        response = request.success(request.input)
+        respond_with(response, :altered)
+      end
+    }.new
+  }
+
+  let(:response) { Response::Success.new(request, :altered) }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { mock }
+  let(:input)    { mock }
+
+  it { should eql(response) }
+end

data/spec/unit/substation/environment/chain_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Substation::Environment, '#chain' do
+
+  let(:object) { described_class.build(&block) }
+
+  let(:expected) { Chain.build(dsl, other, &chain) }
+  let(:other)    { Chain::EMPTY }
+  let(:chain)    { lambda { |_| test Spec::FAKE_HANDLER } }
+  let(:dsl)      { Chain::DSL::Builder.call(registry) }
+  let(:registry) { described_class::DSL.registry(&block) }
+  let(:block)    { lambda { |_| register(:test, Spec::Processor) } }
+
+  context "when other is not given" do
+    context "and a block is given" do
+      subject { object.chain(&chain) }
+
+      it { should eql(expected) }
+    end
+
+    context "and no block is given" do
+      subject { object.chain }
+
+      let(:expected) { Chain.build(dsl, other) }
+
+      it { should eql(expected) }
+    end
+  end
+
+  context "when other is given" do
+    context "and a block is given" do
+      subject { object.chain(other, &chain) }
+
+      it { should eql(expected) }
+    end
+
+    context "and no block is given" do
+      subject { object.chain(other) }
+
+      let(:expected) { Chain.build(dsl, other) }
+
+      it { should eql(expected) }
+    end
+  end
+end

data/spec/unit/substation/environment/class_methods/build_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Substation::Environment, '.build' do
+  subject { described_class.build(&block) }
+
+  let(:block)    { lambda { |_| register(:test, Substation) } }
+  let(:expected) { described_class.new(registry) }
+  let(:registry) { described_class::DSL.registry(&block) }
+
+  it { should eql(expected) }
+end

data/spec/unit/substation/environment/dsl/class_methods/registry_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Substation::Environment::DSL, '.registry' do
+  context "when a block is given" do
+    subject { described_class.registry(&block) }
+
+    let(:block)    { lambda { |_| register :test, Spec::Processor } }
+    let(:expected) { { :test => Spec::Processor } }
+
+    it { should eql(expected) }
+  end
+
+  context "when no block is given" do
+    subject { described_class.registry }
+
+    it { should eql({}) }
+  end
+end

data/spec/unit/substation/environment/dsl/register_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Substation::Environment::DSL, '#register' do
+  subject { object.register(name, processor) }
+
+  let(:object)    { described_class.new }
+  let(:name)      { :test }
+  let(:processor) { Spec::Processor }
+
+  let(:expected) { { :test => Spec::Processor } }
+  let(:block)    { lambda { |_| register :test, Spec::Processor } }
+
+  its(:registry) { should eql(expected) }
+end

data/spec/unit/substation/environment/dsl/registry_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Substation::Environment::DSL, '#registry' do
+  subject { object.registry }
+
+  context "when a block is given" do
+    let(:object)   { described_class.new(&block) }
+    let(:block)    { lambda { |_| register :test, Spec::Processor } }
+    let(:expected) { { :test => Spec::Processor } }
+
+    it { should eql(expected) }
+  end
+
+  context "when no block is given" do
+    let(:object) { described_class.new }
+
+    it { should eql({}) }
+  end
+end

data/spec/unit/substation/processor/evaluator/call_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Evaluator, '#call' do
+  subject { object.call(request) }
+
+  let(:object)  { described_class.new(Spec::Handler::Evaluator.new) }
+  let(:request) { Request.new(env, input) }
+  let(:env)     { mock }
+
+  context "when evaluation is successful" do
+    let(:input)    { :success }
+    let(:response) { Response::Success.new(request, input) }
+
+    it { should eql(response) }
+  end
+
+  context "when evaluation is not successful" do
+    let(:input)    { :invalid }
+    let(:response) { Response::Failure.new(request, :failure) }
+
+    it { should eql(response) }
+  end
+end

data/spec/unit/substation/processor/pivot/call_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Pivot, '#call' do
+  subject { object.call(request) }
+
+  let(:object)  { described_class.new(Spec::Handler::Pivot.new) }
+  let(:request) { Request.new(env, input) }
+  let(:env)     { mock }
+  let(:input)   { mock }
+
+  let(:response) { Response::Success.new(request, request.input) }
+
+  it { should eql(response) }
+end

data/spec/unit/substation/processor/wrapper/call_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Processor::Wrapper, '#call' do
+  subject { object.call(response) }
+
+  let(:object)   { described_class.new(Spec::Handler::Wrapper::Presenter) }
+  let(:response) { Response::Success.new(request, output) }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { mock }
+  let(:input)    { mock }
+  let(:output)   { mock }
+
+  let(:wrapped) { Response::Success.new(request, data) }
+  let(:data)    { Spec::Handler::Wrapper::Presenter.new(output) }
+
+  it { should eql(wrapped) }
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: substation
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-14 00:00:00.000000000 Z
+date: 2013-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: adamantium
@@ -103,7 +103,8 @@ extra_rdoc_files:
 files:
 - .gitignore
 - .rspec
-- .rvmrc
+- .ruby-gemset
+- .ruby-version
 - .travis.yml
 - CONTRIBUTING.md
 - Changelog.md
@@ -122,25 +123,49 @@ files:
 - config/yardstick.yml
 - lib/substation.rb
 - lib/substation/chain.rb
+- lib/substation/chain/dsl.rb
 - lib/substation/dispatcher.rb
+- lib/substation/environment.rb
+- lib/substation/environment/dsl.rb
 - lib/substation/observer.rb
+- lib/substation/processor.rb
+- lib/substation/processor/evaluator.rb
+- lib/substation/processor/pivot.rb
+- lib/substation/processor/wrapper.rb
 - lib/substation/request.rb
 - lib/substation/response.rb
-- lib/substation/support/utils.rb
+- lib/substation/utils.rb
 - lib/substation/version.rb
 - spec/integration/substation/dispatcher/call_spec.rb
 - spec/spec_helper.rb
 - spec/unit/substation/chain/call_spec.rb
+- spec/unit/substation/chain/class_methods/build_spec.rb
+- spec/unit/substation/chain/dsl/builder/class_methods/call_spec.rb
+- spec/unit/substation/chain/dsl/builder/dsl_spec.rb
+- spec/unit/substation/chain/dsl/chain_spec.rb
+- spec/unit/substation/chain/dsl/class_methods/processors_spec.rb
+- spec/unit/substation/chain/dsl/processors_spec.rb
+- spec/unit/substation/chain/dsl/use_spec.rb
+- spec/unit/substation/chain/each_spec.rb
 - spec/unit/substation/chain/incoming/result_spec.rb
+- spec/unit/substation/chain/outgoing/call_spec.rb
 - spec/unit/substation/chain/outgoing/result_spec.rb
 - spec/unit/substation/dispatcher/action/call_spec.rb
 - spec/unit/substation/dispatcher/action/class_methods/coerce_spec.rb
 - spec/unit/substation/dispatcher/action_names_spec.rb
 - spec/unit/substation/dispatcher/call_spec.rb
 - spec/unit/substation/dispatcher/class_methods/coerce_spec.rb
+- spec/unit/substation/environment/chain_spec.rb
+- spec/unit/substation/environment/class_methods/build_spec.rb
+- spec/unit/substation/environment/dsl/class_methods/registry_spec.rb
+- spec/unit/substation/environment/dsl/register_spec.rb
+- spec/unit/substation/environment/dsl/registry_spec.rb
 - spec/unit/substation/observer/chain/call_spec.rb
 - spec/unit/substation/observer/class_methods/coerce_spec.rb
 - spec/unit/substation/observer/null/call_spec.rb
+- spec/unit/substation/processor/evaluator/call_spec.rb
+- spec/unit/substation/processor/pivot/call_spec.rb
+- spec/unit/substation/processor/wrapper/call_spec.rb
 - spec/unit/substation/request/env_spec.rb
 - spec/unit/substation/request/error_spec.rb
 - spec/unit/substation/request/input_spec.rb

data/.rvmrc

@@ -1 +0,0 @@
-rvm use @$(basename `pwd`) --create