poniard 0.0.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0163d066c3e20cea1fbed0c012265482f2cf119d
-  data.tar.gz: d787a5fb866cb192c7392df5089a4ea0ea7d43f6
+  metadata.gz: b20dd7bc5a80523165730ffd2352ba33036988b2
+  data.tar.gz: 9eb61c3e74958ace02b6865bb2d6ae0ed443b3a4
 SHA512:
-  metadata.gz: 6c9367058ed0f3f8fbf2ff11b626c3eff4f19e17142edb2c0b551f3e010bdffe6d7d738de2451acbc41567d6dc7827123e46a80aac89d4ed5d27645606007fe0
-  data.tar.gz: c8bd0c27c1341c9d56428a62fb23169059e74ffb2f426e58be38deb96ce8d9c6bb2df0174e54083b7850ee4f9bd470d498ab49ec9eaaa3496ab1c3dd1b5953ae
+  metadata.gz: b5ec064ebc9ed82ca7b3dd47e1e321b062ef153f795513b86feb00d08b0f742cbae5f272dd2ddf4f2c01c2b0b62f62b57e735a8981f3f0eea43587c8eb700ec0
+  data.tar.gz: bb8251380ad780db82f9a15171ba543787d78a25ee4c1368beffab81070d7ea4ff235333b99b74470d413cc34ebd926ee35299f8f43729b490cfe564a03086b6

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Poniard History
+
+## 1.0.0 - 20 April 2014
+
+* `respond_with` returns 406 for unknown formats.
+* Remove `OpenStruct` usage and other known cache-busting constructs.
+* `redirect_to` supports redirects to arbitrary locations when passed a string
+  parameter.
+* Complete documentation of public API.
+
+## 0.0.3 - 19 March 2014
+
+* Support `head` responses.
+
+## 0.0.2 - 26 January 2013
+
+* Hashes can be used directly as sources.
+* Provide default argument for `response.default`.
+
+## 0.0.1 - 25 November 2012
+
+* Initial release.
+

data/README.md

@@ -3,23 +3,23 @@ Poniard
 
 A lightweight gem that provides an alternative to Rails controllers. It uses
 parameter based dependency injection to explicitly make dependencies available,
-rather than mixing them all in from a base class. This allows you to properly
-unit test your controllers in isolation, bringing all the design benefits of
-TDD (as opposed to "test-first" development which is more common with the
-standard integration style controller tests).
+rather than mixing them all in from a base class. This allows controllers to be
+properly tested in isolation, bringing all the design benefits of TDD (as
+opposed to "test-first" development, which is more common with the standard
+integration style controller tests).
 
-Poniard is designed to be compatible with standard controllers. You can use it
+Poniard is designed to be compatible with standard controllers. It can be used
 for your entire application, just one action, or anything in between.
 
 Example
 -------
 
 A poniard controller is slightly more verbose than the what you may be used to.
-In particular, you need to specify all the different dependencies you wish to
-use (`response` and `finder` in this example) as parameters to your method.
-Poniard will introspect the method before calling, and ensure that the correct
-values are passed. These values will for the most part be the same objects you
-normally deal with in Rails (`session`, `flash`, etc...).
+In particular, all the dependencies of a method (`response` in the following
+example) must be declared as parameters to your method. Poniard will introspect
+the method before calling, and ensure that the correct values are passed. These
+values will for the most part be the same objects you normally deal with in
+Rails (`session`, `flash`, etc...).
 
 The following controller renders the default index template, setting the
 instance variables `@message`.
@@ -34,12 +34,12 @@ module Controller
 end
 ```
 
-This is more explicit than traditional controllers in two ways: passing
-variables to the template is done with an explicit method call rather than
-instance variable assignment, and dependencies that would normally be made
-available by a superclass are passed in as parameters to the method.
+This is differs from traditional controllers in two ways: passing variables to
+the template is done with an explicit method call rather than instance variable
+assignment, and dependencies that would normally be made available by
+a superclass are passed in as parameters to the method.
 
-Wiring this controller into your application is a one-liner in your normal
+Wiring this controller into an application is a one-liner in the normal
 controller definition.
 
 ```ruby
