pakada-dispatch 0.1.1 → 0.2.0

data/.yardopts

@@ -0,0 +1 @@
+- LICENSE

data/Gemfile

@@ -1,6 +1,9 @@
-source "http://rubygems.org"
+source :rubygems
 
 gemspec
 
 gem "rake"
 gem "awesome_print"
+
+gem "thin"
+gem "shotgun"

data/README.md

@@ -1,4 +1,7 @@
 Routing And Action Controllers For Pakada
 ===================================================
 
-TODO: Write documentation
+TODO
+----
+
+- Write documentation

data/lib/pakada/dispatch.rb

@@ -1,8 +1,6 @@
+require "http_router"
 require "pakada"
-require "rack/mount"
-require "yajl"
 
-require "pakada/dispatch/util"
 require "pakada/dispatch/controller"
 require "pakada/dispatch/module"
 require "pakada/dispatch/version"
@@ -13,35 +11,18 @@ class Pakada::Dispatch
   attr_reader :router
   
   def initialize
-    @router = Rack::Mount::RouteSet.new
+    @router = HttpRouter.new
   end
   
-  def boot
-    apply_patches
-    load_module_controllers
-    set_app
-    freeze_router
-  end
-  
-  def apply_patches
-    Pakada.modules.each_value do |m|
-      m.singleton_class.send :include, Module
-    end
-  end
-  
-  def load_module_controllers
-    Pakada.modules.each_value {|m| m.load_controllers }
+  def hooks
+    Pakada.instance.instead_of :request, @router.method(:call)
   end
   
-  def set_app
-    Pakada.app = proc {|env| request env }
-  end
-  
-  def freeze_router
-    router.rehash
-  end
-  
-  def request(env)
-    router.call env
+  def boot
+    Pakada.modules.each_value {|mod|
+      mod.extend Pakada.safety(::Pakada::Dispatch::Module)
+      mod.load_controllers
+      mod.routes if mod.respond_to? :routes
+    }
   end
 end

data/lib/pakada/dispatch/controller.rb

@@ -1,169 +1,59 @@
+require "rack/request"
+require "rack/response"
+
 class Pakada
   class Dispatch
-    Action = Struct.new :name, :block, :options
-    
-    METHODS = [:get, :head, :post, :put, :delete]
-    
-    NOT_FOUND_ENDPOINT = proc do |env|
-      [404, {"X-Cascade" => "pass"}, ["Not Found"]]
-    end
-    METHOD_NOT_ALLOWED_ENDPOINT = proc do |methods|
-      proc do |env|
-        allow = methods.map {|m| m.to_s.upcase }.join(", ")
-        [405, {"Allow" => allow}, ["Method Not Allowed"]]
-      end
-    end
-    
     module Controller
-      include Util
-
-      def self.build(&block)
-        Class.new do
-          include Controller
-          class_eval &block if block
-        end
+      def self.included(klass)
+        klass.extend Pakada.safety(self::ClassMethods)
       end
       
-      attr_reader :request, :response, :params, :options
-      
-      def initialize(env)
-        @request, @response = Rack::Request.new(env), Rack::Response.new
-        @params = request.env["pakada.dispatch.params"] || {}
+      def self.create(&block)
+        Class.new.tap {|cls|
+          cls.send :include, self
+          cls.class_eval &block
+        }
       end
       
-      def call_action(name, options = {})
-        method = (request.request_method || "GET").downcase.to_sym
-        action = self.class.actions.find do |a|
-          a.name == name && (
-            a.options[:methods] == :all || a.options[:methods].include?(method))
-        end
-        raise ArgumentError, "No such action - #{name} (#{method})" unless action
+      attr_reader :options, :params, :request, :response
+      
+      def initialize(env, options = {})
+        @request = Rack::Request.new(env)
+        @response = options[:response] || Rack::Response.new
         
