merb 0.4.1 → 0.4.2

data/spec/merb/cookie_store_spec.rb

@@ -30,14 +30,6 @@ end
 
 describe Merb::CookieStore do
   
-  def cookies(*which)
-    @cookies.values_at(*which)
-  end
-  
-  def cookie_value(which)
-    @cookies[which].first
-  end
-  
   before(:each) do
     @secret = 'Keep it secret; keep it safe.'
     @cookies = { 
@@ -47,15 +39,13 @@ describe Merb::CookieStore do
       :flashed => ['BAh7ByIMdXNlcl9pZGkBeyIKZmxhc2h7AA%3D%3D--bf9785a666d3c4ac09f7fe3353496b437546cfbf', { 'user_id' => 123, 'flash' => {} }] 
     }
   end
-  
-  
-  
+
   it "should raise argument error if missing secret key" do
     lambda { Merb::CookieStore.new(nil, nil) }.should raise_error(ArgumentError)
   end
   
   it "should restore and unmarshal good cookies" do
-    cookies(:empty, :a_one, :typical).each do |value, expected|
+    @cookies.values_at(:empty, :a_one, :typical).each do |value, expected|
       session = Merb::CookieStore.new(value, @secret)
       session['lazy loads the data hash'].should be_nil
       session.data.should == expected
@@ -68,18 +58,15 @@ describe Merb::CookieStore do
   end
   
   it "should raise when data overflows" do
-    session =  Merb::CookieStore.new(cookie_value(:empty), @secret)
+    session =  Merb::CookieStore.new(@cookies[:empty].first, @secret)
     session['overflow'] = 'bye!' * 1024
     lambda { session.read_cookie }.should 
       raise_error(Merb::CookieStore::CookieOverflow)
   end
-  
-  it "should close and marshal cookie data" do 
-    session =  Merb::CookieStore.new(cookie_value(:typical), @secret)
-    session.modified?.should == false
-    session['flash'] = {}
-    session.modified?.should == true
-    session.read_cookie.should == cookie_value(:flashed)
+
+  it "should delete entries in the session" do
+    session = Merb::CookieStore.new(@cookies[:a_one].first, @secret)
+    session.delete('a').should == 1
   end
   
 end

data/spec/merb/core_ext_spec.rb

@@ -401,9 +401,14 @@ describe "A String" do
       end.should raise_error(String::InvalidPathConversion)
     end.should_not raise_error(Timeout::Error)
   end
+
+  it "should remove any indentation and add +indentation+ number of spaces" do
+    "foo\n  bar\n".indent(3).should == "   foo\n     bar\n"
+    "  foo\n    bar\n".indent(3).should == "   foo\n     bar\n"
+  end
 end
 
-describe "extracting options form argruments" do
+describe "extracting options from arguments" do
   
   def the_method(*args)
     [extract_options_from_args!(args),args]
@@ -428,3 +433,32 @@ describe "extracting options form argruments" do
   end
   
 end
+
+describe Inflector do
+  it "should transform words from singular to plural" do
+    "post".pluralize.should == "posts"
+    "octopus".pluralize.should =="octopi"
+    "the blue mailman".pluralize.should == "the blue mailmen"
+    "CamelOctopus".pluralize.should == "CamelOctopi"
+  end
+  it "should transform words from plural to singular" do
+    "posts".singularize.should == "post"
+    "octopi".singularize.should == "octopus"
+    "the blue mailmen".singularize.should == "the blue mailman"
+    "CamelOctopi".singularize.should == "CamelOctopus"
+  end
+  it "should transform class names to table names" do
+    "RawScaledScorer".tableize.should == "raw_scaled_scorers"
+    "egg_and_ham".tableize.should == "egg_and_hams"
+    "fancyCategory".tableize.should == "fancy_categories"
+  end
+  it "should tranform table names to class names" do
+    "egg_and_hams".classify.should == "EggAndHam"
+    "post".classify.should == "Post"    
+  end
+  it "should create a foreign key name from a class name" do
+    "Message".foreign_key.should == "message_id"
+    "Message".foreign_key(false).should == "messageid"
+    "Admin::Post".foreign_key.should == "post_id"  
+  end
+end

data/spec/merb/dispatch_spec.rb

