merb 0.4.2 → 0.5.0

data/spec/merb/handler_spec.rb

@@ -7,7 +7,7 @@ describe MerbHandler, "process" do
   end
   
   def log_info_with( with_param )
-    MERB_LOGGER.should_receive(:info).with( with_param )
+    Merb.logger.should_receive(:info).with( with_param )
   end
   
   before(:each) do
@@ -36,7 +36,7 @@ describe MerbHandler, "process" do
     @action = "ACTION"
     Merb::Dispatcher.stub!( :handle ).and_return( [@controller, @action] )
 
-    MERB_LOGGER.stub!(:info)
+    Merb.logger.stub!(:info)
   end
 
   it "should return nil if the socket is closed" do
@@ -44,7 +44,7 @@ describe MerbHandler, "process" do
     do_process.should be_nil
   end
   
-  it "should log the request URI to the MERB_LOGGER.info" do
+  it "should log the request URI to the Merb.logger.info" do
     log_info_with( /REQUEST_URI/ )
     do_process
   end
@@ -66,7 +66,7 @@ describe MerbHandler, "process" do
   end
   
   it "should ask the Dispatcher for the controller and action" do
-    Merb::Dispatcher.should_receive( :handle ).with( @request, @response )
+    Merb::Dispatcher.should_receive( :handle ).with( @request, @response ).and_return( [@controller, @action] )
     do_process
   end
   
@@ -75,7 +75,7 @@ describe MerbHandler, "process" do
     @head = {}
     Merb::Dispatcher.should_receive( :handle ).and_raise( Exception )
     @response.should_receive( :send_status ).with( 500 )
-    MERB_LOGGER.should_receive(:error)
+    Merb.logger.should_receive(:error)
     do_process
   end
   

data/spec/merb/mail_controller_spec.rb

@@ -5,8 +5,8 @@ module Merb
     self._template_root = File.expand_path(File.join(File.dirname(__FILE__), '..', "fixtures/mailers/views"))
   end
 end
-Merb::Server.load_controller_template_path_cache
-Merb::Server.load_erubis_inline_helpers
+Merb::BootLoader.load_controller_template_path_cache
+Merb::BootLoader.load_inline_helpers
 
 class Merb::Mailer
   self.delivery_method = :test_send
@@ -138,7 +138,7 @@ describe "A Merb Mail controller" do
   end
   
   it "should log an error if there are no templates available" do
-    MERB_LOGGER.should_receive(:error).once
+    Merb.logger.should_receive(:error).once
     deliver :tenth
   end
   

data/spec/merb/render_spec.rb

@@ -152,7 +152,7 @@ describe "rendering engines except XMLBuilder", :shared => true do
 end
 
 [true, false].each do |cache|
-  Merb::Server.config[:cache_templates] = cache
+  Merb::Config[:cache_templates] = cache
 
   describe "Merb rendering in general#{" (caching enabled)" if cache}" do
     it "should render inline with Erubis" do

data/spec/merb/responder_spec.rb

@@ -242,9 +242,9 @@ class CrazyResponderSpecController < Merb::Controller
   end  
 end
 
-Merb::Server.load_action_arguments
-Merb::Server.load_controller_template_path_cache
-Merb::Server.load_erubis_inline_helpers
+Merb::BootLoader.load_action_arguments
+Merb::BootLoader.load_controller_template_path_cache
+Merb::BootLoader.load_inline_helpers
 
 describe "A Merb Responder's Content Negotiation" do
 

data/spec/merb/router_spec.rb

@@ -3,11 +3,24 @@ require 'benchmark'
 include Benchmark
 
 require FIXTURES / 'models/router_spec_models'
-$TESTING = true
 
-# OpenStruct fails to return 'method' correctly, which we require for our Request object
+# OpenStruct fails to return :method correctly, 
+# which we require for our Request object.
 class SimpleRequest < OpenStruct
-  def method() @table[:method] end
+  def method
+    @table[:method]
+  end
+end
+
+def generate(*args)
+  Merb::Router.generate *args
+end
+
+describe 'generate helper' do
+  it 'should reference Merb::Router method of the same name' do
+    Merb::Router.should_receive(:generate).with(:test)
+    generate :test
+  end
 end
 
 describe Merb::Router::CachedProc do
@@ -16,7 +29,7 @@ describe Merb::Router::CachedProc do
     cc = Merb::Router::CachedProc.new(regexp)
     Merb::Router::CachedProc[cc.index].cache.should == regexp
   end
-
+  
   it "should register a proc" do
     testproc = proc { puts 'test' }
     cc = Merb::Router::CachedProc.new(testproc)
@@ -74,14 +87,14 @@ describe Merb::Router do
   end
   
   it "should have a spec helper to match routes" do
