pakada-dispatch 0.2.3 → 0.3.0

data/lib/pakada/dispatch.rb

@@ -4,6 +4,7 @@ require "pakada"
 
 require "pakada/dispatch/controller"
 require "pakada/dispatch/module"
+require "pakada/dispatch/rendering_context"
 require "pakada/dispatch/version"
 
 class Pakada::Dispatch
@@ -13,12 +14,6 @@ class Pakada::Dispatch
   
   def initialize
     @router = HttpRouter.new
-    Pakada.safety(Controller).extend Hooked
-    Pakada.safety(Controller).around(:included) {|inner, klass|
-      klass.send :include, Hooked
-      klass.extend Hooked
-      inner.call klass
-    }
   end
   
   def hooks
@@ -27,10 +22,24 @@ class Pakada::Dispatch
   
   def boot
     Pakada.modules.each_value {|mod|
-      mod.extend Pakada.safety(::Pakada::Dispatch::Module)
+      mod.extend Pakada.safety(Pakada::Dispatch::Module)
       mod.load_controllers
       mod.routes if mod.respond_to? :routes
     }
+    
+    if Pakada[:render]
+      context = Pakada.safety(Pakada::Render::RenderingContext)
+      extension = Pakada.safety(Pakada::Dispatch::RenderingContext)
+      context.send :include, extension
+    end
+  end
+  
+  def create_controller(&block)
+    Class.new {
+      include Pakada.safety(Pakada::Dispatch::Controller)
+      include Hooked
+      class_eval &block if block
+    }
   end
   
   def request(env)

data/lib/pakada/dispatch/controller.rb

@@ -8,37 +8,57 @@ class Pakada
         klass.extend Pakada.safety(self::ClassMethods)
       end
       
-      def self.create(&block)
-        Class.new.tap {|cls|
-          cls.send :include, self
-          cls.class_eval &block
-        }
-      end
-      
       attr_reader :options, :params, :request, :response
       
-      def initialize(env, options = {}, &block)
+      def initialize(env, options = {})
         @request = Rack::Request.new(env)
         @response = options[:response] || Rack::Response.new
-        
-        @options, @params = options, request.env["router.params"]
-        (request.env["pakada.controllers"] ||= []) << self
-        
-        catch(:finish) { instance_eval &block }
+        @options, @params = options, request.env["router.params"].dup
+      end
+      
+      def process(&block)
+        instance_eval &block
+        self
       end
       
       def finish!
         throw :finish
       end
       
-      def actions
-        self.class.actions
+      def not_found
+        response.status = 404
+      end
+      
+      def not_found!
+        not_found
+        finish!
+      end
+      
+      def access_denied
+        response.status = 403
+      end
+      
+      def access_denied!
+        access_denied
+        finish!
+      end
+      
+      def json(data)
+        options[:render] = false
+        options[:layout] = false
+        response.headers["Content-Type"] = "application/json"
+        response.write data.to_json
+      end
+      
+      def json!(data)
+        json data
+        finish!
       end
       
       def action(name, options = {})
-        aecktschn = self.class.action(name)
         options[:response] ||= response
-        proc { aecktschn.call request.env, options }
+        aecktschn = self.class.action(name, options)
+        proc { aecktschn.call request.env }
       end
       
       module ClassMethods
@@ -48,24 +68,39 @@ class Pakada
         
         def action(name, options = {}, &block)
           if block