-        @options = action.options.merge options
-        catch(:finish) { instance_eval &action.block }
+        @options, @params = options, env["router.params"]
       end
       
       def finish!
         throw :finish
       end
       
-      def json(obj)
-        response.headers["Content-Type"] = "application/json"
-        response.write obj.respond_to?(:to_json) ? obj.to_json : Yajl::Encoder.encode(obj)
-        finish!
-      end
-      
-      def redirect(*args)
-        response.status = (Fixnum === args[0]) ? args.shift : 303
-
-        if Symbol === args[0]
-          url = url(*args)
-        elsif args[0].respond_to? :to_url
-          url = args[0].to_url
-        elsif args[0]
-          url = args[0]
-        else
-          raise ArgumentError, "Controller#redirect needs a URL"
-        end
-          
-        response.headers["Location"] = url
-        finish!
-      end
-      
-      def forbidden(format = nil)
-        response.status = 403
-        if format == :json
-          response.headers["Content-Type"] = "application/json"
-          response.write Yajl::Encoder.encode({
-            :status => {
-              :code => 403,
-              :message => "Forbidden"
-            }
-          })
-        else
-          response.write "403 Forbidden"
-        end
-        finish!
-      end
-      
-      def not_found(format = nil)
-        response.status = 404
-        if format == :json
-          response.headers["Content-Type"] = "application/json"
-          response.write Yajl::Encoder.encode({
-            :status => {
-              :code => 404,
-              :message => "Not Found"
-            }
-          })
-        else
-          response.write "404 Not Found"
-        end
-        finish!
-      end
-      
       module ClassMethods
         def actions
-          @actions ||= []
+          @actions ||= {}
         end
         
         def action(name, options = {}, &block)
           if block
-            options[:methods] ||= :all
-            unless options[:methods].respond_to?(:each) || options[:methods] == :all
-              options[:methods] = [options[:methods]]
-            end
-            actions << Action.new(name, block, options)
-            return
-          end
-          
-          matches = actions.select {|a| a.name == name }
-          return NOT_FOUND_ENDPOINT if matches.empty?
-          
-          proc do |env|
-            method = (env["REQUEST_METHOD"] || "GET").downcase.to_sym
-            allowed = matches.select do |a|
-              a.options[:methods] == :all || a.options[:methods].include?(method)
-            end
-            
-            if allowed.empty?
-              allow = matches.inject([]) {|m, a| m.push(*a.options[:methods]); m }
-              METHOD_NOT_ALLOWED_ENDPOINT.call(allow).call(env)
-            else
-              controller = new env
-              controller.call_action allowed.first.name, options
-              controller.response.finish
-            end
+            actions[name] = proc {|env, opts = {}|
+              c = self.new(env, options.merge(opts))
+              catch(:finish) { c.instance_eval &block }
+              c.response.finish
+            }
           end
-          
-          # elsif actions[name]
-          #   proc do |env|
-          #     method = env["REQUEST_METHOD"]
-          #     allowed = actions[name].options[:methods]
-          #     if method && allowed != :all && !allowed.include?(method.downcase.to_sym)
-          #       [405, {"Allow" => allowed.map {|m| m.to_s.upcase }.join(", ")}, ["Method Not Allowed"]]
-          #     else
-          #       controller = new env
-          #       controller.call_action name, options
-          #       controller.response.finish
-          #     end
-          #   end
-          # else
-          #   proc {|env| [404, {"X-Cascade" => "pass"}, []] }
-          # end
+          actions[name]
         end
         