-    Merb::Router.prepare{ |r| r.default_routes }
-    with_route("/pages/show/1", "GET") do |params|
-      params[:controller].should == "pages"
-      params[:action].should == "show"
-      params[:id].should == "1"
-    end    
+    Merb::Router.prepare { |r| r.default_routes }
+    with_route('/pages/show/1', 'GET') do |params|
+      params[:controller].should == 'pages'
+      params[:action].should == 'show'
+      params[:id].should == '1'
+    end
   end
-
+  
   # it "should be fast" do
   #   Merb::Router.prepare do |r|
   #     r.resource :icon
@@ -121,10 +134,10 @@ describe Merb::Router, "when doing route matching with a big set of example rout
     Set.new(hash.keys).should == Set.new(keys)
   end
   
-  before(:all) do
+  before :all do
     Merb::Router.prepare do |r|
-      # A simple route match, sends "/contact" to Info#contact
-      # (i.e. the 'contact' method inside the 'Info' controller)
+      # A simple route match, sends "/contact" to Info#contact,
+      # i.e. the 'contact' method inside the 'Info' controller
       r.match("/contact").
         to(:controller => "info", :action => "contact")
       
@@ -166,7 +179,7 @@ describe Merb::Router, "when doing route matching with a big set of example rout
       # Use square-bracket notation to replace param results with captures from the path
       r.match(%r[^/movies/(\d+)-(\d+)-(\d+)$]).
         to(:controller => "movies", :movie_id => "[1][2][3]", :action => "show")
-
+      
       # Use the second optional argument of 'match' to be more specific about the request;
       # in this case, only accept the POST method for the /movies/create action
       r.match("/movies/create", :method => "post").
@@ -176,12 +189,12 @@ describe Merb::Router, "when doing route matching with a big set of example rout
       # e.g. :user_agent[1] will be replaced with either 'MSIE' or 'Gecko' in the following case:
       r.match(%r[^/movies/(.+)], :user_agent => /(MSIE|Gecko)/).
         to(:controller => "movies", :title => "[1]", :action => "show", :agent => ":user_agent[1]")
-
+      
       # The 'match' method can also be called without the path string or regexp.
       # In this example, direct all insecure traffic to a Insecure#index
       r.match(:protocol => "http://").
         to(:controller => "insecure", :action => "index")
-
+      
       # Use anonymous placeholders in place of the ugly-looking pattern, /([^\/.,;?]+)/
       r.match("/::/users/::").
         to(:controller => "users", :action => "[2]", :id => "[1]")
@@ -193,6 +206,7 @@ describe Merb::Router, "when doing route matching with a big set of example rout
       r.match('/admin').to(:namespace => 'admin') do |foo|
         foo.match('/foo').to(:controller => 'foo')
       end
+      
       r.match('/foo').to(:controller => 'foo')
         
       # Putting it all together, and adding the requirement that we use an "admin" prefix on the
@@ -204,12 +218,12 @@ describe Merb::Router, "when doing route matching with a big set of example rout
       end.to(:controller => "users", :action => "default")
       # Note that the last line above sends all traffic in the "admin" subdomain to the
       # Admin::Users#default action if no other route is matched.
-
+      
       # Create a deferred route.  In this case, the decision of whether or not the route
       # is a match is made via the .xhr? call.  Note that it's ok to put the hash in a
       # conditional because if the "if" statement is false, ruby returns nil (i.e. no match).
       r.match(%r[^/deferred]).defer_to do |request, params|
-        {:controller => "ajax", :action => "index"} if request.xhr?
+        { :controller => "ajax", :action => "index" } if request.xhr?
       end
       
       # Use the placeholders in a the  deferred route
@@ -218,14 +232,14 @@ describe Merb::Router, "when doing route matching with a big set of example rout
       end
     end
   end
-
+  
   it "should connect '/contact' to Info#contact" do
     index, route = Merb::Router.match(SimpleRequest.new(:protocol => "http://", :path => '/contact'), {})
     route[:controller].should == "info"
     route[:action].should == "contact"
     should_only_have_keys(route, :controller, :action)
   end
-
+  
   it "should use placeholders in the match and pass them along to the params" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/books/12/show'), {})
     route[:controller].should == "books"
@@ -233,7 +247,7 @@ describe Merb::Router, "when doing route matching with a big set of example rout
     route[:book_id].should == "12"
     should_only_have_keys(route, :controller, :action, :book_id)
   end
-
+  
   it "should allow placeholders to be used in the params to construct results from matches" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/admin/accounts/users/index'), {})
     route[:controller].should == "accounts/users"
@@ -246,7 +260,7 @@ describe Merb::Router, "when doing route matching with a big set of example rout
     route[:id].should == "4"
     should_only_have_keys(route, :module, :controller, :action, :id)
   end
-
+  
   it "should allow 'match' to use a block to factor out repetitive parts, merging the path as it goes" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/accounts/overview'), {})
     route[:controller].should == "accounts"