-            actions[name] = proc {|env, *args|
-              opts = (args[0] || {}).merge(:action => name)
-              action = self.new(env, options.merge(opts), &block)
-              action.response.finish unless opts[:response]
+            actions[name] = {
+              :block => block,
+              :options => options
+            }
+          else
+            unless action = actions[name]
+              raise ArgumentError, "Unknown action: #{name}"
+            end
+            
+            options = self.options.dup.tap {|opts|
+              opts.merge! action[:options]
+              opts.merge! options
+              opts.merge! :action => name
+            }
+            
+            proc {|env|
+              self.new(env, options).process(&action[:block]).response.finish
             }
           end
-          actions[name]
+        end
+        
+        def options(opts = {})
+          (@options ||= {}).tap {|o| o.merge! opts }
         end
         
         def to_proc
           method(:call).to_proc
         end
         
-        def call(env, options = {})
+        def call(env)
           env["router.params"] ||= {}
-          name = env["router.params"][:action] ||
-                 env["REQUEST_METHOD"].downcase
-          action(name.to_sym).call env, options
+          name = env["router.params"][:action] || env["REQUEST_METHOD"].downcase
+          action(name.to_sym).call env
         end
       end
     end

data/lib/pakada/dispatch/module.rb

@@ -13,11 +13,9 @@ class Pakada
       
       def controller(name, &block)
         if block
-          controllers[name] = Pakada.safety(Controller).create(&block).tap {|c|
-            c.before(:new) {|env, *args|
-              options = args[0] || {}
-              options.merge! :module => pakada_name, :controller => name
-            }
+          controllers[name] = Pakada[:dispatch].create_controller(&block).tap {|c|
+            c.options[:controller] = name
+            c.options[:module] = pakada_name
           }
         else
           controllers[name]

data/lib/pakada/dispatch/rendering_context.rb

@@ -0,0 +1,7 @@
+class Pakada::Dispatch
+  module RenderingContext
+    def url(route, params = {})
+      Pakada[:dispatch].router.url route, params
+    end
+  end
+end

data/lib/pakada/dispatch/version.rb

@@ -1,5 +1,5 @@
 class Pakada
   class Dispatch
-    VERSION = "0.2.3"
+    VERSION = "0.3.0"
   end
 end

data/pakada-dispatch.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rspec"
   s.add_development_dependency "yard"
   s.add_development_dependency "rdiscount"
+  s.add_development_dependency "pakada-render"
 
   s.files         = `git ls-files`.split("\n") - [".gitignore", "config.ru"]
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/controller_spec.rb

@@ -3,10 +3,11 @@ require "spec_helper"
 describe Pakada::Dispatch::Controller do
   let(:block) { proc {} }
   let(:ctrlr_mod) { Pakada.safety Pakada::Dispatch::Controller }
-  let(:ctrlr) { ctrlr_mod.create &block }
+  let(:ctrlr) { Pakada[:dispatch].create_controller &block }
   let(:ctrlr_obj) { ctrlr.new env, options, &block }
-  let(:env) { {"router.params" => stub("router params")} }
-  let(:options) { {:response => stub("response")} }
+  let(:env) { {"router.params" => {}} }
+  let(:options) { {} }
+  let(:response) { ctrlr_obj.response }
   
   context ".included hook" do
     it "extends the includer class with ClassMethods" do
@@ -15,23 +16,13 @@ describe Pakada::Dispatch::Controller do
     end
   end
   
-  context ".create(name) { ... }" do
-    let(:klass) { stub "class" }
-    
-    before { Class.stub :new => klass }
-    
-    it "includes itself into a new class and calls the block in its context" do
-      klass.should_receive(:include).with ctrlr_mod
-      klass.should_receive(:class_eval) {|&blk| block.should equal(blk) }
-      
-      ctrlr
-    end
-  end
-  
   context "#initialize(env, options) { ... }" do
+    let(:options) { {:response => stub("response")} }
+    
     it "sets the options and routing params objects" do
       ctrlr_obj.options.should equal(options)
-      ctrlr_obj.params.should equal(env["router.params"])
+      ctrlr_obj.params.should == env["router.params"]
+      ctrlr_obj.params.should_not equal(env["router.params"])
     end
     
     it "sets the request and response objects" do
@@ -45,56 +36,99 @@ describe Pakada::Dispatch::Controller do
       ctrlr_obj.response.status.should equal(200)
       ctrlr_obj.response.should_not equal(old_response)
     end
-    
-    it "adds itself to env[pakada.controllers]" do
-      ctrlr_obj
-      env["pakada.controllers"].should == [ctrlr_obj]
+  end
+  
+  context "#finish!" do
+    it "throws :finish" do
+      proc { ctrlr_obj.finish! }.should throw_symbol(:finish)
     end
+  end
+  
+  context "#process { ... }" do
+    let(:block) { proc {} }
     
-    let(:ctrlr_alloc) { ctrlr.allocate }
-    
-    it "instance_evals the passed block, catching :finish" do
-      ctrlr_alloc.should_receive(:instance_eval) {|&blk|
-        blk.should equal(block)
-        throw :catch
+    it "instance_evals the passed block" do
+      ctrlr_obj.should_receive(:instance_eval) {|&blk|
+        block.should equal(blk)
       }
-      proc {
-        ctrlr_alloc.send :initialize, env, &block
-      }.should throw_symbol(:catch)
+      ctrlr_obj.process &block
+    end
+    
+    it "returns the controller object" do
+      ctrlr_obj.process(&block).should equal(ctrlr_obj)
     end
   end
   
-  context "#finish!" do
-    it "throws :finish" do
-      proc { ctrlr_obj.finish! }.should throw_symbol(:finish)
+  context "#not_found" do
+    it "sets a 404 status" do
+      ctrlr_obj.not_found
+      response.status.should equal(404)
+    end
+  end
+  
+  context "#not_found!" do
+    it "sets a 404 status and finishes" do
+      ctrlr_obj.should_receive :not_found
+      ctrlr_obj.should_receive :finish!
+      ctrlr_obj.not_found!
+    end
+  end
+  
+  context "#access_denied" do
+    it "sets a 403 status" do
+      ctrlr_obj.access_denied
+      response.status.should equal(403)
+    end
+  end
+  
+  context "#access_denied!" do
+    it "sets a 403 status and finishes" do
+      ctrlr_obj.should_receive :access_denied
+      ctrlr_obj.should_receive :finish!
+      ctrlr_obj.access_denied!
+    end
+  end
+  
+  context "#json" do
+    let(:data) { stub "data", :to_json => stub("json_data") }
+    
+    it "sets a JSON response" do
+      response.should_receive(:write).with data.to_json
+      ctrlr_obj.json data
+      response.headers["Content-Type"].should == "application/json"
     end
   end
   
-  context "#actions" do
-    let(:actions) { stub "action" }
+  context "#json!" do
+    let(:data) { stub "data" }
     
-    it "forwards to .actions" do
-      ctrlr.should_receive(:actions) { actions }
-      ctrlr_obj.actions.should equal(actions)
+    it "sets a JSON response and finishes" do
+      ctrlr_obj.should_receive(:json).with data
+      ctrlr_obj.should_receive :finish!
+      ctrlr_obj.json! data
     end
   end
   
   context "#action(name, options = {})" do
+    let(:actions) { {:foo => stub("foo action")} }
+    
     before {
-      ctrlr_obj.actions[:foo] = stub("action")
+      ctrlr.stub(:action) {|name, *| actions[name] }
     }
     
     it "forwards to .action" do
-      ctrlr.action(:foo).should_receive(:call) {|env, opts|
+      actions[:foo].should_receive(:call) {|env|
         env.should equal(ctrlr_obj.request.env)
       }
       ctrlr_obj.action(:foo).call
     end
     
     it "passes the response in options" do
-      ctrlr.action(:foo).should_receive(:call) {|env, opts|
-        opts.should == options
+      ctrlr.should_receive(:action) {|name, opts|
+        opts[:response].should equal(ctrlr_obj.response)
+        actions[:foo]
       }
+      actions[:foo].should_receive(:call)
       ctrlr_obj.action(:foo).call
     end
   end
@@ -106,54 +140,104 @@ describe Pakada::Dispatch::Controller do
     end
   end
   
-  context ".action(name)" do
-    let(:action) { stub "action" }
-    before { ctrlr.actions[:foo] = action }
+  context ".action(name, options = {}) { ... }" do
+    let(:block) { proc {} }
+    let(:options) { {:key => :value} }
     
-    it "returns the specified action" do
-      ctrlr.action(:foo).should equal(action)
+    it "stores the block and options" do
+      ctrlr.action :foo, options, &block
+      ctrlr.actions[:foo].should == {
+        :options => options,
+        :block => block
+      }
+    end
+    
+    it "defaults options to an empty Hash" do
+      ctrlr.action :foo, &block
+      ctrlr.actions[:foo][:options].tap {|opts|
+        opts.should be_a(Hash)
+        opts.should be_empty
+      }
     end
   end
   
-  context ".action(name, options = {}) { ... }" do
-    let(:options) { {:foo => stub("foo option")} }
-    let(:override_options) { {:bar => stub("bar option")} }
-    let(:merged_options) { options.merge override_options }
-    let(:env) { stub "env" }
-    let(:ctrlr_obj) { stub "controller object", :response => response }
-    let(:response) { stub "response", :finish => stub("finished response") }
+  context ".action(name, options = {})" do
+    let(:controller_options) {
+      {
+        :key1 => stub("value1 from controller"),
+        :key2 => stub("value2 from controller")
+      }
+    }
+    let(:action_options) {
+      {
+        :key2 => stub("value2 from action"),
+        :key3 => stub("value3 from action")
+      }
+    }
+    let(:call_options) {
+      {
+        :key3 => stub("value3 from call")
+      }
+    }
+    let(:merged_options) {
+      {
+        :key1 => controller_options[:key1],
+        :key2 => action_options[:key2],
+        :key3 => call_options[:key3],
+        :action => :foo
+      }
+    }
     
     before {
-      ctrlr.action :foo, options, &block
-      ctrlr.stub :new => ctrlr_obj
+      ctrlr.stub :options => controller_options
+      ctrlr.action(:foo, action_options, &block)
+      ctrlr_obj
     }
     
-    it "creates an action proc" do
-      ctrlr.action(:foo).should respond_to(:call)
+    it "merges controller, action and call options" do
+      ctrlr.should_receive(:new) {|env, options|
+        options.should == merged_options
+        ctrlr_obj
+      }
+      ctrlr.action(:foo, call_options).call env
     end
     
-    it "'s proc creates a controller object passing env, options and block" do
-      ctrlr.should_receive(:new) {|e, opts, &blk|
-        e.should equal(env)
-        opts.values_at(*merged_options.keys).should == merged_options.values
-        blk.should equal(block)
+    it "adds the action's name to options" do
+      ctrlr.should_receive(:new) {|env, options|
+        options[:action].should equal(:foo)
+        ctrlr_obj
       }
-      ctrlr.action(:foo).call env, override_options
+      ctrlr.action(:foo).call env
     end
     
-    it "'s proc returns the finished response" do
-      ctrlr.action(:foo).call(env).should equal(response.finish)
+    it "raises an ArgumentError if the specified action doesn't exist" do
+      proc { ctrlr.action(:i_dont_exist) }.should raise_error(ArgumentError)
     end
     
-    it "'s proc adds the action's name to the options hash" do
-      ctrlr.should_receive(:new) {|e, opts|
-        opts[:action].should equal(:foo)
+    context "returns a proc that" do
+      let(:finished_response) { stub "response" }
+      
+      before {
+        ctrlr.stub :new => ctrlr_obj
+        ctrlr_obj.response.stub :finish => finished_response
       }
-      ctrlr.action(:foo).call env
-    end
-    
-    it "'s proc returns nothing if a response gets passed in via options" do
-      ctrlr.action(:foo).call(env, :response => response).should be_nil
+      
+      it "creates a new controller object" do
+        ctrlr.should_receive(:new).with(env, merged_options)
+        ctrlr.action(:foo, call_options).call env
+      end
+      
+      it "processes the action" do
+        ctrlr_obj.should_receive(:process) {|&blk|
+          block.should equal(blk)
+          ctrlr_obj
+        }
+        ctrlr.action(:foo).call env
+      end
+      
+      it "returns the finished response" do
+        ctrlr.action(:foo).call(env).should equal(finished_response)
+      end
     end
   end
   
@@ -176,14 +260,19 @@ describe Pakada::Dispatch::Controller do
         "REQUEST_METHOD" => "bar"
       }
     }
+    let(:actions) {
+      {
+        :foo => stub("foo action"),
+        :bar => stub("bar action")
+      }
+    }
     
     before {
-      ctrlr.action(:foo) {}
-      ctrlr.action(:bar) {}
+      ctrlr.stub(:action) {|name| actions[name] }
     }
     
     it "sets default routing params" do
-      ctrlr.action(:bar).should_receive(:call) {|e, opts|
+      actions[:bar].should_receive(:call) {|e, opts|
         e["router.params"].should == {}
       }
       
@@ -192,12 +281,12 @@ describe Pakada::Dispatch::Controller do
     end
     
     it "calls the action from routing params by default" do
-      ctrlr.action(:foo).should_receive :call
+      actions[:foo].should_receive :call
       ctrlr.call env
     end
     
     it "calls the REQUEST_METHOD action as fallback" do
-      ctrlr.action(:bar).should_receive :call
+      actions[:bar].should_receive :call
       
       env.delete "router.params"
       ctrlr.call env

data/spec/dispatch_spec.rb

@@ -1,9 +1,10 @@
 require "spec_helper"
 
 describe Pakada::Dispatch do
-  let(:dispatch) { Pakada::Dispatch.new }
+  let(:dispatch) { Pakada[:dispatch] }
   
   context "#initialize" do
+    let(:dispatch) { Pakada::Dispatch.new }
     let(:router) { stub "router" }
     
     before {
@@ -13,22 +14,6 @@ describe Pakada::Dispatch do
     it "sets the router" do
       dispatch.router.should equal(router)
     end
-    
-    let(:controller) { Pakada.safety(Pakada::Dispatch::Controller) }
-    let(:klass) { stub "controller klass" }
-    let(:inner) { stub "proc", :call => nil }
-    
-    it "makes Controller and controllers hookable" do
-      controller.should_receive(:around) {|method, &block|
-        method.should equal(:included)
-        
-        klass.should_receive(:extend).with Hooked
-        klass.should_receive(:include).with Hooked
-        block.call inner, klass
-      }
-      dispatch
-      controller.method :hooked
-    end
   end
   
   context "#hooks" do
@@ -54,11 +39,8 @@ describe Pakada::Dispatch do
     }
     
     before {
-      Pakada.instance.stub :modules => {
-        :dispatch => dispatch,
-        :module1 => module1,
-        :module2 => module2
-      }
+      Pakada.modules[:module1] = module1
+      Pakada.modules[:module2] = module2
       module1.stub :routes
     }
     
@@ -80,5 +62,27 @@ describe Pakada::Dispatch do
       module1.should_receive :routes
       dispatch.boot
     end
+    
+    let(:context) { Pakada.safety(Pakada::Render::RenderingContext).new }
+    
+    it "extends Pakada::Render::RenderingContext" do
+      dispatch.boot
+      context.should respond_to(:url)
+    end
+  end
+  
+  context "#create_controller { ... }" do
+    it "creates a fresh controller class" do
+      dispatch.create_controller.tap {|cls|
+        controller = Pakada.safety(Pakada::Dispatch::Controller)
+        cls.included_modules.should include(controller, Hooked)
+      }
+    end
+    
+    it "executes the block within the class' scope" do
+      dispatch.create_controller {
+        @foo = :foo
+      }.instance_variable_get(:@foo).should equal(:foo)
+    end
   end
 end

data/spec/module_spec.rb

@@ -32,7 +32,7 @@ describe Pakada::Dispatch::Module do
   
   context "#controller(name) { ... }" do
     let(:block) { proc {} }
-    let(:controller) { stub "controller", :before => nil }
+    let(:controller) { stub "controller", :options => {} }
     let(:dispatch) { Pakada::Dispatch.new }
     
     before {
@@ -40,28 +40,21 @@ describe Pakada::Dispatch::Module do
     }
     
     it "creates a controller class from the given block" do
-      Pakada.safety(Pakada::Dispatch::Controller) \
-        .should_receive(:create) {|&blk|
-          blk.should equal(block)
-          controller
-        }
+      dispatch.should_receive(:create_controller) {|&blk|
+        blk.should equal(block)
+        controller
+      }
       
       mod.controller :bar, &block
       mod.controllers[:bar].should equal(controller)
     end
     
-    let(:options) { {} }
-    
-    it "hooks the controller class' .new method to add module and controller name to options" do
-      Pakada.safety(Pakada::Dispatch::Controller) \
-        .should_receive(:create) { controller }
-      controller.should_receive(:before) {|method, &blk|
-        method.should equal(:new)
-        blk.call nil, options
+    it "sets :module and :controller options" do
+      mod.controller :bar, &block
+      mod.controllers[:bar].options.tap {|options|
         options[:module].should equal(:foo)
         options[:controller].should equal(:bar)
       }
-      mod.controller(:bar) {}
     end
   end
   

data/spec/rendering_context_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Pakada::Dispatch::RenderingContext do
+  let(:context) {
+    Object.new.tap {|o| o.extend Pakada::Dispatch::RenderingContext }
+  }
+  
+  context "#url(route, params)" do
+    let(:params) { stub "params" }
+    let(:url) { stub "url" }
+    
+    it "forwards to router.url" do
+      Pakada[:dispatch].router.should_receive(:url) {|route, prms|
+        route.should equal(:foo)
+        prms.should equal(params)
+        url
+      }
+      context.url(:foo, params).should equal(url)
+    end
+    
+    it "defaults params to an empty Hash" do
+      Pakada[:dispatch].router.should_receive(:url) {|route, params|
+        params.should be_a(Hash)
+        params.should be_empty
+      }
+      context.url :foo
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ begin
 rescue LoadError; end
 
 require "pakada/dispatch"
+require "pakada/render"
 
 RSpec.configure {|config|
   config.before {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pakada-dispatch
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-06 00:00:00.000000000Z
+date: 2011-09-11 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pakada
-  requirement: &85649150 !ruby/object:Gem::Requirement
+  requirement: &78613870 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *85649150
+  version_requirements: *78613870
 - !ruby/object:Gem::Dependency
   name: http_router
-  requirement: &85648750 !ruby/object:Gem::Requirement
+  requirement: &78613560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *85648750
+  version_requirements: *78613560
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &85648260 !ruby/object:Gem::Requirement
+  requirement: &78613140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *85648260
+  version_requirements: *78613140
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &85647280 !ruby/object:Gem::Requirement
+  requirement: &78612570 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *85647280
+  version_requirements: *78612570
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &85646720 !ruby/object:Gem::Requirement
+  requirement: &78612140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *85646720
+  version_requirements: *78612140
 - !ruby/object:Gem::Dependency
   name: rdiscount
-  requirement: &85646210 !ruby/object:Gem::Requirement
+  requirement: &78587120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *85646210
+  version_requirements: *78587120
+- !ruby/object:Gem::Dependency
+  name: pakada-render
+  requirement: &78586770 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *78586770
 description: 
 email:
 - lars.gierth@gmail.com
@@ -95,12 +106,14 @@ files:
 - lib/pakada/dispatch.rb
 - lib/pakada/dispatch/controller.rb
 - lib/pakada/dispatch/module.rb
+- lib/pakada/dispatch/rendering_context.rb
 - lib/pakada/dispatch/version.rb
 - pakada-dispatch.gemspec
 - spec/controller_spec.rb
 - spec/controllers/foo.rb
 - spec/dispatch_spec.rb
 - spec/module_spec.rb
+- spec/rendering_context_spec.rb
 - spec/spec_helper.rb
 homepage: https://rubygems.org/gems/pakada-dispatch
 licenses: []