-        METHODS.each do |m|
-          eval <<-R, nil, __FILE__, __LINE__
-            def #{m}(name, options = {}, &block)
-              action(name, options.merge(:methods => :#{m}), &block)
-            end
-          R
+        def to_proc
+          method(:call).to_proc
+        end
+        
+        def call(env)
+          env["router.params"] ||= {}
+          name = env["router.params"][:action] ||
+                 env["REQUEST_METHOD"].downcase
+          action(name.to_sym).call env
         end
-      end
-      
-      def self.included(klass)
-        klass.extend ClassMethods
       end
     end
   end

data/lib/pakada/dispatch/module.rb

@@ -1,67 +1,38 @@
+require "pathname"
+
 class Pakada
   class Dispatch
     module Module
-      include Util
+      def controller_path
+        # TODO change this when Pakada uses Pathname for module paths
+        #@controller_path ||= path.join("controllers")
+        @controller_path ||= Pathname.new(path).join("controllers")
+      end
       
-      attr_reader :controllers
+      def controllers
+        @controllers ||= {}
+      end
+      
+      def controller(name, &block)
+        if block
+          controllers[name] = Pakada.safety(Controller).create(&block)
+        else
+          controllers[name]
+        end
+      end
       
       def load_controllers
-        @controllers = {}
-        Dir["#{path}/controllers/*.rb"].each do |file|
-          next unless file.match %r{.*/[a-z0-9_]+\.rb$}
-          name = file.split("/").last.split(".").first
-          @controllers[name.to_sym] = Controller.build do
-            class_eval File.read(file), file, 1
-          end
-        end if path
+        controller_path.each_entry {|path|
+          path = controller_path.join(path)
+          next unless path.file?
+          controller(path.basename(".rb").to_s.to_sym) {
+            class_eval File.read(path), path.to_s, 1
+          }
+        } if controller_path.exist?
       end
       
-      def route(name = nil, opts)
-        route = opts.keys.find {|k| !k.kind_of? Symbol }
-        target = opts.delete route
-        splats = []
-        unless route.is_a? Regexp
-          route = route.gsub(/\((.*)\)/, '(\1)?')
-            .gsub(/:([a-z0-9\-_]+)/, '(?<\1>[a-z0-9\-_]+)')
-            .gsub(/\*([a-z0-9\-_]+)/) do |match|
-              splats << $1.to_sym
-              '(?<' + $1 + '>([a-z0-9\-_]/?)*)'
-            end
-          route = Regexp.compile "^#{route}$"
-        end
-        
-        defaults = opts.dup
-        target = "::" + target unless target.include? "::"
-        target = target + "#" unless target.include? "#"
-        parts = target.split /::|#/
-        defaults[:module] = parts[0].to_sym unless !parts[0] || parts[0].empty?
-        defaults[:controller] = parts[1].to_sym unless !parts[1] || parts[1].empty?
-        defaults[:action] = parts[2].to_sym unless !parts[2] || parts[2].empty?
-        
-        app = proc do |env|
-          env["pakada.dispatch.route"] = name
-          params = env["pakada.dispatch.params"] = env["rack.routing_args"].dup
-          
-          params.each_pair do |key, value|
-            if splats.include? key
-              params[key] = value.split("/").select {|v| !v.empty? }
-            end
-            if [:module, :controller, :action].include? key
-              params[key] = value.to_sym
-            end
-          end
-          
-          mod = Pakada[params[:module]]
-          controller = mod.controllers[params[:controller].to_sym] if mod
-          if controller
-            controller.action(params[:action]).call(env)
-          else
-            [404, {"X-Cascade" => "pass"}, []]
-          end
-        end
-        
-        defaults[:module] = module_name unless defaults[:module]
-        Pakada[:dispatch].router.add_route app, {:path_info => route}, defaults, name
+      def route(name, pattern, &block)
+        Pakada[:dispatch].router.add(pattern).name(name).to &block
       end
     end
   end

data/lib/pakada/dispatch/version.rb

@@ -1,5 +1,5 @@
 class Pakada
   class Dispatch
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

data/pakada-dispatch.gemspec

@@ -12,14 +12,14 @@ Gem::Specification.new do |s|
   s.summary     = %q{Routing And Action Controllers For Pakada}
   #s.description = %q{TODO: Write a gem description}
 
-  s.add_dependency "pakada", "~> 0.2"
-  s.add_dependency "rack-mount"
-  s.add_dependency "yajl-ruby"
+  s.add_dependency "pakada"
+  s.add_dependency "http_router"
   
   s.add_development_dependency "rspec"
-  s.add_development_dependency "fakefs"
+  s.add_development_dependency "yard"
+  s.add_development_dependency "rdiscount"
 
-  s.files         = `git ls-files`.split("\n") - [".gitignore", ".rvmrc"]
+  s.files         = `git ls-files`.split("\n") - [".gitignore", "config.ru"]
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]

data/spec/controller_spec.rb

@@ -1,366 +1,151 @@
 require "spec_helper"
 
 describe Pakada::Dispatch::Controller do
-  describe ".build" do
-    it "builds an empty controller class" do
-      subject.build.should respond_to(:action)
-      subject.build.should have(0).actions
-    end
-    
-    describe "when called with a block" do
-      it "executes the block in the class' context" do
-        subject.build { action(:foo) {} }.should have(1).actions
-      end
-    end
-  end
-end
-
-describe "SomeController" do
-  subject do
-    Pakada::Dispatch::Controller.build
-  end
-  
-  describe ".action" do
-    describe "when called with a block" do
-      it "adds an action to the controller" do
-        block = proc {}
-        subject.action :foo, &block
-        subject.actions.find {|a| a.name == :foo }.block.should == block
-      end
-      
-      describe "and twice with the same name" do
-        it "adds a second action with the same name" do
-          2.times { subject.action :foo, &proc {} }
-          subject.should have(2).actions
-        end
-      end
-    end
-    
-    describe "when called with a block and a hash" do
-      it "adds an action with options" do
-        block = proc {}
-        subject.action :foo, {}, &block
-        subject.actions.find {|a| a.name == :foo }.options.should respond_to(:[])
-      end
-      
-      it "defaults the :methods option to :all" do
-        subject.action :foo, &proc {}
-        subject.actions.find {|a| a.name == :foo }.options[:methods].should == :all
-        
-        subject.actions.clear
-        subject.action :foo, {:methods => :get}, &proc {}
-        subject.actions.find {|a| a.name == :foo }.options[:methods].should == [:get]
-      end
-    end
-    
-    describe "when called without a block" do
-      it "builds a Rack end-point" do
-        subject.action(:foo) {}
-        
-        env = {"foo" => "123"}
-        options = {:key => :value}
-        response = stub "response", :finish => [200, {}, []]
-        controller = stub "controller", :response => response
-        
-        subject.should_receive(:new).twice.with(env) { controller }
-        
-        controller.should_receive(:call_action).once.with(:foo, {})
-        subject.action(:foo).call(env).should == response.finish
-        
-        controller.should_receive(:call_action).once.with(:foo, options)
-        subject.action(:foo, options).call(env)
-      end
-      
-      describe "and with the name of a non-existing action" do
-        it "returns a 404 end-point" do
-          subject.action(:foo).call({}).should == [
-            404, {"X-Cascade" => "pass"}, ["Not Found"]
-          ]
-        end
-      end
-      
-      it "checks if the :methods constraint matches" do
-        subject.action :foo, :methods => [:get, :head], &proc {}
-        subject.action(:foo).call("REQUEST_METHOD" => "POST").should == [
-          405, {"Allow" => "GET, HEAD"}, ["Method Not Allowed"]
-        ]
-        subject.action(:foo).call("REQUEST_METHOD" => "GET")[0].should == 200
-        subject.action(:foo).call({})[0].should == 200
-        
-        subject.action :foo, :methods => :all, &proc {}
-        subject.action(:foo).call("REQUEST_METHOD" => "PUT")[0].should == 200
-      end
-      
-      it "tries the next equal-named action if the constraint doesn't match" do
-        subject.action(:foo, :methods => :get) { not_found }
-        subject.action(:foo) {}
-        subject.action(:foo).call("REQUEST_METHOD" => "POST")[0].should == 200
-      end
-    end
-  end
+  let(:block) { proc {} }
+  let(:ctrlr_mod) { Pakada.safety Pakada::Dispatch::Controller }
+  let(:ctrlr) { ctrlr_mod.create &block }
   
-  Pakada::Dispatch::METHODS.each do |m|
-    describe ".#{m}" do
-      it "forwards to .action(:#{m}, ...)" do
-        subject.should_receive(:action).with(:foo, :methods => m)
-        subject.send(m, :foo, &proc {})
-      end
+  context ".included hook" do
+    it "extends the includer class with ClassMethods" do
+      mod = Pakada.safety(Pakada::Dispatch::Controller::ClassMethods)
+      ctrlr.singleton_class.included_modules.should include(mod)
     end
   end
   
-  describe "#initialize" do
-    it "sets up Rack::Request and Response objects" do
-      env = {"foo" => "123"}
-      controller = subject.new env
-      
-      controller.request.env.should == env
-      controller.response.should respond_to(:finish)
-    end
+  context ".create(name) { ... }" do
+    let(:klass) { stub "class" }
+    
+    before { Class.stub :new => klass }
     
-    it "populates #params with the routing parameters" do
-      params = {:foo => :bar}
-      controller = subject.new "pakada.dispatch.params" => params
-      controller.params.should == params
+    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) }
       