@@ -266,7 +280,7 @@ describe Merb::Router, "when doing route matching with a big set of example rout
     route[:controller].should == "accounts"
     route[:action].should == "reports"
     should_only_have_keys(route, :controller, :action)
-
+    
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/slideshow/2'), {})
     route[:controller].should == "accounts"
     route[:action].should == "slideshow"
@@ -281,7 +295,7 @@ describe Merb::Router, "when doing route matching with a big set of example rout
     route[:id].should == "5"
     should_only_have_keys(route, :controller, :action, :id)
   end
-
+  
   it "should be able to use square bracket notation to replace param results with captures from the path" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/movies/123-1-9999'), {})
     route[:controller].should == "movies"
@@ -295,13 +309,13 @@ describe Merb::Router, "when doing route matching with a big set of example rout
     route[:controller].should be_nil
     route[:action].should be_nil
     should_only_have_keys(route)
-
+    
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/movies/create', :method => "post"), {})
     route[:controller].should == "movies"
     route[:action].should == "create"
     should_only_have_keys(route, :controller, :action)
   end
-
+  
   it "should use variables from the 'match' as a result sent to the controller in the params hash" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/movies/harry-potter-3', :user_agent => "Internet Explorer (MSIE)"), {})
     route[:controller].should == "movies"
@@ -322,7 +336,7 @@ describe Merb::Router, "when doing route matching with a big set of example rout
     route[:action].should == "index"
     should_only_have_keys(route, :controller, :action)
   end
-
+  
   it "should use anonymous placeholders" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/5/users/show', :protocol => "https://"), {})
     route[:controller].should == "users"
@@ -335,8 +349,8 @@ describe Merb::Router, "when doing route matching with a big set of example rout
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/bar', :method => :get), {})
     route[:namespace].should == 'foo'
     route[:controller].should == 'bar'
-    route[:action].should == 'index' 
-    should_only_have_keys(route, :namespace, :controller, :action)   
+    route[:action].should == 'index'
+    should_only_have_keys(route, :namespace, :controller, :action)
   end
   
   it "should have namespace 'admin' if path is '/admin/foo'" do
@@ -344,14 +358,14 @@ describe Merb::Router, "when doing route matching with a big set of example rout
     route[:namespace].should == 'admin'
     route[:controller].should == 'foo'
     route[:action].should == 'index' 
-    should_only_have_keys(route, :namespace, :controller, :action)   
+    should_only_have_keys(route, :namespace, :controller, :action)
   end
   
   it "should not have namespace if path is just '/foo'" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/foo', :method => :get), {})
     route[:controller].should == 'foo'
     route[:action].should == 'index' 
-    should_only_have_keys(route, :controller, :action)   
+    should_only_have_keys(route, :controller, :action)
   end
   
   it "should send all admin.* domains to the 'admin/users' controller, and 'default' action" do
@@ -394,106 +408,105 @@ describe Merb::Router, "when doing route matching with a big set of example rout
 end
 
 describe Merb::Router, "with a single resource, 'blogposts' with 'comments'" do
-  before(:each) do
+  before :each do
     Merb::Router.prepare do |r|
-      r.resources :blogposts do |bposts|
-        bposts.resources :comments
-      end  
+      r.resources :blogposts do |b|
+        b.resources :comments
+      end
     end
   end
-
+  
   it "should match /blogposts" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/blogposts', :method => :get), {})
     route[:controller].should == 'blogposts'
     route[:action].should == 'index'
-
+    
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/blogposts', :method => :post), {})
     route[:controller].should == 'blogposts'
     route[:action].should == 'create'
   end
-
+  
   it "should match /blogposts/new" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/blogposts/new', :method => :get), {})
     route[:controller].should == 'blogposts'
     route[:action].should == 'new'
-  end  
-
+  end
+  
   it "should match /blogposts/1" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/blogposts/1', :method => :get), {})
     route[:controller].should == 'blogposts'
     route[:action].should == 'show'
     route[:id].should == '1'
-
+    
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/blogposts/1', :method => :put), {})
     route[:controller].should == 'blogposts'
     route[:action].should == 'update'
     route[:id].should == '1'
-
+    
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/blogposts/1', :method => :delete), {})
     route[:controller].should == 'blogposts'
     route[:action].should == 'destroy'
     route[:id].should == '1'
   end
-
+  
   it "should match /blogposts/1;edit" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/blogposts/1;edit', :method => :get), {})
     route[:controller].should == 'blogposts'
     route[:action].should == 'edit'
     route[:id].should == '1'
-
+    
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/blogposts/1;edit', :method => :put), {})
     route[:controller].should be_nil
     route[:action].should be_nil
   end
-
+  
   it "should match /blogposts/1/edit" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/blogposts/1/edit', :method => :get), {})
     route[:controller].should == 'blogposts'
     route[:action].should == 'edit'
     route[:id].should == '1'