@@ -50,7 +50,7 @@ class RegistrationsController < ApplicationController
 end
 ```
 
-You can mix and match traditional and poniard styles. Some actions can be
+Traditional and poniard styles can be used together. Some actions can be
 implemented in the normal controller, others can be provided by an injectable
 one.
 
@@ -74,8 +74,8 @@ end
 ### Sources
 
 Poniard knows about all the standard controller objects such as `response`,
-`session` and `flash`. You then layer your own domain specific definitions on
-top by creating **sources**:
+`session` and `flash`. Domain specific definitions are then layered on top by
+creating **sources**:
 
 ```ruby
 class Source
@@ -91,7 +91,7 @@ class Source
 end
 ```
 
-Wire this up in the `provided_by` call:
+This is wired up in the `provided_by` call:
 
 ```ruby
 provided_by Controller::Registration, sources: [
@@ -99,8 +99,8 @@ provided_by Controller::Registration, sources: [
 ]
 ```
 
-You can specify as many sources as you like, making it easy to reuse logic
-across controllers.
+Any number of sources can be used, making it easy to reuse logic across
+controllers.
 
 Testing
 -------
@@ -139,40 +139,23 @@ Techniques
 
 ### Built-in sources
 
-Undocumented, but it is a pretty straight-forward mapping to Rails objects with
-the exception of `response`. The code is in `lib/poniard/controller_source.rb`.
+See the [YARD docs][yard] for all the built in controller sources.
+
+[yard]: http://rubydoc.info/github/xaviershay/poniard/master/Poniard/ControllerSource/
 
 ### Layouts
 
-If you implement a `layout` method in your controller, it will be used to
-select a layout for the controller. This is equivalent to adding a custom
-`layout` method to a standard controller.
+If a `layout` method is implemented in a controller, it will be used to select
+a layout for the controller. This is equivalent to adding a custom `layout`
+method to a standard controller.
 
 ### Mime types
 
-The Rails `respond_with` API is not very OO, so is hard to test in isolation.
-Poniard provides a wrapper that allows you to provide a response object that is
-much easier to work with.
-
-```ruby
-module Controller
-  class Registration
-    def index(response, finder)
-      response.respond_with RegistrationsIndexResponse, finder.all
-    end
+The Rails `respond_to` API is not very Object-Oriented, so is hard to test in
+isolation. Poniard provides an alternative [`respond_with`][respond-with] that
+allows you to provide a response object, which is much easier to work with.
 
-    RegistrationsIndexResponse = Struct.new(:registrations) do
-      def html(response)
-        response.default registrations: registrations
-      end
-
-      def json(response)
-        response.render json: registrations.to_json
-      end
-    end
-  end
-end
-```
+[respond-with]: http://rubydoc.info/github/xaviershay/poniard/master/Poniard/ControllerSource/Response.html#respond_with-instance_method
 
 ### Authorization
 
@@ -182,19 +165,19 @@ can then be handled in a standard manner using `rescue_from`.
 ```ruby
 module Source
   class Admin
-    def current_organiser(session)
-      Organiser.find_by_id(session[:organiser_id])
+    def current_admin(session)
+      User.find_by_id(session[:admin_id])
     end
 
-    def authorized_organiser(current_organiser)
-      current_organiser || raise(ResponseException::Unauthorized)
+    def authorized_admin(current_admin)
+      current_admin || raise(ResponseException::Unauthorized)
     end
   end
 end
 ```
 
-This can be slightly weird if the method you are authorizing does not actually
-need to interact with the organiser, since it will have a method parameter that
+This can be slightly weird if the method being authorized does not actually
+need to interact with the admin, since it will have a method parameter that
 is never used.
 
 ```ruby
@@ -209,7 +192,7 @@ def instance_method(name)
 end
 
 it 'requires authorization' do
-  instance_method(:index).should have_param(:authorized_organiser)
+  instance_method(:index).should have_param(:authorized_admin)
 end
 ```
 
@@ -218,15 +201,12 @@ Developing
 
 ### Status
 
-Experimental. I've backported an existing app, added minor new features, and it
-was a pleasant experience. It needs a lot more usage before the API stabilizes,
-or it is even proved to be useful.
+Not widely used. May be some obvious things missing from built-in controller
+sources that you will have to add.
 
 ### Compatibility
 
-Requires 1.9, should be easy to backport to 1.8 if anyone is interested. Use
-1.9 style hashes and probably relies on `methods` calls returning symbols
-rather than strings.
+Requires 1.9 or above.
 
 ### Support
 

data/lib/poniard/controller.rb

@@ -1,17 +1,30 @@
 module Poniard
+  # Mixing this module into a Rails controller provides the poniard DSL to that
+  # controller. To enable poniard on all controllers, mix this in to
+  # `ApplicationController`.
   module Controller
+    # @private
     def self.included(klass)
       klass.extend(ClassMethods)
     end
 
+    # Call the given method via the poniard injector. A `ControllerSource` is
+    # provided as default, along with any sources passed to `provided_by`.
     def inject(method)
       injector = Injector.new [
         ControllerSource.new(self)
       ] + self.class.sources.map(&:new)
-      injector.dispatch self.class.provided_by.new.method(method)
+      injector.eager_dispatch self.class.provided_by.new.method(method)
     end
 
+    # Class methods that are automatically added when `Controller` is included.
     module ClassMethods
+      # For every non-inherited public instance method on the given class,
+      # generates a method of the same name that calls it via the injector.
+      #
+      # If a `layout` method is present on the class, it is given special
+      # treatment and set up so that it will be called using the Rails `layout`
+      # DSL method.
       def provided_by(klass = nil, opts = {})
         if klass
           methods = klass.public_instance_methods(false)
@@ -43,6 +56,10 @@ module Poniard
         end
       end
 
+      # An array of sources to be used for all injected methods on the host
+      # class. This is typically specified using the `sources` option to
+      # `provided_by`, however you can override it for more complicated dynamic
+      # behaviour.
       def sources
         @sources
       end

data/lib/poniard/controller_source.rb

@@ -1,26 +1,74 @@
 module Poniard
+  # Poniard source providing access to Rails controller features. It is always
+  # available to poniard controllers added using
+  # {Poniard::Controller::ClassMethods#provided_by}.
   class ControllerSource
-    Response = Struct.new(:controller, :injector) do
+    # A wrapper around the Rails response that provides a more OO-friendly
+    # interface, specifically designed with isolated unit testing in mind.
+    #
+    # This class should not be explictly constructed by users. It is provided
+    # in the response parameter provided by {ControllerSource}.
+    class Response
+      # @private
+      attr_reader :controller, :injector
+
+      # @private
+      def initialize(controller, injector)
+        @controller = controller
+        @injector = injector
+      end
+
+      # Calls the given route method with arguments, then redirects to the
+      # result. +_path+ is automatically appended so does not need to be
+      # included in the path. +_url+ suffixes are handled correctly, in that
+      # they are used as is without adding a +_path+ suffix. That is a little
+      # magic, justified by +_path+ being what you want 90% of the time.
+      #
+      # If +path+ is a string, redirect to it as is without calling any route
+      # helpers.
+      #
+      # @example
+      #     def index(response)
+      #       response.redirect_to :user, 1 # user_path(1)
+      #     end
       def redirect_to(path, *args)
-        unless path.to_s.ends_with?('_url')
-          path = "#{path}_path"
+        case path
+        when Symbol
+          unless path.to_s.ends_with?('_url')
+            path = "#{path}_path"
+          end
+
+          controller.redirect_to(controller.send(path, *args))
+        else
+          controller.redirect_to path, *args
         end
-
-        controller.redirect_to(controller.send(path, *args))
       end
 
+      # Redirect to the given action on the current controller.
       def redirect_to_action(action)
         controller.redirect_to action: action
       end
 
+      # Render the view associated with given action with the given instance
+      # variables.
+      #
+      # @param action[Symbol/String] name of the action
+      # @param ivars[Hash] instance variables to be set for view rendering
       def render_action(action, ivars = {})
         render action: action, ivars: ivars
       end
 
+      # Delegates directly to {ActionController::Head#head}.
       def head(*args)
         controller.head *args
       end
 
+      # Delegates to `ActionController::Base#render`, with two exceptions if
+      # the last argument is a hash:
+      #
+      # * +ivars+ is deleted from the hash and used to set instance variables
+      #   that can then be accessed by any templates.
+      # * +headers+ is deleted from the hash and used to set response headers.
       def render(*args)
         opts = args.last
         if opts.is_a?(Hash)
@@ -41,43 +89,91 @@ module Poniard
         controller.render *args
       end
 
+      # Renders default template for the current action. Equivalent to not call
+      # any `render` method in a normal Rails controller. Unlike Rails, poniard
+      # does not support empty method bodies.
+      #
+      # @param ivars[Hash] instance variables to be set for view rendering
       def default(ivars = {})
         ivars.each do |name, val|
           controller.instance_variable_set("@#{name}", val)
         end
       end
 
+      # Object-oriented replacement for
+      # {ActionController::MimeResponds#respond_to} method. The given class is
+      # instantiated with the remaining arguments, and is expected to implement
+      # a method named after each format it supports. The methods are called
+      # via the injector.
+      #
+      # If the requested format is not implemented, a 406 "Not Acceptable"
+      # response is returned.
+      #
+      # @example
+      #     class MyController
+      #       IndexResponse = Struct.new(:results) do
+      #         def html(response)
+      #           response.default results: results
+      #         end
+      #
+      #         def json(response)
+      #           response.render json: results
+      #         end
+      #       end
+      #
+      #       def index(response)
+      #         response.respond_with IndexResponse, Things.all
+      #       end
+      #     end
       def respond_with(klass, *args)
         obj = klass.new(*args)
         format = controller.request.format.symbol
         if obj.respond_to?(format)
           injector.dispatch obj.method(format)
+        else
+          head(406) # Not acceptable
         end
       end
 
+      # Delegates directly to {ActionController::DataStreaming#send_data}.
       def send_data(*args)
         controller.send_data(*args)
       end
     end
 
+    # @private
     def initialize(controller)
       @controller = controller
     end
 
+    # Provides direct access to +request+.
     def request;   @controller.request; end
+
+    # Provides direct access to +params+.
     def params;    @controller.params; end
+
+    # Provides direct access to +session+.
     def session;   @controller.session; end
+
+    # Provides direct access to +flash+.
     def flash;     @controller.flash; end
+
+    # Provides access to +flash.now+. It is useful, particularly when testing,
+    # to treat this as a completely separate concept from +flash+.
     def now_flash; @controller.flash.now; end
 
+    # Provides access to +render+ and friends abstracted behind {Response a
+    # nice OO interface}.
     def response(injector)
       Response.new(@controller, injector)
     end
 
+    # Provides direct access to +Rails.env+.
     def env
       Rails.env
     end
 
+    # Provides direct access to +Rails.application.config+.
     def app_config
       Rails.application.config
     end

data/lib/poniard/injector.rb

@@ -1,52 +1,113 @@
-require 'ostruct'
-
 module Poniard
+  # A parameter pased dependency injector. Figures out which arguments to call
+  # a method with based on the names of method's parameters. Multiple sources
+  # can be provided to lookup parameter values. They are checked in reverse
+  # order.
+  #
+  # The injector itself is always available to methods via the +injector+
+  # parameter.
+  #
+  # @example
+  #     def my_method(printer)
+  #       printer.("hello!")
+  #     end
+  #
+  #     Injector.new([{
+  #       printer: ->(msg) { puts msg }
+  #     }]).dispatch(method(:my_method))
   class Injector
     attr_reader :sources
 
     def initialize(sources = [])
       @sources = sources.map {|source|
         if source.is_a? Hash
-          OpenStruct.new(source)
+          HashSource.new(source)
         else
-          source
+          ObjectSource.new(self, source)
         end
-      }+ [self]
+      } + [HashSource.new(injector: self)]
     end
 