-      controller = subject.new({})
-      controller.params.should == {}
+      ctrlr
     end
   end
   
-  describe "#call_action" do
-    it "invokes the action's block in the controller's scope" do
-      subject.action(:foo) { do_something }
-      controller = subject.new({})
-      controller.should_receive :do_something
-      
-      controller.call_action :foo
-    end
+  context "#initialize(env, options)" do
+    let(:env) { {"router.params" => stub("router params")} }
+    let(:options) { {:response => stub("response")} }
+    let(:ctrlr_obj) { ctrlr.new env, options }
     
-    it "populates #options" do
-      subject.action(:foo, :key => :value) {}
-      controller = subject.new({})
-      
-      controller.call_action :foo
-      controller.options[:key].should == :value
+    it "sets the options and routing params objects" do
+      ctrlr_obj.options.should equal(options)
+      ctrlr_obj.params.should equal(env["router.params"])
     end
     
-    describe "when called with the name of a non-existing action" do
-      it "raises an error" do
-        controller = subject.new({})
-        proc { controller.call_action :foo }.should raise_error(ArgumentError)
-      end
+    it "sets the request and response objects" do
+      ctrlr_obj.request.env.should equal(env)
+      ctrlr_obj.response.should equal(options[:response])
     end
     
-    describe "when called with a hash" do
-      it "overrides the action's options" do
-        subject.action(:foo, :key => :value) {}
-        controller = subject.new({})
-        
-        controller.call_action :foo, :key => :value2
-        controller.options[:key].should == :value2
-      end
+    it "defaults to an empty response object" do
+      old_response = options.delete :response
+      ctrlr_obj.response.status.should equal(200)
+      ctrlr_obj.response.should_not equal(old_response)
     end
   end
   