-
+    
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/blogposts/1/edit', :method => :put), {})
     route[:controller].should be_nil
     route[:action].should be_nil
   end
-
+  
   it "should generate blogposts path" do
-    Merb::Router.generate(:blogposts).should == '/blogposts'
+    generate(:blogposts).should == '/blogposts'
   end
-
+  
   it "should generate blogpost path" do
-    Merb::Router.generate(:blogpost, {:id => 1}).should == '/blogposts/1'
+    generate(:blogpost, :id => 1).should == '/blogposts/1'
     b = Blogposts.new
-    Merb::Router.generate(:blogpost, b).should == '/blogposts/42'
-    Merb::Router.generate(:blogpost, :id => b).should == '/blogposts/42'
+    generate(:blogpost, b).should == '/blogposts/42'
+    generate(:blogpost, :id => b).should == '/blogposts/42'
   end
-
+  
   it "should generate new_blogpost path" do
-    Merb::Router.generate(:new_blogpost).should == '/blogposts/new'
+    generate(:new_blogpost).should == '/blogposts/new'
   end
-
+  
   it "should generate edit_blogpost path" do
-    Merb::Router.generate(:edit_blogpost, {:id => 1}).should == '/blogposts/1/edit'
+    generate(:edit_blogpost, {:id => 1}).should == '/blogposts/1/edit'
   end
-    
+  
   it "should generate comments path" do
-    c = Comment.new     
-    Merb::Router.generate(:comments, c).should == '/blogposts/42/comments'
+    c = Comment.new
+    generate(:comments, c).should == '/blogposts/42/comments'
   end
   
   it "should generate comment path" do
     c = Comment.new
-    Merb::Router.generate(:comment, c).should == '/blogposts/42/comments/24'
+    generate(:comment, c).should == '/blogposts/42/comments/24'
   end
-  
 end
 
 
 describe Merb::Router, "with resources using name_prefix, 'oranges' and 'ape'" do
-  before(:each) do
+  before :each do
     Merb::Router.prepare do |r|
       r.resources :oranges, :name_prefix => "florida_"
-      r.resource :ape, :name_prefix => "grape_"
+      r.resource  :ape,     :name_prefix => "grape_"
     end
   end
   
@@ -502,96 +515,147 @@ describe Merb::Router, "with resources using name_prefix, 'oranges' and 'ape'" d
     route[:controller].should == 'oranges'
     route[:action].should == 'index'
   end
-
+  
   it "should generate florida_oranges path" do
-    Merb::Router.generate(:florida_oranges).should == '/oranges'
+    generate(:florida_oranges).should == '/oranges'
   end
-
+  
   it "should generate florida_orange path" do
-    Merb::Router.generate(:florida_orange, {:id => 1}).should == '/oranges/1'
+    generate(:florida_orange, :id => 1).should == '/oranges/1'
     b = Blogposts.new
-    Merb::Router.generate(:florida_orange, b).should == '/oranges/42'
-    Merb::Router.generate(:florida_orange, :id => b).should == '/oranges/42'
+    generate(:florida_orange, b).should == '/oranges/42'
+    generate(:florida_orange, :id => b).should == '/oranges/42'
   end
   
   it "should generate new_florida_orange path" do
-    Merb::Router.generate(:new_florida_orange).should == '/oranges/new'
+    generate(:new_florida_orange).should == '/oranges/new'
   end
   
   it "should generate edit_florida_orange path" do
-    Merb::Router.generate(:edit_florida_orange, {:id => 1}).should == '/oranges/1/edit'
-  end  
+    generate(:edit_florida_orange, {:id => 1}).should == '/oranges/1/edit'
+  end
   
   it "should match /ape" do
     index, route = Merb::Router.match(SimpleRequest.new(:path => '/ape', :method => :get), {})
     route[:controller].should == 'ape'
     route[:action].should == 'show'
   end
-
+  
   it "should generate grape_ape path" do
-    Merb::Router.generate(:grape_ape).should == '/ape'
+    generate(:grape_ape).should == '/ape'
   end
-
+  
   it "should generate new_grape_ape path" do
-    Merb::Router.generate(:new_grape_ape).should == '/ape/new'
+    generate(:new_grape_ape).should == '/ape/new'
   end
   
   it "should generate edit_grape_ape path" do
-    Merb::Router.generate(:edit_grape_ape).should == '/ape/edit'
-  end  
+    generate(:edit_grape_ape).should == '/ape/edit'
+  end
 end
 
 describe Merb::Router, "with resources using a collection action" do
-  before(:each) do
+  before :each do
     Merb::Router.prepare do |r|
       r.resources :flowers, :collection => { :random => [:get] }
     end
   end
-
+  
   it "should generate random_flowers path" do