@@ -4,7 +4,7 @@ require File.dirname(__FILE__) + '/../fixtures/controllers/dispatch_spec_control
 $TESTING = true
 
 describe Merb::Dispatcher do
-  
+
   before(:all) do
     Merb::Server.config[:allow_reloading] = false
     Merb::Router.prepare do |r|
@@ -24,9 +24,15 @@ describe Merb::Dispatcher do
       end
       r.default_routes
     end
-    puts Merb::Router.named_routes[:new_comment].generate(:post_id => 1)
   end
   
+  it "should not overwrite url params with query string params" do
+    controller, action = request(:get, '/foo/bar/42?id=24')
+    controller.class.should == Foo
+    action.should == "bar"
+    controller.params[:id].should == '42'
+  end  
+  
   it "should not allow private and protected methods to be called" do
     controller, action = request(:get, '/foo/call_filters')
     controller.status.should == Merb::ControllerExceptions::ActionNotFound::STATUS

data/spec/merb/generator_spec.rb

@@ -25,7 +25,9 @@ describe "an app generator" do
   end
   
   it "should create directory structure" do
-    @generator.command(:create).invoke!
+    silence_generator do
+      @generator.command(:create).invoke!
+    end
     %w{
       app
       app/controllers
@@ -51,7 +53,9 @@ describe "an app generator" do
   end
     
   it "should create files from templates" do
-    @generator.command(:create).invoke!
+    silence_generator do
+      @generator.command(:create).invoke!
+    end
     %w{
       app/controllers/application.rb
       app/helpers/global_helper.rb
@@ -73,7 +77,9 @@ describe "an app generator" do
   end
   
   it "should create files from rubigen dependency" do
-    @generator.command(:create).invoke!
+    silence_generator do
+      @generator.command(:create).invoke!
+    end
     %w{
       script/generate
       script/destroy
@@ -81,7 +87,9 @@ describe "an app generator" do
   end
   
   it "should make script files executable" do
-    @generator.command(:create).invoke!
+    silence_generator do
+      @generator.command(:create).invoke!
+    end
     
     %w{
       script/stop_merb

data/spec/merb/mail_controller_spec.rb

@@ -6,6 +6,7 @@ module Merb
   end
 end
 Merb::Server.load_controller_template_path_cache
+Merb::Server.load_erubis_inline_helpers
 
 class Merb::Mailer
   self.delivery_method = :test_send
@@ -141,4 +142,36 @@ describe "A Merb Mail controller" do
     deliver :tenth
   end
   
+end
+
+describe "Merb::MailController with url generation" do
+  
+  it_should_behave_like "class with general url generation"
+  it_should_behave_like "non routeable controller with url mixin"
+  
+  def new_url_controller(route, params = {:action => 'show', :controller => 'Test'})
+    request = OpenStruct.new
+    request.route = route
+    request.params = params
+    response = OpenStruct.new
+    response.read = ""
+    
+    @controller = Merb::Controller.build(request, response)
+    TestMailController.new(params, @controller)
+  end
+  
+  it "should raise an error if no controller is specified and the base controller is not set" do
+    c = new_url_controller(@default_route, {})    
+    lambda do
+      the_url = c.url(:action => "bar")
+    end.should raise_error
+  end
+  
+  it "should use the base controller when it is set to generate a url when no :controller option is specified" do
+    c = new_url_controller(@defualt_route, :controller => "foo")
+    lambda do
+      the_url = c.url(:action => "bar")
+      the_url.should == "/foo/bar"
+    end.should_not raise_error    
+  end
 end

data/spec/merb/part_controller_spec.rb

@@ -89,4 +89,36 @@ describe "A Merb PartController" do
     controller.body.should match(/part_js_format/m)
   end
   
-end  
+end  
+
+describe "A Merb Part Controller with urls" do
+  
+  it_should_behave_like "class with general url generation"
+  it_should_behave_like "non routeable controller with url mixin"
+  
+  def new_url_controller(route, params = {:action => 'show', :controller => 'Test'})
+    request = OpenStruct.new
+    request.route = route
+    request.params = params
+    response = OpenStruct.new
+    response.read = ""
+    
+    @controller = Merb::Controller.build(request, response)
+    TodoPart.new(@controller)
+  end
+  
+  it "should use the web_controllers type if no controller is specified" do
+    c = new_url_controller(@default_route, :controller => "my_controller")
+    the_url = c.url(:action => "bar")
+    the_url.should == "/my_controller/bar"
+  end
+  
+  it "should raise an error if the web_controller's params[:controller] is not set" do
+    c = new_url_controller(@default_route, {})
+    lambda do
+      the_url = c.url(:action => "bar")
+      the_url.should == "/my_controller/bar"
+    end.should raise_error
+  end
+  
+end

data/spec/merb/render_spec.rb

@@ -21,6 +21,12 @@ describe "rendering engines except XMLBuilder", :shared => true do
     content.clean.should == "Locals!"
   end
 
+  it "should render a partial with nil locals" do
+    c = new_controller
+    content = c.partial "partials/#{@engine}", :yo => nil
+    content.clean.should == "No Locals!"
+  end
+
   it "should render a partial using the :partial method" do
     c = new_controller
     content = c.partial("partials/#{@engine}")
@@ -108,6 +114,14 @@ describe "rendering engines except XMLBuilder", :shared => true do
     content.should match( /Start Tester Block\s*In Tester Block\s*Finish Tester Block/m)
   end
 
+  it "should bind the concat to independent render buffers" do
+    c = new_controller
+    content = c.render :template => "template_views/interface_concat_#{@engine}", :layout => :none
+    content.should match( /Start Tester Block\s*In Tester Block\s*Finish Tester Block/m)
+    content = c.render :template => "template_views/interface_concat_#{@engine}", :layout => :none
+    content.should match( /Start Tester Block\s*In Tester Block\s*Finish Tester Block/m)
+  end
+  
   it "should implement a capture( &block ) method" do
     c = new_controller
     content = c.render :template => "template_views/interface_capture_#{@engine}", :layout => :none
@@ -368,6 +382,66 @@ describe "Merb rendering with an object calls to_json or to_xml on the object" d
   
 end
 
+describe "Merb rendering with an object calls to_json or to_xml on the object (using specified arguments)" do
+  
+  it "render @foo should call @foo.to_json when json is requested (using default options)" do
+    c = new_spec_controller(:format => 'json', :controller => 'RenderObjectWithArgumentsController')
+    c.provided_format_arguments_for(:json).should == ["foo", "bar"]
+    c.dispatch(:render_standard)
+    c.body.should == "['foo','bar']"
+  end
+  
+  it "render @foo should call @foo.to_json when json is requested (using action options)" do
+    c = new_spec_controller(:format => 'json', :controller => 'RenderObjectWithArgumentsController')
+    c.dispatch(:render_specific)
+    c.body.should == "['foo','bar','baz']"
+  end
+  
+  it "render @foo should call @foo.to_xml when xml is requested (using default options)" do
+    c = new_spec_controller(:format => 'xml', :controller => 'RenderObjectWithArgumentsController')
+    c.provided_format_arguments_for(:xml).should == [{:foo=>"bar"}]
+    c.dispatch(:render_standard)
+    c.body.should == "<foo>bar</foo>"
+  end
+  
+  it "render @foo should call @foo.to_xml when xml is requested (using action options)" do
+    c = new_spec_controller(:format => 'xml', :controller => 'RenderObjectWithArgumentsController')
+    c.dispatch(:render_specific)
+    c.body.should == "<biz>baz</biz><foo>bar</foo>"
+  end
+  
+end
+
+describe "Merb rendering with an object and using a block/lambda for provides" do
+  
+  it "render @foo should use the default block when xml is requested" do
+    c = new_spec_controller(:format => 'xml', :controller => 'RenderObjectWithBlockController')
+    c.provided_format_arguments_for(:xml).should be_kind_of(Proc)
+    c.dispatch(:render_standard)
+    c.body.should == "<foo>RenderObjectWithBlockController</foo>"
+  end
+  
+  it "render @foo should use the default block when json is requested" do
+    c = new_spec_controller(:format => 'json', :controller => 'RenderObjectWithBlockController')
+    c.provided_format_arguments_for(:json).should be_kind_of(Proc)
+    c.dispatch(:render_standard)
+    c.body.should == "['foo']"
+  end
+  
+  it "render @foo should use the specific proc when xml is requested" do
+    c = new_spec_controller(:format => 'xml', :controller => 'RenderObjectWithBlockController')
+    c.dispatch(:render_specific)
+    c.body.should == "<foo>RENDEROBJECTWITHBLOCKCONTROLLER</foo>"
+  end
+  
+  it "render @foo should use the specific proc when json is requested" do
+    c = new_spec_controller(:format => 'json', :controller => 'RenderObjectWithBlockController')
+    c.dispatch(:render_specific)
+    c.body.should == "['RenderObjectWithBlockController','foo','bar','baz']"
+  end
+  
+end
+
 def new_spec_controller(options={})
   params = {:controller => 'ExtensionTemplateController'}
   params.update(:format => options.delete(:format)) if options[:format]

data/spec/merb/request_spec.rb

@@ -132,6 +132,24 @@ describe Merb::Request do
     Merb::Request::parse_json_params = true
   end
   
+  it "should parse a JSON body into params when charset provided" do
+    @in.post_body = "{\"title\":\"hello there\",\"body\":\"some text\"}"
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = "text/x-json; charset=utf-8"
+    request = Merb::Request.new(@in)
+    request.params[:title].should == "hello there"
+    request.params[:body].should == "some text"
+  end
+  
+  it "should parse an XML body into params when charset provided" do
+    @in.post_body = "<root><title>hello there</title><body>some text</body></root>"
+    @in['REQUEST_METHOD'] = 'POST'
+    @in['CONTENT_TYPE'] = "text/xml; charset=utf-8"
+    request = Merb::Request.new(@in)
+    request.params[:root][:title].should == "hello there"
+    request.params[:root][:body].should == "some text"
+  end
+  
   it "should handle hash-style form fields in multipart/form-data" do
     m = Merb::Test::Multipart::Post.new :foo => 'bario',
          'files[foo][file]' => File.open(FIXTURES / 'foo.rb'),
@@ -240,4 +258,29 @@ describe Merb::Request do
     request = Merb::Request.new(@in)
     request.accept.should == "*/*"
   end
+  
+  it "should be able to tell you the HTTP method for POST requests without an error" do
+    @in['REQUEST_METHOD'] = 'POST'
+    request = Merb::Request.new(@in)
+    lambda {request.method}.should_not raise_error
+    request.method.should == :post
+  end
+  
+  it "should be able to tell you the HTTP method for GET requests without an error" do
+    @in['REQUEST_METHOD'] = 'GET'
+    request = Merb::Request.new(@in)
+    lambda {request.method}.should_not raise_error
+    request.method.should == :get
+  end
+  
+  it "multipart_params should return an empty hash if the request is not multipart" do
+    request = Merb::Request.new(@in)
+    request.send(:multipart_params).should == {}
+  end
+  
+  it "should add namespace to controller name" do
+    request = Merb::Request.new(@in)
+    request.stubs(:route_params).returns({:controller => 'bar', :namespace => 'foo'})
+    request.controller_name.should == "foo/bar"
+  end
 end

data/spec/merb/responder_spec.rb

@@ -244,6 +244,7 @@ end
 
 Merb::Server.load_action_arguments
 Merb::Server.load_controller_template_path_cache
+Merb::Server.load_erubis_inline_helpers
 
 describe "A Merb Responder's Content Negotiation" do
 

data/spec/merb/router_spec.rb

@@ -72,6 +72,15 @@ describe Merb::Router do
     Merb::Router.routes[0].should == r1
     Merb::Router.routes[1].should == r2
   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    
+  end
 
   # it "should be fast" do
   #   Merb::Router.prepare do |r|
@@ -177,13 +186,22 @@ describe Merb::Router, "when doing route matching with a big set of example rout
       r.match("/::/users/::").
         to(:controller => "users", :action => "[2]", :id => "[1]")
       
+      # Namespace can be used to specify the module
+      r.match('/bar').to(:controller => 'bar', :namespace => 'foo')
+      
+      # Namespace can be used to provide path prefix
+      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
-      # domain (e.g. admin.mysite.com), do some interesting stuff:
-      r.match(:domain => /^admin\b/) do |admin|
+      # host (e.g. admin.mysite.com), do some interesting stuff:
+      r.match(:host => /^admin\b/).to(:namespace => 'admin') do |admin|
         admin.match(%r[/([A-Z]\w+)\+([A-Z]\w+)/::]).
-          to(:controller => "admin/users", :action => ":path[3]",
+          to(:controller => "users", :action => ":path[3]",
             :first_name => ":path[1]", :last_name => ":path[2]")
-      end.to(:controller => "admin/users", :action => "default")
+      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.
 
@@ -313,25 +331,51 @@ describe Merb::Router, "when doing route matching with a big set of example rout
     should_only_have_keys(route, :controller, :action, :id)
   end
   
+  it "should use namespace" do
+    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)   
+  end
+  
+  it "should have namespace 'admin' if path is '/admin/foo'" do
+    index, route = Merb::Router.match(SimpleRequest.new(:path => '/admin/foo', :method => :get), {})
+    route[:namespace].should == 'admin'
+    route[:controller].should == 'foo'
+    route[:action].should == 'index' 
+    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)   
+  end
+  
   it "should send all admin.* domains to the 'admin/users' controller, and 'default' action" do
-    index, route = Merb::Router.match(SimpleRequest.new(:domain => "admin.mysite.com", :path => '/welcome', :protocol => "https://"), {})
-    route[:controller].should == "admin/users"
+    index, route = Merb::Router.match(SimpleRequest.new(:host => "admin.mysite.com", :path => '/welcome', :protocol => "https://"), {})
+    route[:namespace].should == "admin"
+    route[:controller].should == "users"
     route[:action].should == "default"
-    should_only_have_keys(route, :controller, :action)
+    should_only_have_keys(route, :namespace, :controller, :action)
     
-    index, route = Merb::Router.match(SimpleRequest.new(:domain => "admin.another-site.com", :path => '/go/somewhere/else', :protocol => "https://"), {})
-    route[:controller].should == "admin/users"
+    index, route = Merb::Router.match(SimpleRequest.new(:host => "admin.another-site.com", :path => '/go/somewhere/else', :protocol => "https://"), {})
+    route[:namespace].should == "admin"
+    route[:controller].should == "users"
     route[:action].should == "default"
-    should_only_have_keys(route, :controller, :action)
+    should_only_have_keys(route, :namespace, :controller, :action)
   end
   
   it "should decipher the first-name / last-name pairs on an admin.* domain" do
-    index, route = Merb::Router.match(SimpleRequest.new(:domain => "admin.mysite.com", :path => '/Duane+Johnson/edit', :protocol => "https://"), {})
-    route[:controller].should == "admin/users"
+    index, route = Merb::Router.match(SimpleRequest.new(:host => "admin.mysite.com", :path => '/Duane+Johnson/edit', :protocol => "https://"), {})
+    route[:namespace].should == "admin"
+    route[:controller].should == "users"    
     route[:action].should == "edit"
     route[:first_name].should == "Duane"
     route[:last_name].should == "Johnson"
-    should_only_have_keys(route, :controller, :action, :first_name, :last_name)
+    should_only_have_keys(route, :namespace, :controller, :action, :first_name, :last_name)
   end
   
   it "should defer to the Ajax controller for xhr requests" do
@@ -723,4 +767,65 @@ describe Merb::Router::Behavior, "class methods" do
     @b.array_to_code(["one string"]).should == "\"one string\""
     @b.array_to_code(["string", :var, :var2, "other"]).should == "\"string\" + var + var2 + \"other\""
   end
+end
+
+describe "Merb::Route", "rendered as a string" do
+  before(:all) do
+    Merb::Router.prepare do |r|
+      r.default_routes
+    end
+    @routes = Merb::Router.routes
+  end
+  
+  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
+    Merb::Router.prepare do |r|
+      #Declare one in the nested style
+      r.match(:host => /^.*$/).to(:namespace => 'admin') do |admin|
+        admin.resources :oranges
+      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
+    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'
+  end
+  
+  it "should generate new_admin_orange path" do
+    Merb::Router.generate(:new_admin_orange).should == '/oranges/new'
+  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'
+  end
+  
+  it "should generate edit_admin_ape path" do
+    Merb::Router.generate(:edit_admin_ape).should == '/ape/edit'
+  end  
+
 end