+    # Call the given method with arguments. If a parameter is not provided by
+    # any source, an {UnknownInjectable} instance is passed instead.
     def dispatch(method, overrides = {})
+      dispatch_method(method, UnknownInjectable.method(:new), overrides)
+    end
+
+    # Same as {#dispatch}, except it raises an exception immediately if any
+    # parameter is not provided by sources.
+    def eager_dispatch(method, overrides = {})
+      dispatch_method(method, ->(name) {
+        ::Kernel.raise UnknownParam, name
+      }, overrides)
+    end
+
+    private
+
+    def dispatch_method(method, unknown_param_f, overrides = {})
       args = method.parameters.map {|_, name|
         source = sources_for(overrides).detect {|source|
-          source.respond_to?(name)
+          source.provides?(name)
         }
 
         if source
-          dispatch(source.method(name), overrides)
+          source.dispatch(name, overrides)
         else
-          UnknownInjectable.new(name)
+          unknown_param_f.(name)
         end
       }
       method.(*args)
     end
 
-    def injector
-      self
+    def sources_for(overrides)
+      [HashSource.new(overrides)] + sources
     end
+  end
 
-    private
+  # @private
+  class HashSource
+    def initialize(hash)
+      @hash = hash
+    end
 
-    def sources_for(overrides)
-      [OpenStruct.new(overrides)] + sources
+    def provides?(name)
+      @hash.has_key?(name)
+    end
+
+    def dispatch(name, _)
+      @hash.fetch(name)
+    end
+  end
+
+  # @private
+  class ObjectSource
+    def initialize(injector, object)
+      @injector = injector
+      @object   = object
+    end
+
+    def provides?(name)
+      @object.respond_to?(name)
+    end
+
+    def dispatch(name, overrides)
+      @injector.dispatch(@object.method(name), overrides)
     end
   end
 