-  describe "#finish!" do
-    it "immediately finishes the action's execution" do
-      finishing = nil
-      subject.action :foo do
-        finishing = :now
-        finish!
-        finishing = :nooot
-      end
-      
-      subject.new({}).call_action :foo
-      finishing.should == :now
+  context "#finish!" do
+    it "throws :finish" do
+      proc { ctrlr.new({}).finish! }.should throw_symbol(:finish)
     end
   end
   
-  describe "#redirect" do
-    describe "when called with a URL string" do
-      it "redirects to the URL and finishes" do
-        controller = subject.new({})
-        controller.should_receive :finish!
-        controller.redirect "/something"
-        
-        controller.response.headers["Location"].should == "/something"
-      end
+  context ".actions" do
+    it "is an empty Hash" do
+      ctrlr.actions.should be_an(Hash)
+      ctrlr.actions.should be_empty
     end
+  end
+  
+  context ".action(name, options) { ... }" do
+    let(:block) { proc {} }
+    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") }
     
-    describe "when called with an object that responds to #to_url" do
-      it "redirects to the URL returned by #to_url and finishes" do
-        controller = subject.new({})
-        controller.should_receive :finish!
-        controller.redirect stub("object", :to_url => "/something")
-        
-        controller.response.headers["Location"].should == "/something"
-      end
-    end
+    before {
+      ctrlr.action :foo, options, &block
+      ctrlr.stub :new => ctrlr_obj
+    }
     