-    Merb::Router.generate(:random_flowers).should == '/flowers/random'
+    generate(:random_flowers).should == '/flowers/random'
+  end
+
+  it "should match GET to /flowers/random" do
+    index, route = Merb::Router.match(SimpleRequest.new(:path => '/flowers/random', :method => :get), {})
+    route[:controller].should == 'flowers'
+    route[:action].should == 'random'
+  end
+
+  it "should match GET to /flowers/random.xml" do
+    index, route = Merb::Router.match(SimpleRequest.new(:path => '/flowers/random.xml', :method => :get), {})
+    route[:controller].should == 'flowers'
+    route[:action].should == 'random'
+    route[:format].should == 'xml'
   end
+
 end
 
-describe Merb::Router, "with resources using a member action" do
-  before(:each) do
+describe Merb::Router, "with resources using a member action { :pick => [:get] }" do
+  before :each do
     Merb::Router.prepare do |r|
       r.resources :flowers, :member => { :pick => [:get] }
     end
   end
-
+  
   it 'should generate pick_flower path' do
-    Merb::Router.generate(:pick_flower, { :id => 1 }).should == '/flowers/1/pick'
+    generate(:pick_flower, :id => 1).should == '/flowers/1/pick'
+  end
+  
+  it "should match GET to /flowers/2/pick" do
+    index, route = Merb::Router.match(SimpleRequest.new(:path => '/flowers/2/pick', :method => :get), {})
+    route[:controller].should == 'flowers'
+    route[:action].should == 'pick'
+    route[:id].should == '2'
+  end
+
+  it "should not match POST to /flowers/2/pick" do
+    index, route = Merb::Router.match(SimpleRequest.new(:path => '/flowers/2/pick', :method => :post), {})
+    route[:controller].should_not == 'flowers'
+    route[:action].should_not == 'pick'
+    route[:id].should_not == '2'
   end
+
+  it "should not match PUT to /flowers/2/pick" do
+    index, route = Merb::Router.match(SimpleRequest.new(:path => '/flowers/2/pick', :method => :put), {})
+    route[:controller].should_not == 'flowers'
+    route[:action].should_not == 'pick'
+    route[:id].should_not == '2'
+  end
+
+  it "should not match DELETE to /flowers/2/pick" do
+    index, route = Merb::Router.match(SimpleRequest.new(:path => '/flowers/2/pick', :method => :delete), {})
+    route[:controller].should_not == 'flowers'
+    route[:action].should_not == 'pick'
+    route[:id].should_not == '2'
+  end
+  
+  it "should match GET to /flowers/2/pick.xml" do
+    index, route = Merb::Router.match(SimpleRequest.new(:path => '/flowers/2/pick.xml', :method => :get), {})
+    route[:controller].should == 'flowers'
+    route[:action].should == 'pick'
+    route[:id].should == '2'
+    route[:format].should == 'xml'
+  end
+  
 end
 
 describe Merb::Router::Behavior do
-  before(:all) do
+  before :all do
     @behavior = Merb::Router::Behavior
   end
   
   it "should leave strings as strings and add ^...$ in the @conditions hash" do
-    @behavior.new({:path => "/one/two"}).conditions[:path].should == "^/one/two$"
+    @behavior.new(:path => '/one/two').conditions[:path].should == '^/one/two$'
   end
-
+  
   it "should replace special characters in strings with their escaped equivalents" do
-    @behavior.new({:path => "test.xml"}).conditions[:path].should == "^test\\.xml$"
+    @behavior.new(:path => 'test.xml').conditions[:path].should == '^test\\.xml$'
   end
   
   it "should convert symbols to strings and add ^...$ in the @conditions hash" do
-    @behavior.new({:method => :get}).conditions[:method].should == "^get$"
+    @behavior.new(:method => :get).conditions[:method].should == '^get$'
   end
   
   it "should convert regular expressions to strings in the @conditions hash" do
-    @behavior.new({:protocol => /https?/}).conditions[:protocol].should == "https?"
+    @behavior.new(:protocol => /https?/).conditions[:protocol].should == 'https?'
   end
-
+  
   it "should deduce placeholders from the @conditions hash" do
-    ph = @behavior.new({:path => "/:controller/:action"}).placeholders
+    ph = @behavior.new(:path => '/:controller/:action').placeholders
     ph[:controller].should == [:path, 1]
     ph[:action].should == [:path, 2]
   end
-
+  
   it "should deduce placeholders from the @conditions hash, even when they contain numbers" do
     ph = @behavior.new({:path => "/:part1/:part2"}).placeholders
     ph[:part1].should == [:path, 1]
@@ -599,40 +663,40 @@ describe Merb::Router::Behavior do
   end
 
   it "should deduce placeholders within regular expressions that contain prefixed captures" do