+  # Raised by {Injector#eager_dispatch} if a parameter is not provided by any
+  # sources.
   class UnknownParam < RuntimeError; end
 
+  # An object that will raise an exception if any method is called on it. This
+  # is particularly useful in testing so that you only need to inject the
+  # parameters that should actually be called during the test.
   class UnknownInjectable < BasicObject
     def initialize(name)
       @name = name
     end
 
+    # @private
     def method_missing(*args)
       ::Kernel.raise UnknownParam,
         "Tried to call method on an uninjected param: #{@name}"

data/lib/poniard/version.rb

@@ -1,3 +1,5 @@
+# Top-level namespace for Poniard. See +README.md+ for library description.
 module Poniard
-  VERSION = '0.0.3'
+  # Current version of Poniard, in semantic versioning format.
+  VERSION = '1.0.0'
 end

data/poniard.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '>= 1.9.0'
   gem.files         = Dir.glob("{spec,lib}/**/*.rb") + %w(
                         README.md
-                        HISTORY.md
+                        CHANGELOG.md
                         LICENSE
                         poniard.gemspec
                       )
@@ -24,5 +24,4 @@ Gem::Specification.new do |gem|
   gem.version       = Poniard::VERSION
   gem.has_rdoc      = false
   gem.add_development_dependency 'rspec', '~> 2.11'
