substation 0.0.6 → 0.0.7

data/CONTRIBUTING.md

@@ -0,0 +1,11 @@
+Contributing
+------------
+
+* If you want your code merged into the mainline, please discuss the proposed changes with me before doing any work on it.
+* Fork the project.
+* Make your feature addition or bug fix.
+  * Follow this [style guide](https://github.com/dkubb/styleguide).
+* Add specs for it. This is important so I don't break it in a future version unintentionally. Tests must cover all branches within the code, and code must be fully covered.
+* Commit, do not mess with Rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Run "rake ci". This must pass and not show any regressions in the metrics for the code to be merged.
+* Send me a pull request. Bonus points for topic branches.

data/Changelog.md

@@ -1,3 +1,12 @@
+# v0.0.7 2013-06-14
+
+* [feature] Make `Substation::Response#request` part of the public API (snusnu)
+* [feature] Introduce `Substation::Chain` to process an action as a chain of
+            incoming handlers, followed by the pivot handler and some outgoing
+            handlers.
+
+[Compare v0.0.6..v0.0.7](https://github.com/snusnu/substation/compare/v0.0.6...v0.0.7)
+
 # v0.0.6 2013-05-17
 
 * [fixed] Fixed bug for actions configured with a const handler (snusnu)

data/Gemfile

@@ -3,6 +3,6 @@ source 'http://rubygems.org'
 gemspec
 
 group :development do
-  gem 'devtools', :git => 'https://github.com/datamapper/devtools.git'
+  gem 'devtools', :git => 'https://github.com/rom-rb/devtools.git'
   eval File.read('Gemfile.devtools')
 end

data/README.md

@@ -12,23 +12,25 @@
 [codeclimate]: https://codeclimate.com/github/snusnu/substation
 [coveralls]: https://coveralls.io/r/snusnu/substation
 
-`substation` can be thought of as a domain level request router. It assumes
+Think of `substation` as some sort of domain level request router. It assumes
 that every usecase in your application has a name and is implemented in a dedicated
-class that will be referred to as an *action* for the purposes of this
-document. The only protocol such actions must support is `#call(request)`.
+object that will be referred to as an *action*. The only protocol such actions must
+support is `#call(request)`.
 
-The contract for actions specifies that when invoked, actions can
+The contract for actions specifies that when invoked, they can
 receive arbitrary input data which will be available in `request.input`.
 Additionally, `request.env` contains an arbitrary object that
 represents your application environment and will typically provide access
-to useful things like a logger or a storage engine abstraction.
+to useful things like a logger and probably some sort of storage engine
+abstraction object.
 
 The contract further specifies that every action must return an instance
 of either `Substation::Response::Success` or
 `Substation::Response::Failure`. Again, arbitrary data can be associated
-with any kind of response, and will be available in `response.data`. In
-addition to that, `response.success?` is available and will indicate
-wether invoking the action was successful or not.
+with any kind of response, and will be available in `response.output`. To
+indicate wether invoking the action was successful or not, you can use
+`response.success?`. In addition to that, `response.request` contains
+the request object used to invoke the action.
 
 `Substation::Dispatcher` stores a mapping of action names to the actual
 objects implementing the action, as well as the application environment.
@@ -290,16 +292,28 @@ few simple actions.
 module App
 
   class Database
-    include Concord.new(:entries)
+    include Equalizer.new(:relations)
+
+    def initialize(relations)
+      @relations = relations
+    end
 
     def [](relation_name)
-      Relation.new(entries[relation_name])
+      Relation.new(relations[relation_name])
     end
 
+    protected
+
+    attr_reader :relations
+
     class Relation
-      include Concord.new(:tuples)
+      include Equalizer.new(:tuples)
       include Enumerable
 
+      def initialize(tuples)
+        @tuples = tuples
+      end
+
       def each(&block)
         return to_enum unless block_given?
         tuples.each(&block)
@@ -313,37 +327,45 @@ module App
       def insert(tuple)
         self.class.new(tuples + [tuple])
       end
+
+      protected
+
+      attr_reader :tuples
     end
   end
 
   module Models
 
     class Person
-      include Concord.new(:attributes)
+      include Equalizer.new(:id, :name)
 
-      def id
-        attributes[:id]
-      end
+      attr_reader :id
+      attr_reader :name
 
-      def name
-        attributes[:name]
+      def initialize(attributes)
+        @id, @name = attributes.values_at(:id, :name)
       end
     end
   end # module Models
 
   class Environment
-    include Concord.new(:storage)
-    include Adamantium::Flat
+    include Equalizer.new(:storage)
 
     attr_reader :storage
+
+    def initialize(storage)
+      @storage = storage
+    end
   end
 
   class Storage
-    include Concord.new(:db)
-    include Adamantium::Flat
-
+    include Equalizer.new(:db)
     include Models
 
+    def initialize(db)
+      @db = db
+    end
+
     def list_people
       db[:people].all.map { |tuple| Person.new(tuple) }
     end
@@ -356,14 +378,21 @@ module App
       relation = db[:people].insert(:id => person.id, :name => person.name)
       relation.map { |tuple| Person.new(tuple) }
     end
+
+    protected
+
+    attr_reader :db
   end
 
   class App
-    include Concord.new(:dispatcher)
-    include Adamantium::Flat
+    include Equalizer.new(:dispatcher)
+
+    def initialize(dispatcher)
+      @dispatcher = dispatcher
+    end
 
     def call(name, input = nil)
-      dispatcher.call(name, input)
+      @dispatcher.call(name, input)
     end
   end
 
@@ -373,7 +402,6 @@ module App
   class Action
 
     include AbstractType
-    include Adamantium::Flat
 
     def self.call(request)
       new(request).call
@@ -440,8 +468,8 @@ module App
   end # module Actions
 
   module Observers
-    LogEvent  = Class.new { def self.call(response); end }
-    SendEmail = Class.new { def self.call(response); end }
+    LogEvent  = Proc.new { |response| response }
+    SendEmail = Proc.new { |response| response }
   end
 
   DB = Database.new({
@@ -474,3 +502,188 @@ response = App::APP.call(:list_companies)
 response.success? # => true
 response.output   # => [#<App::Models::Person attributes={:id=>1, :name=>"John"}>]
 ```
+
+## Chains
+
+In a typical application scenario, a few things need to happen before an
+actual use case (an action) can be invoked. These things will often
+include the following steps (probably in that order).
+
+* Authentication
+* Authorization
+* Input data sanitization
+* Input data validation
+
+We only want to invoke our action if all those steps succeed. If any of
+the above steps fails, we want to send back a response that provides
+details about what exactly prevented us from further processing the
+request. If authentication fails, why try to authorize. If authorization
+fails, why try to sanitize. And so on.
+
+If, however, all the above steps passed, we can
+
+* Invoke the action
+
+Oftentimes, at this point, we're not done just yet. We have invoked our
+action and we probably got back some data, but we still need to turn it
+into something the caller can easily consume. If you happen to develop a
+web application for example, you'll probably want to render some HTML or
+some JSON.
+
+a) If you need to return HTML, you might
+
+* Wrap the response data in some presenter object
+* Wrap the presenter in some view object
+* Use that view object to render an HTML template
+
+b) If you need to return JSON, you might just
+
+* Pass the response data to some serializer object and dump it to JSON
+
+To allow chaining all those steps in a declarative way, substation
+provides an object called `Substation::Chain`. Its contract is dead
+simple:
+
+1. `#call(Substation::Request) => Substation::Response`
+2. `#result(Substation::Response) => Substation::Response`
+
+You typically won't be calling `Substation::Chain#result` yourself, but
+having it around, allows us to use chains in *incoming handlers*,
+essentially nesting chains. This makes it possible to construct one
+chain up until the pivot handler, and then reuse that same chain in one
+usecase that takes the response and renders HTML, and in another that
+renders JSON.
+
+To construct a chain, you need to pass an enumerable of so called
+handler objects to `Substation::Chain.new`. Handlers must support two
+methods:
+
+1. `#call(<Substation::Request, Substation::Response>) => Substation::Response`
+2. `#result(Substation::Response) => <Substation::Request, Substation::Response>`
+
+### Incoming handlers
+
+All steps required *before* processing the action will potentially
+produce a new, altered, `Substation::Request`. Therefore, the object
+passed to `#call` must be an instance of `Substation::Request`.
+
+Since `#call` must return a `Substation::Response` (because the chain
+would halt and return that response in case calling its `#success?`
+method would return `false`), we also need to implement `#result`
+and have it return a `Substation::Request` instance that can be passed
+on to the next handler.
+
+The contract for incoming handlers therefore is:
+
+1. `#call(Substation::Request) => Substation::Response`
+2. `#result(Substation::Response) => Substation::Request`
+
+By including the `Substation::Chain::Incoming` module into your handler
+class, you'll get the following for free:
+
+```ruby
+def result(response)
+  Request.new(response.env, response.output)
+end
+```
+
+This shows that an incoming handler can alter the incoming request in any
+way that it wants to, as long as it returns the new request input data in
+`Substation::Response#output` returned from `#call`.
+
+### The pivot handler
+
+Pivot is just another fancy name for the action in the context of a
+chain. It's also the point where all subsequent handlers have to further
+process the `Substation::Response` returned from invoking the action.
+
+The contract for the pivot handler therefore is:
+
+1. `#call(Substation::Request) => Substation::Response`
+2. `#result(Substation::Response) => Substation::Response`
+
+By including the `Substation::Chain::Pivot` module into your handler
+class, you'll get the following for free:
+
+```ruby
+def result(response)
+  response
+end
+```
+
+This reflects the fact that a pivot handler (since it's the one actually
+producing the "raw" response, returns it unaltered.
+
+### Outgoing handlers
+
+All steps required *after* processing the action will potentially
+produce a new, altered, `Substation::Response` instance to be returned.
+Therefore the object passed to `#call` must be an instance of
+`Substation::Response`. Since subsequent outgoing handlers might further
+process the response, `#result` must be implemented so that it returns a
+`Substation::Response` object that can be passed on to the next handler.
+
+The contract for outgoing handlers therefore is:
+
+1. `#call(Substation::Response) => Substation::Response`
+2. `#result(Substation::Response) => Substation::Response`
+
+By including the `Substation::Chain::Outgoing` module into your handler
+class, you'll get the following for free:
+
+```ruby
+def result(response)
+  response
+end
+```
+
+This shows that an outgoing handler's `#call` can do anything with
+the `Substation::Response#output` it received, as long as it makes
+sure to return a new response with the new output properly set.
+
+### Example
+
+[substation-demo](https://github.com/snusnu/substation-demo) implements a
+simple web application using `Substation::Chain`.
+
+The demo implements a few of the above mentioned *incoming handlers*
+for
+
+* [Sanitization](https://github.com/snusnu/substation-demo/blob/master/demo/web/sanitizers.rb) using [ducktrap](https://github.com/mbj/ducktrap)
+* [Validation](https://github.com/snusnu/substation-demo/blob/master/demo/validators.rb) using [vanguard](https://github.com/mbj/vanguard)
+
+and some simple *outgoing handlers* for
+
+* Wrapping response output in a
+[presenter](https://github.com/snusnu/substation-demo/blob/master/demo/web/presenters.rb)
+* [Serializing](https://github.com/snusnu/substation-demo/blob/master/demo/web/serializers.rb) response output to JSON
+
+The
+[handlers](https://github.com/snusnu/substation-demo/blob/master/demo/web/processors.rb)
+are called *processors* in that app, and encapsulate the actual handler
+performing the job. That's a common pattern, because you typically will
+have to adapt to the interface your actual handlers provide.
+
+Have a look at the base
+[actions](https://github.com/snusnu/substation-demo/blob/master/demo/web/actions.rb)
+that are then used to either produce
+[HTML](https://github.com/snusnu/substation-demo/blob/master/demo/web/actions/html.rb)
+or
+[JSON](https://github.com/snusnu/substation-demo/blob/master/demo/web/actions/json.rb).
+
+Finally it's all hooked up behind a few
+[sinatra](https://github.com/sinatra/sinatra)
+[routes](https://github.com/snusnu/substation-demo/blob/master/demo/web/routes.rb)
+
+## Credits
+
+* [snusnu](https://github.com/snusnu)
+* [mbj](https://github.com/mbj)
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+
+## Copyright
+
+Copyright &copy; 2013 Martin Gamsjaeger (snusnu). See [LICENSE](LICENSE) for details.

data/config/flay.yml

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

data/config/reek.yml

@@ -23,7 +23,9 @@ DuplicateMethodCall:
   allow_calls: []
 FeatureEnvy:
   enabled: true
-  exclude: []
+  exclude:
+  - Substation::Chain#call # loops over instance state
+  - Substation::Chain::Incoming#result # defined in a module
 IrresponsibleModule:
   enabled: true
   exclude: []
@@ -63,6 +65,8 @@ TooManyStatements:
   - Substation::Utils#self.const_get
   - Substation::Utils#self.symbolize_keys
   - Substation::Dispatcher::Action#self.coerce
+  - Substation::Chain#call
+  - Substation::Utils#self.coerce_callable
   max_statements: 3
 UncommunicativeMethodName:
   enabled: true
@@ -100,5 +104,6 @@ UnusedParameters:
   exclude: []
 UtilityFunction:
   enabled: true
-  exclude: []
+  exclude:
+  - Substation::Chain::Incoming#result # defined in a module
   max_helper_calls: 0

data/lib/substation.rb

@@ -36,5 +36,6 @@ end
 require 'substation/request'
 require 'substation/response'
 require 'substation/observer'
+require 'substation/chain'
 require 'substation/dispatcher'
 require 'substation/support/utils'

data/lib/substation/chain.rb

@@ -0,0 +1,164 @@
+module Substation
+
+  # Implements a chain of responsibility for an action
+  #
+  # An instance of this class will typically contain (in that order)
+  # a few handlers that process the incoming {Request} object, one
+  # handler that calls an action ({Chain::Pivot}), and some handlers
+  # that process the outgoing {Response} object.
+  #
+  # Both {Chain::Incoming} and {Chain::Outgoing} handlers must
+  # respond to `#call(response)` and `#result(response)`.
+  #
+  # @example chain handlers (used in instance method examples)
+  #
+  #   module App
+  #
+  #     class Handler
+  #
+  #       def initialize(handler = nil)
+  #         @handler = handler
+  #       end
+  #
+  #       protected
+  #
+  #       attr_reader :handler
+  #
+  #       class Incoming < self
+  #         include Substation::Chain::Incoming
+  #       end
+  #
+  #       class Outgoing < self
+  #         include Substation::Chain::Outgoing
+  #
+  #         private
+  #
+  #         def respond_with(response, output)
+  #           response.class.new(response.request, output)
+  #         end
+  #       end
+  #     end
+  #
+  #     class Validator < Handler::Incoming
+  #       def call(request)
+  #         result = handler.call(request.input)
+  #         if result.valid?
+  #           request.success(request.input)
+  #         else
+  #           request.error(result.violations)
+  #         end
+  #       end
+  #     end
+  #
+  #     class Pivot < Handler
+  #       include Substation::Chain::Pivot
+  #
+  #       def call(request)
+  #         handler.call(request)
+  #       end
+  #     end
+  #
+  #     class Presenter < Handler::Outgoing
+  #       def call(response)
+  #         respond_with(response, handler.new(response.output))
+  #       end
+  #     end
+  #   end
+  #
+  class Chain
+
+    # Supports chaining handlers processed before the {Pivot}
+    module Incoming
+
+      # 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}
+      #
+      # @return [Request]
+      #   the request passed on to the next handler in a {Chain}
+      #
+      # @api private
+      def result(response)
+        Request.new(response.env, response.output)
+      end
+    end
+
+    # Supports chaining the {Pivot} or handlers processed after the {Pivot}
+    module Outgoing
+
+      # The response passed on to the next handler in a {Chain}
+      #
+      # @param [Response] response
+      #   the response returned from the previous handler in a {Chain}
+      #
+      # @return [Response]
+      #   the response passed on to the next handler in a {Chain}
+      #
+      # @api private
+      def result(response)
+        response
+      end
+    end
+
+    # Supports chaining the {Pivot} handler
+    Pivot = Outgoing
+
+    include Concord.new(:handlers)
+    include Adamantium::Flat
+    include Pivot # allow nesting of chains
+
+    # Call the chain
+    #
+    # Invokes all handlers and returns either the first
+    # {Response::Failure} that it encounters, or if all
+    # goes well, the {Response::Success} returned from
+    # the last handler.
+    #
+    # @example
+    #
+    #   module App
+    #     SOME_ACTION = Substation::Chain.new [
+    #       Validator.new(MY_VALIDATOR),
+    #       Pivot.new(Actions::SOME_ACTION),
+    #       Presenter.new(Presenters::SomePresenter)
+    #     ]
+    #
+    #     env     = Object.new # your env would obviously differ
+    #     input   = { 'name' => 'John' }
+    #     request = Substation::Request.new(env, input)
+    #
+    #     response = SOME_ACTION.call(request)
+    #
+    #     if response.success?
+    #       response.output # => the output wrapped in a presenter
+    #     else
+    #       response.output # => if validation, pivot or presenter failed
+    #     end
+    #   end
+    #
+    # @param [Request] request
+    #   the request to handle
+    #
+    # @return [Response::Success]
+    #   the response returned from the last handler
+    #
+    # @return [Response::Failure]
+    #   the response returned from the failing handler
+    #
+    # @raise [Exception]
+    #   any exception that isn't explicitly rescued in client code
+    #
+    # @api public
+    def call(request)
+      handlers.inject(request) { |result, handler|
+        response = handler.call(result)
+        return response unless response.success?
+        handler.result(response)
+      }
+    end
+
+  end # class Chain
+end # module Substation

data/lib/substation/response.rb

@@ -41,6 +41,18 @@ module Substation
     include Equalizer.new(:request, :output)
     include Adamantium::Flat
 
+    # The request that lead to this response
+    #
+    # @example
+    #
+    #   response = dispatcher.call(:successful_action, :some_input)
+    #   response.request # => request passed to action named :successful_action
+    #
+    # @return [Request]
+    #
+    # @api public
+    attr_reader :request
+
     # The application environment used within an action
     #
     # @example
@@ -115,15 +127,6 @@ module Substation
     # @api public
     abstract_method :success?
 
-    protected
-
-    # The request that lead to this response
-    #
-    # @return [Request]
-    #
-    # @api private
-    attr_reader :request
-
     # An errorneous {Response}
     class Failure < self
 

data/lib/substation/support/utils.rb

@@ -57,7 +57,7 @@ module Substation
       case handler
       when Symbol, String
         Utils.const_get(handler)
-      when Proc, Class
+      when Proc, Class, Chain
         handler
       else
         raise(ArgumentError)

data/lib/substation/version.rb

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

data/spec/integration/substation/dispatcher/call_spec.rb

@@ -5,16 +5,28 @@ require 'spec_helper'
 module App
 
   class Database
-    include Concord.new(:entries)
+    include Equalizer.new(:relations)
+
+    def initialize(relations)
+      @relations = relations
+    end
 
     def [](relation_name)
-      Relation.new(entries[relation_name])
+      Relation.new(relations[relation_name])
     end
 
+    protected
+
+    attr_reader :relations
+
     class Relation
-      include Concord.new(:tuples)
+      include Equalizer.new(:tuples)
       include Enumerable
 
+      def initialize(tuples)
+        @tuples = tuples
+      end
+
       def each(&block)
         return to_enum unless block_given?
         tuples.each(&block)
@@ -28,37 +40,45 @@ module App
       def insert(tuple)
         self.class.new(tuples + [tuple])
       end
+
+      protected
+
+      attr_reader :tuples
     end
   end
 
   module Models
 
     class Person
-      include Concord.new(:attributes)
+      include Equalizer.new(:id, :name)
 
-      def id
-        attributes[:id]
-      end
+      attr_reader :id
+      attr_reader :name
 
-      def name
-        attributes[:name]
+      def initialize(attributes)
+        @id, @name = attributes.values_at(:id, :name)
       end
     end
   end # module Models
 
   class Environment
-    include Concord.new(:storage)
-    include Adamantium::Flat
+    include Equalizer.new(:storage)
 
     attr_reader :storage
+
+    def initialize(storage)
+      @storage = storage
+    end
   end
 
   class Storage
-    include Concord.new(:db)
-    include Adamantium::Flat
-
+    include Equalizer.new(:db)
     include Models
 
+    def initialize(db)
+      @db = db
+    end
+
     def list_people
       db[:people].all.map { |tuple| Person.new(tuple) }
     end
@@ -71,14 +91,21 @@ module App
       relation = db[:people].insert(:id => person.id, :name => person.name)
       relation.map { |tuple| Person.new(tuple) }
     end
+
+    protected
+
+    attr_reader :db
   end
 
   class App
-    include Concord.new(:dispatcher)
-    include Adamantium::Flat
+    include Equalizer.new(:dispatcher)
+
+    def initialize(dispatcher)
+      @dispatcher = dispatcher
+    end
 
     def call(name, input = nil)
-      dispatcher.call(name, input)
+      @dispatcher.call(name, input)
     end
   end
 
@@ -88,7 +115,6 @@ module App
   class Action
 
     include AbstractType
-    include Adamantium::Flat
 
     def self.call(request)
       new(request).call
@@ -155,8 +181,8 @@ module App
   end # module Actions
 
   module Observers
-    LogEvent  = Class.new { def self.call(response); end }
-    SendEmail = Class.new { def self.call(response); end }
+    LogEvent  = Proc.new { |response| response }
+    SendEmail = Proc.new { |response| response }
   end
 
   DB = Database.new({

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain, '#call' do
+
+  subject { object.call(request) }
+
+  let(:object)   { described_class.new(handlers) }
+  let(:handlers) { [ handler_1, handler_2 ] }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { mock }
+  let(:input)    { mock }
+
+  let(:handler_2) {
+    Class.new {
+      include Substation::Chain::Outgoing
+      def call(request)
+        request.success(request.input)
+      end
+    }.new
+  }
+
+  context "when all handlers are successful" do
+    let(:handler_1) {
+      Class.new {
+        include Substation::Chain::Incoming
+        def call(request)
+          request.success(request.input)
+        end
+      }.new
+    }
+
+    let(:response) { Response::Success.new(request, request.input) }
+
+    it { should eql(response) }
+  end
+
+  context "when an intermediate handler is not successful" do
+    let(:handler_1) {
+      Class.new {
+        include Substation::Chain::Incoming
+        def call(request)
+          request.error(request.input)
+        end
+      }.new
+    }
+
+    let(:response) { Response::Failure.new(request, request.input) }
+
+    before do
+      handler_2.should_not_receive(:call)
+    end
+
+    it { should eql(response) }
+  end
+end

data/spec/unit/substation/chain/incoming/result_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::Incoming, '#result' do
+
+  subject { object.result(response) }
+
+  let(:object) {
+    Class.new {
+      include Substation::Chain::Incoming
+    }.new
+  }
+
+  let(:response) { Response::Success.new(request, input) }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { mock }
+  let(:input)    { mock }
+
+  it { should eql(request) }
+end

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Chain::Outgoing, '#result' do
+
+  subject { object.result(response) }
+
+  let(:object) {
+    Class.new {
+      include Substation::Chain::Outgoing
+    }.new
+  }
+
+  let(:response) { Response::Success.new(request, input) }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { mock }
+  let(:input)    { mock }
+
+  it { should be(response) }
+end

data/spec/unit/substation/response/request_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Response, '#request' do
+
+  subject { object.request }
+
+  let(:object)   { Class.new(described_class).new(request, output) }
+  let(:request)  { Request.new(env, input) }
+  let(:env)      { mock }
+  let(:input)    { mock }
+  let(:output)   { mock }
+
+  it { should equal(request) }
+end

data/spec/unit/substation/utils/class_methods/coerce_callable_spec.rb

@@ -30,6 +30,12 @@ describe Utils, '.coerce_callable' do
     it { should be(handler) }
   end
 
+  context "with a Chain handler" do
+    let(:handler) { Chain.new([]) }
+
+    it { should be(handler) }
+  end
+
   context "with an unsupported handler" do
     let(:handler) { mock }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: substation
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-17 00:00:00.000000000 Z
+date: 2013-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: adamantium
@@ -105,6 +105,7 @@ files:
 - .rspec
 - .rvmrc
 - .travis.yml
+- CONTRIBUTING.md
 - Changelog.md
 - Gemfile
 - Gemfile.devtools
@@ -120,6 +121,7 @@ files:
 - config/reek.yml
 - config/yardstick.yml
 - lib/substation.rb
+- lib/substation/chain.rb
 - lib/substation/dispatcher.rb
 - lib/substation/observer.rb
 - lib/substation/request.rb
@@ -128,6 +130,9 @@ files:
 - 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/incoming/result_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
@@ -144,6 +149,7 @@ files:
 - spec/unit/substation/response/failure/success_predicate_spec.rb
 - spec/unit/substation/response/input_spec.rb
 - spec/unit/substation/response/output_spec.rb
+- spec/unit/substation/response/request_spec.rb
 - spec/unit/substation/response/success/success_predicate_spec.rb
 - spec/unit/substation/utils/class_methods/coerce_callable_spec.rb
 - spec/unit/substation/utils/class_methods/const_get_spec.rb