-    ph = @behavior.new({:path => %r[/(\d+)/:controller/:action]}).placeholders
+    ph = @behavior.new(:path => %r[/(\d+)/:controller/:action]).placeholders
     ph[:controller].should == [:path, 2]
     ph[:action].should == [:path, 3]
-
-    ph = @behavior.new({:path => %r[/:controller/:action/(\d+)]}).placeholders
+    
+    ph = @behavior.new(:path => %r[/:controller/:action/(\d+)]).placeholders
     ph[:controller].should == [:path, 1]
     ph[:action].should == [:path, 2]
   end
   
   it "should deduce placeholder positions in nested captures" do
-    ph = @behavior.new({:path => %r[(/(\d+)/:controller)/:action]}).placeholders
+    ph = @behavior.new(:path => %r[(/(\d+)/:controller)/:action]).placeholders
     ph[:controller].should == [:path, 3]
     ph[:action].should == [:path, 4]
-
-    ph = @behavior.new({:path => %r[/(\d+)/(:controller)/:action]}).placeholders
+    
+    ph = @behavior.new(:path => %r[/(\d+)/(:controller)/:action]).placeholders
     ph[:controller].should == [:path, 3]
     ph[:action].should == [:path, 4]
-
-    ph = @behavior.new({:path => %r[/(\d+)/:controller/(:action)]}).placeholders
+    
+    ph = @behavior.new(:path => %r[/(\d+)/:controller/(:action)]).placeholders
     ph[:controller].should == [:path, 2]
     ph[:action].should == [:path, 4]
-
-    ph = @behavior.new({:path => %r[(/(\d+)/(:controller/((:action))))]}).placeholders
+    
+    ph = @behavior.new(:path => %r[(/(\d+)/(:controller/((:action))))]).placeholders
     ph[:controller].should == [:path, 4]
     ph[:action].should == [:path, 7]
   end
   
   it "should replace any placeholders found within @conditions strings with segment regular expressions" do
-    m = @behavior.new({:path => "/:my/:place:holders/:here"}).conditions
+    m = @behavior.new(:path => "/:my/:place:holders/:here").conditions
     m[:path].should == "^/([^/.,;?]+)/([^/.,;?]+)([^/.,;?]+)/([^/.,;?]+)$"
   end
   
   it "should set default values for params that came from placeholders" do
-    p = @behavior.new({:path => "/:my/:place:holders/:here"}).params
+    p = @behavior.new(:path => "/:my/:place:holders/:here").params
     p[:my].should == ":my"
     p[:place].should == ":place"
     p[:holders].should == ":holders"
@@ -640,11 +704,11 @@ describe Merb::Router::Behavior do
   end
   
   it "should merge params with its ancestors" do
-    b = @behavior.new({}, {:controller => "my_controller", :action => "index"})
-    c = @behavior.new({}, {:action => "show"}, b)
-    c.merged_params.should == {:controller => "my_controller", :action => "show"}
+    b = @behavior.new({}, { :controller => "my_controller", :action => "index" })
+    c = @behavior.new({}, { :action => "show" }, b)
+    c.merged_params.should == { :controller => "my_controller", :action => "show" }
   end
-
+  
   # it "should have a default action and controller for merged params" do
   #   a = @behavior.new
   #   a.merged_params.should == {:controller => "application", :action => "index"}
@@ -655,37 +719,37 @@ describe Merb::Router::Behavior do
   #   c = @behavior.new({}, {:action => "show"})
   #   c.merged_params.should == {:controller => "application", :action => "show"}
   # end
-
+  
   it "should merge conditions with its ancestors" do
-    b = @behavior.new({:method => "get", :protocol => "http"})
-    c = @behavior.new({:method => "put"}, {}, b)
-    c.merged_conditions.should == {:method => "^put$", :protocol => "^http$"}
+    b = @behavior.new({ :method => "get", :protocol => "http" })
+    c = @behavior.new({ :method => "put" }, {}, b)
+    c.merged_conditions.should == { :method => "^put$", :protocol => "^http$" }
   end
   
   it "should merge placeholders with its ancestors" do
-    b = @behavior.new({:method => "get", :protocol => ":ssl"}, {:action => ":method"})
-    c = @behavior.new({:method => "put"}, {:action => ":ssl"}, b)
-    c.merged_placeholders.should == {:ssl => [:protocol, 1]}
+    b = @behavior.new({ :method => "get", :protocol => ":ssl" }, { :action => ":method" })
+    c = @behavior.new({ :method => "put" }, { :action => ":ssl" }, b)
+    c.merged_placeholders.should == { :ssl => [:protocol, 1] }
   end
   
   it "should add the number of path captures in the ancestors' paths to placeholders that hold a place for :path captures" do