-    describe "when called with a route name and (optionally) a hash" do
-      it "redirects to the URL generated by Util#url and finishes" do
-        controller = subject.new({})
-        controller.should_receive :finish!
-        controller.should_receive(:url).with(:myroute, :key => "value") { "/something" }
-        controller.redirect :myroute, :key => "value"
-        
-        controller.response.headers["Location"].should == "/something"
-      end
+    it "creates an action proc" do
+      ctrlr.action(:foo).should respond_to(:call)
     end
     
-    it "accepts an HTTP status code" do
-      controller = subject.new({})
-      controller.stub :finish!
-      controller.redirect 302, "/"
-      
-      controller.response.status.should == 302
+    it "'s proc creates a controller object passing env and options" do
+      ctrlr.should_receive(:new).with(env, merged_options) { ctrlr_obj }
+      ctrlr.action(:foo).call env, override_options
     end
     
-    it "uses 303 See Other as the default HTTP status code" do
-      controller = subject.new({})
-      controller.stub :finish!
-      controller.redirect "/"
-      
-      controller.response.status.should == 303
+    it "'s proc instance_evals the action proc catching :finish" do
+      ctrlr_obj.should_receive(:instance_eval) {|&blk| block.should equal(blk) }
+      ctrlr.action(:foo).call env
     end
     
-    it "raises an ArgumentError if the arguments don't include a URL" do
-      controller = subject.new({})
-      
-      proc { controller.redirect }.should raise_error(ArgumentError)
-      proc { controller.redirect 303 }.should raise_error(ArgumentError)
+    it "'s proc returns the finished response" do
+      ctrlr.action(:foo).call(env).should equal(response.finish)
     end
   end
   
-  describe "#not_found" do
-    it "sets a 404 status code, writes a message and finishes" do
-      subject.action(:foo) { not_found }
-      controller = subject.new({})
-      
-      controller.should_receive :finish!
-      controller.call_action :foo
-      
-      controller.response.status.should == 404
-      controller.response.body.join.should == "404 Not Found"
-    end
+  context ".action(name)" do
+    let(:action) { stub "action" }
+    before { ctrlr.actions[:foo] = action }
     
-    describe "when called with :json as argument" do
-      it "writes the message in JSON format" do
-        subject.action(:foo) { not_found :json }
-        controller = subject.new({})
-        controller.call_action :foo
-        
-        controller.response.headers["Content-Type"].should == "application/json"
-        Yajl::Parser.parse(controller.response.body.join).should == {
-          "status" => {
-            "code" => 404,
-            "message" => "Not Found"
-          }
-        }
-      end
+    it "returns the specified action" do
+      ctrlr.action(:foo).should equal(action)
     end
   end
   
-  describe "#forbidden" do
-    it "sets a 403 status code, writes a message and finishes" do
-      subject.action(:foo) { forbidden }
-      controller = subject.new({})
-      
-      controller.should_receive :finish!
-      controller.call_action :foo
-      
-      controller.response.status.should == 403
-      controller.response.body.join.should == "403 Forbidden"
-    end
+  context ".to_proc" do
+    let(:env) { stub "env" }
+    let(:response) { stub "response" }
     