-  gem.add_development_dependency 'rake'
 end

data/spec/controller_source_spec.rb

@@ -0,0 +1,294 @@
+require 'integration_helper'
+
+describe Poniard::ControllerSource, type: :controller do
+  describe 'Response' do
+    context '#default' do
+      render_views
+
+      poniard_controller do
+        def index(response)
+          response.default message: "implicit"
+        end
+      end
+
+      it 'renders template matching method name with instance variables' do
+        get :index
+        expect(response.body).to match(/Message: implicit/)
+      end
+    end
+
+    context '#render' do
+      render_views
+
+      poniard_controller do
+        def index(response)
+          response.render action: 'index',
+            headers: {'Content-Type' => 'text/plain'},
+            ivars: {message: 'explicit'}
+        end
+      end
+
+      it 'renders explicit template with instance variables' do
+        get :index
+        expect(response.body).to match(/Message: explicit/)
+      end
+
+      it 'can set headers' do
+        get :index
+        expect(response.headers['Content-Type']).to eq('text/plain')
+      end
+    end
+
+    context '#render_action' do
+      render_views
+
+      poniard_controller do
+        def index(response)
+          response.render_action 'index', message: 'explicit'
+        end
+      end
+
+      it 'renders explicit template with instance variables' do
+        get :index
+        expect(response.body).to match(/Message: explicit/)
+      end
+    end
+
+    describe '#head' do
+      poniard_controller do
+        def index(response)
+          response.head 422
+        end
+      end
+
+      it 'sets response code' do
+        get :index
+        expect(response.status).to eq(422)
+      end
+    end
+
+    describe '#redirect_to' do
+      # See fake admin_* route methods in integration_helper.rb
+
+      context 'path' do
+        poniard_controller do
+          def index(response)
+            response.redirect_to :admin, :secret
+          end
+        end
+
+        it 'redirects' do
+          get :index
+          expect(response).to redirect_to("/admin/secret")
+        end
+      end
+
+      context 'url' do
+        poniard_controller do
+          def index(response)
+            response.redirect_to :admin_url, :secret
+          end
+        end
+
+        it 'redirects' do
+          get :index
+          expect(response).to redirect_to("http://foo/admin/secret")
+        end
+      end
+
+      context 'arbitrary' do
+        poniard_controller do
+          def index(response)
+            response.redirect_to '/some_path'
+          end
+        end
+
+        it 'redirects' do
+          get :index
+          expect(response).to redirect_to("/some_path")
+        end
+      end
+    end
+
+    context '#redirect_to_action' do
+      poniard_controller do
+        def index(response)
+          response.redirect_to_action :new
+        end
+
+        def new
+        end
+      end
+
+      it 'redirects' do
+        pending "Not sure correct rspec-rails scaffolding to make this work"
+        get :index
+        expect(response).to redirect_to(:new)
+      end
+    end
+
+    describe '#send_data' do
+      poniard_controller do
+        def index(response)
+          response.send_data "data", type: "text/plain"
+        end
+      end
+
+      it 'sends body' do
+        get :index
+        expect(response.body).to eq("data")
+      end
+
+      it 'sets headers' do
+        get :index
+        expect(response.headers['Content-Type']).to eq("text/plain")
+      end
+    end
+
+    describe '#respond_with' do
+      render_views
+
+      poniard_controller do
+        def index(response)
+          responder = Class.new do
+            def initialize(body)
+              @body = body
+            end
+
+            def html(response); response.render text: "<b>#{@body}</b>" end
+            def text(response); response.render text: @body end
+          end
+
+          response.respond_with responder, "body"
+        end
+      end
+
+      it 'responds with html' do
+        get :index
+        expect(response.body).to eq("<b>body</b>")
+      end
+
+      it 'responds with text' do
+        get :index, format: :text
+        expect(response.body).to eq("body")
+      end
+
+      it 'handles unknown format' do
+        get :index, format: :json
+        expect(response.status).to eq(406)
+      end
+    end
+  end
+
+  context 'request source' do
+    poniard_controller do
+      def index(response, request)
+        response.render text: request.path
+      end
+    end
+
+    it 'provides access to raw rails request' do
+      get :index
+      expect(response.body).to eq("/anonymous")
+    end
+  end
+
+  context 'params source' do
+    poniard_controller do
+      def index(response, params)
+        response.render text: params[:q]
+      end
+    end
+
+    it 'provides access to raw rails params' do
+      get :index, q: 'query'
+      expect(response.body).to eq("query")
+    end
+  end
+
+  context 'session source' do
+    poniard_controller do
+      def index(response, session)
+        response.render text: session[:user_id]
+      end
+    end
+
+    it 'provides access to raw rails session' do
+      get :index, {}, {user_id: '1'}
+      expect(response.body).to eq("1")
+    end
+  end
+
+  context 'flash source' do
+    poniard_controller do
+      def index(response, flash)
+        flash[:message] = "FLASH"
+        response.render text: ""
+      end
+    end
+
+    it 'provides access to raw rails flash' do
+      get :index
+      expect(flash[:message]).to eq("FLASH")
+    end
+  end
+
+  context 'flash now source' do
+    poniard_controller do
+      def index(response, now_flash)
+        now_flash[:message] = "FLASH"
+        response.render text: ""
+      end
+    end
+
+    it 'provides access to raw rails flash' do
+      get :index
+      expect(flash[:message]).to eq("FLASH")
+    end
+  end
+
+  context 'env source' do
+    poniard_controller do
+      def index(response, env)
+        response.render text: env
+      end
+    end
+
+    it 'provides access to current environment' do
+      get :index
+      expect(response.body).to eq("test")
+    end
+  end
+
+  context 'config source' do
+    poniard_controller do
+      def index(response, app_config)
+        response.render text: app_config.secret_token
+      end
+    end
+
+    it 'provides access to current config' do
+      get :index
+      expect(response.body).to eq(PoniardApp.config.secret_token)
+    end
+  end
+
+  context 'with layout' do
+    render_views
+
+    poniard_controller do
+      def layout
+        'admin'
+      end
+
+      def index(response, app_config)
+        response.render text: "secret", layout: true
+      end
+    end
+
+    it 'uses the provided layout' do
+      get :index
+      expect(response.body).to match(/ADMIN: secret/)
+    end
+  end
+end