-    b = @behavior.new({:path => "/:controller/:action"})
-    b.placeholders.should == {:controller => [:path, 1], :action => [:path, 2]}
-    c = @behavior.new({:path => "/:id"}, {}, b)
-    c.placeholders.should == {:id => [:path, 1]}
+    b = @behavior.new(:path => "/:controller/:action")
+    b.placeholders.should == { :controller => [:path, 1], :action => [:path, 2] }
+    c = @behavior.new({ :path => "/:id" }, {}, b)
+    c.placeholders.should == { :id => [:path, 1] }
     
-    c.merged_placeholders.should == {:controller => [:path, 1], :action => [:path, 2], :id => [:path, 3]}
+    c.merged_placeholders.should == { :controller => [:path, 1], :action => [:path, 2], :id => [:path, 3] }
   end
   
   it "should merge the :path differently than other @conditions keys -- it should concatenate" do
     b = @behavior.new({:method => "get", :protocol => "http"})
     c = @behavior.new({:path => "/test", :method => "put"}, {}, b)
     c.merged_conditions.should == {:method => "^put$", :protocol => "^http$", :path => "^/test$"}
-
+    
     b = @behavior.new({:path => "/test", :method => "get", :protocol => "http"})
     c = @behavior.new({:method => "put"}, {}, b)
     c.merged_conditions.should == {:method => "^put$", :protocol => "^http$", :path => "^/test$"}
-
+    
     b = @behavior.new({:path => "/admin", :method => "get", :protocol => "http"})
     c = @behavior.new({:path => "/test", :method => "put"}, {}, b)
     c.merged_conditions.should == {:method => "^put$", :protocol => "^http$", :path => "^/admin/test$"}
@@ -696,7 +760,7 @@ describe Merb::Router::Behavior do
     cp = b.send(:compiled_params)
     cp[:controller].should == "path1"
     cp[:action].should == "path2"
-
+    
     b = @behavior.new(
       {:path => "/admin/:controller/:action/:postfix", :method => "get"},
       {:controller => "/admin/:controller", :action => "neat_o_:action:postfix"})
@@ -704,7 +768,7 @@ describe Merb::Router::Behavior do
     cp[:controller].should == "\"/admin/\" + path1"
     cp[:action].should == "\"neat_o_\" + path2 + path3"
   end
