pakada-dispatch 0.1.1 → 0.2.0

data/spec/controllers/foo.rb

@@ -0,0 +1 @@
+action(:bar) {}

data/spec/dispatch_spec.rb

@@ -1,78 +1,62 @@
 require "spec_helper"
 
 describe Pakada::Dispatch do
-  subject { Pakada::Dispatch.new }
+  let(:dispatch) { Pakada::Dispatch.new }
   
-  it "is a Pakada module" do
-    subject.module_name.should == :dispatch
-  end
-  
-  describe "#initialize" do
-    it "initializes the router" do
-      subject.router.should respond_to :add_route
-      subject.router.should respond_to :call
-    end
-  end
-  
-  describe "#boot" do
-    before :each do
-      [:apply_patches, :load_module_controllers].each {|m| subject.stub m }
-    end
+  context "#initialize" do
+    let(:router) { stub "router" }
     
-    it "calls #apply_patches" do
-      subject.should_receive :apply_patches
-      subject.boot
-    end
-    
-    it "calls #load_module_controllers" do
-      subject.should_receive :load_module_controllers
-      subject.boot
-    end
-    
-    it "calls #set_app" do
-      subject.should_receive :set_app
-      subject.boot
-    end
+    before {
+      HttpRouter.stub :new => router
+    }
     
-    it "calls #freeze_router" do
-      subject.should_receive :freeze_router
-      subject.boot
+    it "sets the router" do
+      dispatch.router.should equal(router)
     end
   end
   
-  describe "#apply_patches" do
-    it "patches Pakada::Module" do
-      Pakada.instance.stub(:modules).and_return :foo => stub("foo module")
-      
-      subject.apply_patches
-      Pakada[:foo].should respond_to(:load_controllers)
+  context "#hooks" do
+    it "replaces Pakada#request with router#call" do
+      Pakada.instance.should_receive(:instead_of).with(
+        :request, dispatch.router.method(:call))
+      dispatch.hooks
     end
   end
   
-  describe "#load_module_controllers" do
-    it "calls #load_controllers on each module" do
-      Pakada.instance.stub(:modules).and_return :foo => stub("foo module")
+  context "#boot" do
+    let(:module1) {
+      Class.new { @pakada_name = :module1; include Pakada::Module }.new
+    }
+    let(:module2) {
+      Class.new { @pakada_name = :module2; include Pakada::Module }.new
+    }
+    
+    before {
+      Pakada.instance.stub :modules => {
+        :dispatch => dispatch,
+        :module1 => module1,
+        :module2 => module2
+      }
+      module1.stub :routes
+    }
+    
+    it "includes Module into each Pakada module" do
+      mod = Pakada.safety(Pakada::Dispatch::Module)
       
-      Pakada[:foo].should_receive :load_controllers
-      subject.load_module_controllers
+      dispatch.boot
+      module1.singleton_class.included_modules.should include(mod)
+      module2.singleton_class.included_modules.should include(mod)
     end
-  end
-  
-  describe "#set_app" do
-    it "makes Pakada.app.call forward to Dispatch.request" do
-      subject.set_app
-      
-      req, resp = stub("request"), stub("response")
-      subject.should_receive(:request).with(req).and_return resp
-      
-      Pakada.app.call(req).should == resp
+    
+    it "loads each module's controllers" do
+      module1.should_receive :load_controllers
+      module2.should_receive :load_controllers
+      dispatch.boot
     end
-  end
-  
-  describe "#freeze_router" do
-    it "freezes the router" do
-      subject.router.should_receive :rehash
-      subject.freeze_router
+    
+    it "tries to call #routes on each module" do
+      module1.should_receive :routes
+      dispatch.boot
     end
   end
 end

data/spec/module_spec.rb

@@ -1,282 +1,85 @@
 require "spec_helper"
 
 describe Pakada::Dispatch::Module do
-  describe "#load_controllers" do
-    before do
-      FakeFS.activate!
-    end
-    
-    subject do
-      FileUtils.mkdir_p "/mymodule/controllers"
-      File.open "/mymodule/controllers/foo.rb", "w" do |f|
-        f.write "action(:foo) {}"
-      end
-      
-      Class.new do
-        @module_name, @path = :foo, "/mymodule"
-        include Pakada::Module
-        include Pakada::Dispatch::Module
-      end.new
-    end
-    
-    it "iterates over the module's controllers/ directory and builds a controller for each file" do
-      subject.load_controllers
-      subject.controllers[:foo].should have(1).actions
-    end
+  let(:mod) {
+    Class.new {
+      @pakada_name, @path = :foo, "/path/to"
+      include Pakada::Module
+      include Pakada::Dispatch::Module
+    }.new
+  }
+  
+  context "#controller_path" do
+    let(:path) { mod.controller_path }
     