data/spec/injector_spec.rb

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 require 'poniard/injector'
 
 describe Poniard::Injector do
@@ -66,6 +68,13 @@ describe Poniard::Injector do
     called.should == injector
   end
 
+  it 'allows nil values in hash sources' do
+    value = nil
+    injector = described_class.new
+    injector.dispatch ->(x) { value = x.nil? }, x: nil
+    value.should == true
+  end
+
   it 'yields a fail object when source is unknown' do
     called = false
     m = ->(unknown) {
@@ -80,4 +89,13 @@ describe Poniard::Injector do
     described_class.new.dispatch(m)
     called.should be_true
   end
+
+  describe '#eager_dispatch' do
+    it 'raises when source is unknown' do
+      m = ->(unknown) {}
+      expect {
+        described_class.new.eager_dispatch(m)
+      }.to raise_error(Poniard::UnknownParam, "unknown")
+    end
+  end
 end

data/spec/integration_helper.rb

@@ -0,0 +1,44 @@
+ENV['RAILS_ENV'] = 'test'
+
+require 'spec_helper'
+
+require 'action_controller/railtie'
+require 'rspec/rails'
+
+require 'poniard'
+
+Rails.backtrace_cleaner.remove_silencers!
+class PoniardApp < Rails::Application
+  config.secret_token = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+  config.session_store :cookie_store, :key => '_myproject_session'
+  config.active_support.deprecation = :log
+  config.eager_load = false
+  config.root = File.dirname(__FILE__)
+end
+PoniardApp.initialize!
+
+class ApplicationController < ActionController::Base
+  before_filter :prepend_view_paths
+
+  def prepend_view_paths
+    prepend_view_path File.expand_path("../views", __FILE__)
+  end
+
+  def admin_path(page)
+    "/admin/#{page}"
+  end
+
+  def admin_url(page)
+    "http://foo/admin/#{page}"
+  end
+end
+
+RSpec.configure do |config|
+  def poniard_controller(&block)
+    controller(ApplicationController) do
+      include Poniard::Controller
+
+      provided_by(Class.new(&block))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'simplecov'
+
+SimpleCov.start

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: poniard
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Xavier Shay
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-20 00:00:00.000000000 Z
+date: 2014-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.11'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 description: A dependency injector for Rails, allows you to write clean controllers.
 email:
 - contact@xaviershay.com
@@ -45,16 +31,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- spec/injector_spec.rb
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/poniard.rb
 - lib/poniard/controller.rb
 - lib/poniard/controller_source.rb
 - lib/poniard/injector.rb
 - lib/poniard/version.rb
-- lib/poniard.rb
-- README.md
-- HISTORY.md
-- LICENSE
 - poniard.gemspec
+- spec/controller_source_spec.rb
+- spec/injector_spec.rb
+- spec/integration_helper.rb
+- spec/spec_helper.rb
 homepage: http://github.com/xaviershay/poniard
 licenses: []
 metadata: {}
@@ -64,20 +53,23 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A dependency injector for Rails, allows you to write clean controllers.
 test_files:
+- spec/controller_source_spec.rb
 - spec/injector_spec.rb
+- spec/integration_helper.rb
+- spec/spec_helper.rb
 has_rdoc: false

data/HISTORY.md

@@ -1,15 +0,0 @@
-# Poniard History
-
-## 0.0.3 - 19 March 2014
-
-* Support `head` responses.
-
-## 0.0.2 - 26 January 2013
-
-* Hashes can be used directly as sources.
-* Provide default argument for `response.default`.
-
-## 0.0.1 - 25 November 2012
-
-* Initial release.
-