-
+  
   it "should allow a bracketed number such as [3] to compile to path3" do
     b = @behavior.new(
       {:path => "/admin/:controller/:action/(.+)", :method => "get"},
@@ -712,7 +776,7 @@ describe Merb::Router::Behavior do
     cp = b.send(:compiled_params)
     cp[:catchall].should == "path3"
   end
-
+  
   it "should allow a backslash to escape an underscore in the compiled params" do
     b = @behavior.new(
       {:path => "/admin/:controller/:action", :method => "get"},
@@ -731,101 +795,106 @@ describe Merb::Router::Behavior do
   end
   
   it "should allow for conditional blocks using the 'defer_to' method" do
-    b = @behavior.new({:path => "/admin"})
-    route = b.defer_to { |request| {:controller => "late_bound", :action => "place"} }
+    b = @behavior.new(:path => '/admin')
+    route = b.defer_to { |request| { :controller => 'late_bound', :action => 'place' } }
     route.conditional_block.should be_an_instance_of(Proc)
     route.compile.should match(/block_result/m)
   end
 end
 
 describe Merb::Router::Behavior, "class methods" do
-  before(:all) do
+  before :all do
     @b = Merb::Router::Behavior
   end
   
-  it "should count opening parentheses" do
-    @b.count_parens_up_to(" ( )", 1).should == 1
-    @b.count_parens_up_to(" ( )", 50).should == 1
-    @b.count_parens_up_to(" (() )", 1).should == 1
-    @b.count_parens_up_to(" (() )", 2).should == 2
+  it 'should count opening parentheses' do
+    [[' ( )',    1,  1],
+     [' ( )',    50, 1],
+     [' (() )',  1,  1],
+     [' (() )',  2,  2]].each do |parens,limit,expected|
+      @b.count_parens_up_to(parens, limit).should == expected
+    end
+    
     # TODO: skip escaped open parens
   end
   
-  it "should concatenate strings without endcaps" do
-    @b.concat_without_endcaps(nil, nil).should be_nil
-    @b.concat_without_endcaps(nil, "^test").should == "^test"
-    @b.concat_without_endcaps("my$", nil).should == "my$"
-    @b.concat_without_endcaps("my", "test").should == "mytest"
-    @b.concat_without_endcaps("my$", "test").should == "mytest"
-    @b.concat_without_endcaps("my^", "test").should == "my^test"
-    @b.concat_without_endcaps("my$", "^test").should == "mytest"
-    @b.concat_without_endcaps("^my$", "^test$").should == "^mytest$"
+  it 'should concatenate strings without endcaps' do
+    [[nil, nil, nil],
+     [nil, '^test', '^test'],
+     ['my$', nil, 'my$'],
+     ['my', 'test', 'mytest'],
+     ['my$', 'test', 'mytest'],
+     ['my^', 'test', 'my^test'],
+     ['my$', '^test', 'mytest'],
+     ['^my$', '^test$', '^mytest$']].each do |str1, str2, expected|
+      @b.concat_without_endcaps(str1, str2).should == expected
+    end
   end
   
-  it "should compile arrays with strings and symbols into code" do
-    @b.array_to_code([:var, "this string"]).should == "var + \"this string\""
-    @b.array_to_code(["one string"]).should == "\"one string\""
-    @b.array_to_code(["string", :var, :var2, "other"]).should == "\"string\" + var + var2 + \"other\""
+  it 'should compile arrays with strings and symbols into code' do
+    [[[:var, 'this string'], %{var + "this string"}],
+     [['one string'], %{"one string"}],
+     [["string", :var, :var2, "other"], %{"string" + var + var2 + "other"}]].each do |array, expected|
+      @b.array_to_code(array).should == expected
+    end
   end
 end
 
-describe "Merb::Route", "rendered as a string" do
-  before(:all) do
-    Merb::Router.prepare do |r|
-      r.default_routes
-    end
+describe Merb::Router::Route, 'rendered as a string' do
+  before :all do
+    Merb::Router.prepare { |r| r.default_routes }
     @routes = Merb::Router.routes
   end
   
-  it "should show the default route" do
+  it 'should show the default route' do
     @routes.last.to_s.should == "/:controller(/:action(/:id)?)?(\\.:format)?"
   end
 end
 
-describe Merb::Router, "with resources using namespace 'admin'" do
-  before(:each) do
+describe Merb::Router, 'using namespaces' do
+  before :each do
     Merb::Router.prepare do |r|
-      #Declare one in the nested style
-      r.match(:host => /^.*$/).to(:namespace => 'admin') do |admin|
-        admin.resources :oranges
+      r.namespace :admin do |a|
+        a.resources :namespace_block_resources
+        a.resource  :namespace_block_resource
+      end
+      
+      r.match :namespace => 'admin' do |a|
+        a.resources :match_block_resources
+        a.resource  :match_block_resource
       end
-      #Declare one in the non-nested style
-      r.resources :ape, :namespace => 'admin'
-      #Declare resources without a namespace to make sure it's not overridden
-      r.resources :oranges
-      r.resource :ape
+      
+      r.resources :namespace_option_resources, :namespace => 'admin'
+      r.resource  :namespace_option_resource,  :namespace => 'admin'
+      
+      r.resources :resources, :namespace => 'admin'
+      r.resource  :resource,  :namespace => 'admin'
+      r.resources :resources
+      r.resource  :resource
+      
+      r.resources :path_namespace_resources, :namespace => 'admin/supersecret'
+      r.resources :path_namespace_resource,  :namespace => 'admin/supersecret'
     end
   end
   
-  it "should generate admin_oranges path" do
-    Merb::Router.generate(:admin_oranges).should == '/oranges'
-  end
-
-  it "should generate admin_orange path" do
-    Merb::Router.generate(:admin_orange, {:id => 1}).should == '/oranges/1'
-    b = Blogposts.new
-    Merb::Router.generate(:admin_orange, b).should == '/oranges/42'
-    Merb::Router.generate(:admin_orange, :id => b).should == '/oranges/42'
+  # Several ways to define a namespace. Perhaps too many?
+  %w( namespace_block match_block namespace_option ).each do |context|
+    %w( resources resource ).each do |r|
+      it "defines :#{r} in a :#{context} context" do
+        generate("admin_#{context}_#{r}").should == "/admin/#{context}_#{r}"
+      end
+    end
   end
   
-  it "should generate new_admin_orange path" do
-    Merb::Router.generate(:new_admin_orange).should == '/oranges/new'
+  it 'defines namespaces with path fragments' do
+    generate(:admin_supersecret_path_namespace_resources).should ==
+      '/admin/supersecret/path_namespace_resources'
   end
   
-  it "should generate edit_admin_orange path" do
-    Merb::Router.generate(:edit_admin_orange, {:id => 1}).should == '/oranges/1/edit'
-  end  
-  
-  it "should generate admin_ape path" do
-    Merb::Router.generate(:admin_ape).should == '/ape'
-  end
-
-  it "should generate new_admin_ape path" do
-    Merb::Router.generate(:new_admin_ape).should == '/ape/new'
+  it 'allows resources of the same name in different namespaces' do
+    %w( resources resource ).each do |r|
+      generate("admin_#{r}").should == "/admin/#{r}"
+      generate(r).should == "/#{r}"
+    end
   end
-  
-  it "should generate edit_admin_ape path" do
-    Merb::Router.generate(:edit_admin_ape).should == '/ape/edit'
-  end  
-
 end