-    it "does nothing if the module doesn't have a path" do
-      subject.class.instance_variable_set :@path, nil
-      subject.load_controllers
-      subject.should have(0).controllers
+    it "sets the path to the controller directory" do
+      path.should == Pathname.new("/path/to/controllers")
     end
     
-    after do
-      FakeFS.deactivate!
-      FakeFS::FileSystem.clear
-      
-      Pakada::Module.descendants.delete :foo
+    it "does memoization" do
+      mod.controller_path.should equal(path)
     end
   end
   
-  describe "#route" do
-    describe "when called without a symbol" do
-      it "creates an anonymous route" do
-        Pakada.boot
-        
-        Pakada[:dispatch].router.should_receive(:add_route) do |*args|
-          args[0].should respond_to(:call)
-          args[1][:path_info].should be_a(Regexp)
-          args[2].should == {
-            :module => :dispatch,
-            :controller => :foo,
-            :action => :bar
-          }
-          args[3].should be_nil
-        end
-        Pakada[:dispatch].route "/pattern" => "foo#bar"
-      end
-    end
+  context "#controller(name)" do
+    let(:controller) { stub "controller" }
     
-    describe "takes a hash that" do
-      before { Pakada.boot }
-      
-      subject { Pakada[:dispatch] }
-      
-      it "contains a route-pattern => target-action pair" do
-        subject.router.should_receive(:add_route) do |*args|
-          args[0].should respond_to(:call)
-          args[1][:path_info].should == %r{^/pattern$}
-          args[2].should == {
-            :module => :foo,
-            :controller => :bar,
-            :action => :baz
-          }
-          args[3].should == :myroute
-        end
-        subject.route :myroute, "/pattern" => "foo::bar#baz"
-      end
-      
-      it "can contain default values for parameters" do
-        subject.router.should_receive(:add_route) do |*args|
-          args[0].should respond_to(:call)
-          args[1][:path_info].should == %r{^/pattern$}
-          args[2].should == {
-            :module => :dispatch,
-            :controller => :foo,
-            :action => :bar,
-            :key => :value
-          }
-          args[3].should == :myroute
-        end
-        subject.route :myroute, "/pattern" => "#bar", :key => :value, :controller => :foo
-      end
-      
-      it "whose contained default values won't override the target-action" do
-        subject.router.should_receive(:add_route) do |*args|
-          args[0].should respond_to(:call)
-          args[1][:path_info].should be_a(Regexp)
-          args[2].should == {
-            :module => :dispatch,
-            :controller => :foo,
-            :action => :bar
-          }
-          args[3].should == :myroute
-        end
-        subject.route :myroute, "/pattern" => "foo#bar", :action => :baz
-      end
+    it "returns the named controller class if it exists" do
+      mod.controllers[:foo] = controller
+      mod.controller(:foo).should equal(controller)
     end
   end
   
-  describe "#route's route-pattern" do
-    before { Pakada.boot }
-    
-    subject { Pakada[:dispatch] }
-    
-    it "can contain :normal parameters" do
-      subject.router.should_receive(:add_route) do |*args|
-        args[1][:path_info].should == %r{^/(?<key>[a-z0-9\-_]+)/(?<key2>[a-z0-9\-_]+)$}
-      end
-      subject.route :myroute, "/:key/:key2" => ""
-    end
-    
-    it "can contain *splat parameters" do
-      subject.router.should_receive(:add_route) do |*args|
-        args[1][:path_info].should == %r{^/(?<key>([a-z0-9\-_]/?)*)$}
-      end
-      subject.route :myroute, "/*key" => ""
-    end
-    
-    it "can contain optional parts" do
-      subject.router.should_receive(:add_route) do |*args|
-        args[1][:path_info].should == %r{^(/(?<key>[a-z0-9\-_]+))?/(?<key2>[a-z0-9\-_]+)$}
-      end
-      subject.route :myroute, "(/:key)/:key2" => ""
+  context "#controller(name) { ... }" do
+    let(:block) { proc {} }
+    let(:controller) { stub "controller" }
+    let(:dispatch) { Pakada::Dispatch.new }
+    
+    before {
+      Pakada.instance.modules[:dispatch] = dispatch
+    }
+    
+    it "creates a controller class from the given block" do
+      Pakada.safety(Pakada::Dispatch::Controller)
+        .should_receive(:create) {|&blk|
+          blk.should equal(block)
+          controller
+        }
+      
+      mod.controller :bar, &block
+      mod.controllers[:bar].should equal(controller)
     end
   end
   
