poniard 0.0.1 → 0.0.2

data/HISTORY.md

@@ -1,5 +1,10 @@
 # Poniard History
 
+## 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
+* Initial release.

data/README.md

@@ -24,13 +24,15 @@ normally deal with in Rails (`session`, `flash`, etc...).
 The following controller renders the default index template, setting the
 instance variables `@message`.
 
-    module Controller
-      class Registration
-        def index(response)
-          response.default message: "hello"
-        end
-      end
+```ruby
+module Controller
+  class Registration
+    def index(response)
+      response.default message: "hello"
     end
+  end
+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
@@ -40,30 +42,34 @@ 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
 controller definition.
 
-    class RegistrationsController < ApplicationController
-      include Poniard::Controller
+```ruby
+class RegistrationsController < ApplicationController
+  include Poniard::Controller
 
-      provided_by Controller::Registration
-    end
+  provided_by Controller::Registration
+end
+```
 
 You can mix and match traditional and poniard styles. Some actions can be
 implemented in the normal controller, others can be provided by an injectable
 one.
 
-    class RegistrationsController < ApplicationController
-      include Poniard::Controller
+```ruby
+class RegistrationsController < ApplicationController
+  include Poniard::Controller
 
-      # index action provided by this class
-      provided_by Controller::Registration
+  # index action provided by this class
+  provided_by Controller::Registration
 
-      # All controller features work in harmony with poniard, such as this
-      before_filter :require_user
+  # All controller features work in harmony with poniard, such as this
+  before_filter :require_user
 
-      # update action implemented normally
-      def update
-        # ...
-      end
-    end
+  # update action implemented normally
+  def update
+    # ...
+  end
+end
+```
 
 ### Sources
 
@@ -71,23 +77,27 @@ 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**:
 
-    class Source
-      class Registration
-        def finder
-          Registration.accepted
-        end
+```ruby
+class Source
+  class Registration
+    def finder
+      Registration.accepted
+    end
 
-        def current_registration
-          Registration.find(params[:id])
-        end
-      end
+    def current_registration
+      Registration.find(params[:id])
     end
+  end
+end
+```
 
 Wire this up in the `provided_by` call:
 
-    provided_by Controller::Registration, sources: [
-      Source::Registration
-    ]
+```ruby
+provided_by Controller::Registration, sources: [
+  Source::Registration
+]
+```
 
 You can specify as many sources as you like, making it easy to reuse logic
 across controllers.
@@ -99,28 +109,30 @@ Set up a common injector for the scope of your controller that knows about
 common sources that all tests require (such as `response`). Add extra required
 sources on a per test basis (`finder` in the below example).
 
-    require 'poniard/injector'
-    require 'controller/registration'
+```ruby
+require 'poniard/injector'
+require 'controller/registration'
 
-    describe Controller::Registration do
-      let(:response) { double("Poniard::ControllerSource") }
-      let(:injector) { Poniard::Injector.new([OpenStruct.new(
-        response: response.as_null_object
-      )]) }
+describe Controller::Registration do
+  let(:response) { double("Poniard::ControllerSource") }
+  let(:injector) { Poniard::Injector.new([
+    response: response.as_null_object
+  ]) }
 
-      def dispatch(action, overrides = {})
-        injector.dispatch described_class.new.method(action), overrides
-      end
+  def dispatch(action, overrides = {})
+    injector.dispatch described_class.new.method(action), overrides
+  end
 
-      describe '#index' do
-        it 'should render default action with all registrations' do
-          finder = double(all: ['r1'])
-          response.should_receive(:default).with(registrations: ['r1'])
+  describe '#index' do
+    it 'should render default action with all registrations' do
+      finder = double(all: ['r1'])
+      response.should_receive(:default).with(registrations: ['r1'])
 
-          dispatch :index, finder: finder
-        end
-      end
+      dispatch :index, finder: finder
     end
+  end
+end
+```
 
 Techniques
 ----------
@@ -142,58 +154,64 @@ 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.
 
-    module Controller
-      class Registration
-        def index(response, finder)
-          response.respond_with RegistrationsIndexResponse, finder.all
-        end
-
-        RegistrationsIndexResponse = Struct.new(:registrations) do
-          def html(response)
-            response.default registrations: registrations
-          end
-
-          def json(response)
-            response.render json: registrations.to_json
-          end
-        end
+```ruby
+module Controller
+  class Registration
+    def index(response, finder)
+      response.respond_with RegistrationsIndexResponse, finder.all
+    end
+
+    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
+```
 
 ### Authorization
 
 Poniard sources can raise exceptions to indicate authorization failure, which
 can then be handled in a standard manner using `rescue_from`.
 
-    module Source
-      class Admin
-        def current_organiser(session)
-          Organiser.find_by_id(session[:organiser_id])
-        end
+```ruby
+module Source
+  class Admin
+    def current_organiser(session)
+      Organiser.find_by_id(session[:organiser_id])
+    end
 