-    describe "when called with :json as argument" do
-      it "writes the message in JSON format" do
-        subject.action(:foo) { forbidden :json }
-        controller = subject.new({})
-        controller.call_action :foo
-        
-        controller.response.headers["Content-Type"].should == "application/json"
-        Yajl::Parser.parse(controller.response.body.join).should == {
-          "status" => {
-            "code" => 403,
-            "message" => "Forbidden"
-          }
-        }
-      end
+    it "forwards to #call" do
+      ctrlr.should_receive(:call).with(env) { response }
+      ctrlr.to_proc.call(env).should equal(response)
     end
   end
   
-  describe "#json" do
-    it "sets the JSON Content-Type header, writes JSON output and finishes" do
-      subject.action(:foo) { json :key => "value" }
-      controller = subject.new({})
-      
-      controller.should_receive :finish!
-      controller.call_action :foo
-      
-      controller.response.headers["Content-Type"].should == "application/json"
-      Yajl::Parser.parse(controller.response.body.join).should == {"key" => "value"}
-    end
+  context ".call(env)" do
+    let(:env) {
+      {
+        "router.params" => {
+          :action => :foo
+        },
+        "REQUEST_METHOD" => "bar"
+      }
+    }
     
-    it "tries to call #to_json and use its result as output" do
-      obj = double "output", :to_json => '{"key":"value"}'
-      obj.should_receive :to_json
-      
-      subject.action(:foo) { json obj }
-      controller = subject.new({})
-      controller.call_action :foo
+    before {
+      ctrlr.action(:foo) {}
+      ctrlr.action(:bar) {}
+    }
+    
+    it "sets default routing params" do
+      ctrlr.action(:bar).should_receive(:call) {|e|
+        e["router.params"].should == {}
+      }
       
-      Yajl::Parser.parse(controller.response.body.join).should == {"key" => "value"}
+      env.delete "router.params"
+      ctrlr.call env
     end
-  end
-end
-
-describe Pakada::Dispatch::NOT_FOUND_ENDPOINT do
-  subject { Pakada::Dispatch::NOT_FOUND_ENDPOINT.call({}) }
-  
-  it "returns a 404 response" do
-    subject[0].should == 404
-    subject[2].join.should == "Not Found"
-  end
-  
-  it "is stackable" do
-    subject[1]["X-Cascade"].should == "pass"
-  end
-end
-
-describe Pakada::Dispatch::METHOD_NOT_ALLOWED_ENDPOINT do
-  subject do
-    Pakada::Dispatch::METHOD_NOT_ALLOWED_ENDPOINT.call([:get, :post]).call({})
-  end
-  
-  it "returns a 405 response" do
-    subject[0].should == 405
-    subject[2].join.should == "Method Not Allowed"
-  end
-  
-  it "returns an appropriate Allow header" do
-    subject[1]["Allow"].should == "GET, POST"
-  end
-end
-
-describe Pakada::Dispatch::Action do
-  describe "#name" do
-    it "returns the action's name" do
-      Pakada::Dispatch::Action.new(:asdf).name.should == :asdf
-    end
-  end
-  
-  describe "#block" do
-    it "returns the action's code block" do
-      block = double "block"
-      Pakada::Dispatch::Action.new(nil, block).block.should == block
+    
+    it "calls the action from routing params by default" do
+      ctrlr.action(:foo).should_receive :call
+      ctrlr.call env
     end
-  end
-  
-  describe "#options" do
-    it "returns the actions' options hash" do
-      options = double "options"
-      Pakada::Dispatch::Action.new(nil, nil, options).options.should == options
+    
+    it "calls the REQUEST_METHOD action as fallback" do
+      ctrlr.action(:bar).should_receive :call
+      
+      env.delete "router.params"
+      ctrlr.call env
     end
   end
 end