-  describe "#route's target-action" do
-    before { Pakada.boot }
-    
-    subject { Pakada[:dispatch] }
-    
-    it "uses the current module's name as default :module parameter" do
-      subject.router.should_receive :add_route do |*args|
-        args[2].should == {
-          :module => :dispatch
-        }
-      end
-      subject.route "/" => ""
-    end
-    
-    it "can consist of a controller and an action" do
-      subject.router.should_receive :add_route do |*args|
-        args[2].should == {
-          :module => :dispatch,
-          :controller => :foo,
-          :action => :bar
-        }
-      end
-      subject.route "/" => "foo#bar"
-    end
+  context "#load_controllers" do
+    before {
+      path = Pathname.new(__FILE__).parent.join("controllers")
+      mod.stub :controller_path => Pathname.new(path)
+    }
     
-    it "can consist of an action" do
-      subject.router.should_receive :add_route do |*args|
-        args[2].should == {
-          :module => :dispatch,
-          :action => :bar
-        }
-      end
-      subject.route "/" => "#bar"
-    end
-    
-    it "can consist of a controller" do
-      subject.router.should_receive :add_route do |*args|
-        args[2].should == {
-          :module => :dispatch,
-          :controller => :foo
-        }
-      end
-      subject.route "/" => "foo"
-    end
-    
-    it "can consist of a module" do
-      subject.router.should_receive :add_route do |*args|
-        args[2].should == {
-          :module => :mymodule,
-        }
-      end
-      subject.route "/" => "mymodule::"
-    end
-    
-    it "can consist of a module and a controller" do
-      subject.router.should_receive :add_route do |*args|
-        args[2].should == {
-          :module => :mymodule,
-          :controller => :foo
-        }
-      end
-      subject.route "/" => "mymodule::foo"
-    end
-    
-    it "can consist of a module and an action" do
-      subject.router.should_receive :add_route do |*args|
-        args[2].should == {
-          :module => :mymodule,
-          :action => :bar
-        }
-      end
-      subject.route "/" => "mymodule::#bar"
+    it "creates a controller class from each file in controller path" do
+      mod.load_controllers
+      mod.controller(:foo).action(:bar).should respond_to(:call)
     end
   end
   
-  describe "#route's Rack end-point" do
-    def stub_action(route, params = {}, route_name = nil, &block)
-      params = {
-        :module => subject.module_name,
-        :controller => :bar,
-        :action => :baz
-      }.merge(params)
-      
-      controller, action = double("controller"), double("action")
-      subject.controllers[:bar] = controller
-      controller.should_receive(:action).with(:baz).and_return(action)
-      action.should_receive(:call) {|env| block.call env }
-      
-      subject.router.should_receive :add_route do |app, *nothing|
-        app.call "rack.routing_args" => params
-      end
-      subject.route route_name, route => ""
-    end
-    
-    before { Pakada.boot }
-    
-    subject { Pakada[:dispatch] }
-    
-    it "splits splat parameters" do
-      stub_action "/*something", :something => "/some///thing/123" do |env|
-        env["pakada.dispatch.params"][:something].should == ["some", "thing", "123"]
-      end
-    end
-    
-    it "makes sure the module, controller and action params are symbols" do
-      stub_action "/", {
-        :module => subject.module_name.to_s,
-        :controller => "bar",
-        :action => "baz"
-      } do |env|
-        [:module, :controller, :action].each do |k|
-          env["pakada.dispatch.params"][k].should be_kind_of(Symbol)
-        end
-      end
-    end
-    
-    it "calls the respective action" do
-      called = false
-      stub_action("/") {|env| called = true }
-      
-      called.should be_true
-    end
-    
-    it "returns an X-Cascade: pass response if the module or controller doesn't exist" do
-      subject.router.should_receive :add_route do |app, *nothing|
-        env = {"rack.routing_args" => {
-          :module => :dispatch,
-          :controller => :bar,
-          :action => :foofoofoo
-        }}
-        app.call(env).should == [404, {"X-Cascade" => "pass"}, []]
-      end
-      subject.route "/" => ""
-    end
-    
-    it "puts the matched route's name into the environment if it has a name" do
-      stub_action "/with_name", {}, :myroute do |env|
-        env["pakada.dispatch.route"].should == :myroute
-      end
+  context "#route(name, pattern) {|env| ... }" do
+    let(:dispatch) { Pakada::Dispatch.new }
+    let(:route) { stub "route" }
+    let(:pattern) { stub "pattern" }
+    let(:name) { stub "name" }
+    let(:block) { proc {} }
+    
+    before {
+      Pakada.instance.modules[:dispatch] = dispatch
+    }
+    
+    it "adds the specified route to the router" do
+      dispatch.router.should_receive(:add).with(pattern) { route }
+      route.should_receive(:name).with(name) { route }
+      route.should_receive(:to) {|&blk| block.should equal(blk) }
       
-      stub_action "/without_name" do |env|
-        env["pakada.dispatch.route"].should be_nil
-      end
+      mod.route name, pattern, &block
     end
   end
 end