-        def authorized_organiser(current_organiser)
-          current_organiser || raise(ResponseException::Unauthorized)
-        end
-      end
+    def authorized_organiser(current_organiser)
+      current_organiser || 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
 is never used.
 
-    RSpec::Matchers.define :have_param do |attribute|
-      match do |obj|
-        obj.parameters.map(&:last).include?(attribute)
-      end
-    end
+```ruby
+RSpec::Matchers.define :have_param do |attribute|
+  match do |obj|
+    obj.parameters.map(&:last).include?(attribute)
+  end
+end
 
-    def instance_method(name)
-      described_class.new.method(name)
-    end
+def instance_method(name)
+  described_class.new.method(name)
+end
 
-    it 'requires authorization' do
-      instance_method(:index).should have_param(:authorized_organiser)
-    end
+it 'requires authorization' do
+  instance_method(:index).should have_param(:authorized_organiser)
+end
+```
 
 Developing
 ----------
@@ -210,11 +228,11 @@ 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.
 
-## Support
+### Support
 
 Make a [new github issue](https://github.com/xaviershay/poniard/issues/new).
 
-## Contributing
+### Contributing
 
 Fork and patch! Please update the README and other documentation if you add
 features.

data/lib/poniard/controller_source.rb

@@ -37,7 +37,7 @@ module Poniard
         controller.render *args
       end
 
-      def default(ivars)
+      def default(ivars = {})
         ivars.each do |name, val|
           controller.instance_variable_set("@#{name}", val)
         end

data/lib/poniard/injector.rb

@@ -4,28 +4,40 @@ module Poniard
   class Injector
     attr_reader :sources
 
-    def initialize(sources)
-      @sources = sources + [self]
+    def initialize(sources = [])
+      @sources = sources.map {|source|
+        if source.is_a? Hash
+          OpenStruct.new(source)
+        else
+          source
+        end
+      }+ [self]
     end
 
     def dispatch(method, overrides = {})
       args = method.parameters.map {|_, name|
-        source = (
-          [OpenStruct.new(overrides)] +
-          sources
-        ).detect {|source| source.respond_to?(name) }
+        source = sources_for(overrides).detect {|source|
+          source.respond_to?(name)
+        }
+
         if source
           dispatch(source.method(name), overrides)
         else
           UnknownInjectable.new(name)
         end
       }
-      method.call(*args)
+      method.(*args)
     end
 
     def injector
       self
     end
+
+    private
+
+    def sources_for(overrides)
+      [OpenStruct.new(overrides)] + sources
+    end
   end
 
   class UnknownParam < RuntimeError; end

data/lib/poniard/version.rb

@@ -1,3 +1,3 @@
 module Poniard
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/injector_spec.rb

@@ -1,15 +1,83 @@
 require 'poniard/injector'
 
 describe Poniard::Injector do
+  let(:thing) { Object.new }
+
+  it 'calls a lambda' do
+    called = false
+    described_class.new([]).dispatch -> { called = true }
+    called.should == true
+  end
+
+  it 'calls a method' do
+    object = Class.new do
+      def a_number
+        12345
+      end
+    end.new
+
+    described_class.new([]).dispatch(object.method(:a_number)).should == 12345
+  end
+
+  it 'calls a method with a parameter provided by a source' do
+    called = false
+    described_class.new([
+      thing: thing
+    ]).dispatch ->(thing) { called = thing }
+    called.should == thing
+  end
+
+  it 'recursively injects sources' do
+    two_source = Class.new do
+      def two_things(thing)
+        [thing, thing]
+      end
+    end.new
+
+    called = false
+    described_class.new([
+      {thing: thing},
+      two_source
+    ]).dispatch ->(two_things) { called = two_things }
+    called.should == [thing, thing]
+  end
+
+  it 'uses the first source that provides a parameter' do
+    called = false
+    described_class.new([
+      {thing: thing},
+      {thing: nil}
+    ]).dispatch ->(thing) { called = thing }
+    called.should == thing
+  end
+
+  it 'allows sources to be overriden at dispatch' do
+    called = false
+    described_class.new([
+      {thing: nil}
+    ]).dispatch ->(thing) { called = thing }, thing: thing
+    called.should == thing
+  end
+
+  it 'provides itself as a source' do
+    called = false
+    injector = described_class.new
+    injector.dispatch ->(injector) { called = injector }
+    called.should == injector
+  end
+
   it 'yields a fail object when source is unknown' do
     called = false
     m = ->(unknown) {
       ->{
         unknown.bogus
-      }.should raise_error(Poniard::UnknownParam)
+      }.should raise_error(
+        Poniard::UnknownParam,
+        "Tried to call method on an uninjected param: unknown"
+      )
       called = true
     }
-    Poniard::Injector.new([]).dispatch(m)
+    described_class.new.dispatch(m)
     called.should be_true
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: poniard
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-25 00:00:00.000000000 Z
+date: 2013-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec