roda 2.2.0 → 2.3.0

data/spec/plugin/padrino_render_spec.rb

@@ -24,11 +24,11 @@ describe "padrino_render plugin" do
   end
 
   it "render uses layout by default" do
-    body("/render").strip.should == "<title>Roda: Home</title>\nbar"
+    body("/render").strip.must_equal "<title>Roda: Home</title>\nbar"
   end
 
   it "render doesn't use layout if layout is nil" do
-    body("/render/nolayout").strip.should == "<h1>No Layout</h1>"
+    body("/render/nolayout").strip.must_equal "<h1>No Layout</h1>"
   end
 end
 end

data/spec/plugin/param_matchers_spec.rb

@@ -13,9 +13,9 @@ describe "param_matchers plugin" do
     end
 
     io = StringIO.new
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=john@doe.com").should == 'john@doe.com'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "").should == 'No email'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=").should == 'No email'
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=john@doe.com").must_equal 'john@doe.com'
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "").must_equal 'No email'
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=").must_equal 'No email'
   end
 
   it "param matcheshould yield a param only if given" do
@@ -30,8 +30,8 @@ describe "param_matchers plugin" do
     end
 
     io = StringIO.new
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=john@doe.com").should == 'john@doe.com'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "").should == 'No email'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=").should == ''
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=john@doe.com").must_equal 'john@doe.com'
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "").must_equal 'No email'
+    body("/signup", "rack.input" => io, "QUERY_STRING" => "email=").must_equal ''
   end
 end

data/spec/plugin/partials_spec.rb

@@ -28,15 +28,15 @@ else
     end
 
     it "partial renders without layout, and prepends _ to template" do
-      body("/partial").strip.should == "<h1>About Roda</h1>"
+      body("/partial").strip.must_equal "<h1>About Roda</h1>"
     end
 
     it "partial renders without layout, and prepends _ to template" do
-      body("/partial/subdir").strip.should == "<h1>Subdir: About Roda</h1>"
+      body("/partial/subdir").strip.must_equal "<h1>Subdir: About Roda</h1>"
     end
 
     it "partial handles inline partials" do
-      body("/partial/inline").strip.should == "Hello Agent Smith"
+      body("/partial/inline").strip.must_equal "Hello Agent Smith"
     end
 
   end

data/spec/plugin/pass_spec.rb

@@ -18,12 +18,12 @@ describe "pass plugin" do
       end
     end
 
-    body.should == 'root'
-    status('FOO'=>true).should == 404
-    body("/a").should == 'a'
-    body("/a/b").should == 'a'
-    body("/foo/a").should == 'fooa'
-    body("/foo/a/b").should == 'fooa'
-    status("/foo").should == 404
+    body.must_equal 'root'
+    status('FOO'=>true).must_equal 404
+    body("/a").must_equal 'a'
+    body("/a/b").must_equal 'a'
+    body("/foo/a").must_equal 'fooa'
+    body("/foo/a/b").must_equal 'fooa'
+    status("/foo").must_equal 404
   end
 end

data/spec/plugin/path_matchers_spec.rb

@@ -10,8 +10,8 @@ describe "path_matchers plugin" do
       end
     end
 
-    body("/css/reset.css").should == 'reset'
-    status("/css/reset.bar").should == 404
+    body("/css/reset.css").must_equal 'reset'
+    status("/css/reset.bar").must_equal 404
   end
 
   it ":suffix matcher should match given suffix" do
@@ -23,8 +23,8 @@ describe "path_matchers plugin" do
       end
     end
 
-    body("/css/reset.css").should == 'reset'
-    status("/css/reset.bar").should == 404
+    body("/css/reset.css").must_equal 'reset'
+    status("/css/reset.bar").must_equal 404
   end
 
   it ":prefix matcher should match given prefix" do
@@ -36,7 +36,7 @@ describe "path_matchers plugin" do
       end
     end
 
-    body("/css/reset.css").should == '.css'
-    status("/css/foo.bar").should == 404
+    body("/css/reset.css").must_equal '.css'
+    status("/css/foo.bar").must_equal 404
   end
 end

data/spec/plugin/path_rewriter_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "path_rewriter plugin" do 
+  it "allows rewriting remaining path or PATH_INFO" do
+    app(:bare) do
+      plugin :path_rewriter
+      rewrite_path '/1', '/a'
+      rewrite_path '/a', '/b'
+      rewrite_path '/c', '/d', :path_info=>true
+      rewrite_path '/2', '/1', :path_info=>true
+      rewrite_path '/3', '/h'
+      rewrite_path '/3', '/g', :path_info=>true
+      rewrite_path(/\A\/e\z/, '/f')
+      route do |r|
+        "#{r.path_info}:#{r.remaining_path}"
+      end
+    end
+
+    body('/a').must_equal '/a:/b'
+    body('/a/f').must_equal '/a/f:/b/f'
+    body('/b').must_equal '/b:/b'
+    body('/c').must_equal '/d:/d'
+    body('/c/f').must_equal '/d/f:/d/f'
+    body('/d').must_equal '/d:/d'
+    body('/e').must_equal '/e:/f'
+    body('/e/g').must_equal '/e/g:/e/g'
+    body('/1').must_equal '/1:/b'
+    body('/1/f').must_equal '/1/f:/b/f'
+    body('/2').must_equal '/1:/b'
+    body('/2/f').must_equal '/1/f:/b/f'
+    body('/3').must_equal '/g:/g'
+    
+    app.freeze
+    body('/a').must_equal '/a:/b'
+    proc{app.rewrite_path '/a', '/b'}.must_raise FrozenError
+  end
+end

data/spec/plugin/path_spec.rb

@@ -4,7 +4,7 @@ describe "path plugin" do
   def path_app(*args, &block)
     app(:bare) do
       plugin :path
-      path *args, &block
+      path(*args, &block)
       route{|r| send(r.path_info)}
     end
   end
@@ -13,7 +13,7 @@ describe "path plugin" do
     app(:bare) do
       opts[:add_script_name] = true
       plugin :path
-      path *args, &block
+      path(*args, &block)
       route{|r| send(r.path_info)}
     end
   end
@@ -39,75 +39,75 @@ describe "path plugin" do
       end
     end
 
-    body.should == '/foo/bar/a/baz/b'
+    body.must_equal '/foo/bar/a/baz/b'
   end
 
   it "raises if both path and block are given" do
     app.plugin :path
-    proc{app.path(:foo, '/foo'){}}.should raise_error(Roda::RodaError)
+    proc{app.path(:foo, '/foo'){}}.must_raise(Roda::RodaError)
   end
 
   it "raises if neither path nor block are given" do
     app.plugin :path
-    proc{app.path(:foo)}.should raise_error(Roda::RodaError)
+    proc{app.path(:foo)}.must_raise(Roda::RodaError)
   end
 
   it "raises if two options hashes are given" do
     app.plugin :path
-    proc{app.path(:foo, {:name=>'a'}, :add_script_name=>true)}.should raise_error(Roda::RodaError)
+    proc{app.path(:foo, {:name=>'a'}, :add_script_name=>true)}.must_raise(Roda::RodaError)
   end
 
   it "supports :name option for naming the method" do
     path_app(:foo, :name=>'foobar_route'){"/bar/foo"}
-    body("foobar_route").should == "/bar/foo"
+    body("foobar_route").must_equal "/bar/foo"
   end
 
   it "supports :add_script_name option for automatically adding the script name" do
     path_app(:foo, :add_script_name=>true){"/bar/foo"}
-    body("foo_path", 'SCRIPT_NAME'=>'/baz').should == "/baz/bar/foo"
+    body("foo_path", 'SCRIPT_NAME'=>'/baz').must_equal "/baz/bar/foo"
   end
 
   it "respects :add_script_name app option for automatically adding the script name" do
     path_script_name_app(:foo){"/bar/foo"}
-    body("foo_path", 'SCRIPT_NAME'=>'/baz').should == "/baz/bar/foo"
+    body("foo_path", 'SCRIPT_NAME'=>'/baz').must_equal "/baz/bar/foo"
   end
 
   it "supports :add_script_name=>false option for not automatically adding the script name" do
     path_script_name_app(:foo, :add_script_name=>false){"/bar/foo"}
-    body("foo_path", 'SCRIPT_NAME'=>'/baz').should == "/bar/foo"
+    body("foo_path", 'SCRIPT_NAME'=>'/baz').must_equal "/bar/foo"
   end
 
   it "supports path method accepting a block when using :add_script_name" do
     path_block_app(lambda{"c"}, :foo, :add_script_name=>true){|&block| "/bar/foo/#{block.call}"}
-    body("foo_path", 'SCRIPT_NAME'=>'/baz').should == "/baz/bar/foo/c"
+    body("foo_path", 'SCRIPT_NAME'=>'/baz').must_equal "/baz/bar/foo/c"
   end
 
   it "supports :url option for also creating a *_url method" do
     path_app(:foo, :url=>true){"/bar/foo"}
-    body("foo_path", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).should == "/bar/foo"
-    body("foo_url", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).should == "http://example.org/bar/foo"
+    body("foo_path", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).must_equal "/bar/foo"
+    body("foo_url", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).must_equal "http://example.org/bar/foo"
   end
 
   it "supports url method accepting a block when using :url" do
     path_block_app(lambda{"c"}, :foo, :url=>true){|&block| "/bar/foo/#{block.call}"}
-    body("foo_url", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).should == "http://example.org/bar/foo/c"
+    body("foo_url", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).must_equal "http://example.org/bar/foo/c"
   end
 
   it "supports url method name specified in :url option" do
     path_app(:foo, :url=>:foobar_uri){"/bar/foo"}
-    body("foo_path", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).should == "/bar/foo"
-    body("foobar_uri", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).should == "http://example.org/bar/foo"
+    body("foo_path", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).must_equal "/bar/foo"
+    body("foobar_uri", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).must_equal "http://example.org/bar/foo"
   end
 
   it "supports :url_only option for not creating a path method" do
     path_app(:foo, :url_only=>true){"/bar/foo"}
-    proc{body("foo_path")}.should raise_error(NoMethodError)
-    body("foo_url", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).should == "http://example.org/bar/foo"
+    proc{body("foo_path")}.must_raise(NoMethodError)
+    body("foo_url", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>80).must_equal "http://example.org/bar/foo"
   end
 
   it "handles non-default ports in url methods" do
     path_app(:foo, :url=>true){"/bar/foo"}
-    body("foo_url", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>81).should == "http://example.org:81/bar/foo"
+    body("foo_url", 'HTTP_HOST'=>'example.org', "rack.url_scheme"=>'http', 'SERVER_PORT'=>81).must_equal "http://example.org:81/bar/foo"
   end
 end
 
@@ -127,42 +127,42 @@ describe "path plugin" do
 
   it "Roda#path respects classes and symbols registered via Roda.path" do
     # Strings
-    body('path'=>'/foo/bar').should == '/foo/bar'
+    body('path'=>'/foo/bar').must_equal '/foo/bar'
 
     # Classes
-    body('path'=>@obj).should == '/d/1/'
-    body('path'=>[@obj, 'foo']).should == '/d/1/foo'
-    body('path'=>[@obj, 'foo', 'bar']).should == '/d/1/foo/bar'
+    body('path'=>@obj).must_equal '/d/1/'
+    body('path'=>[@obj, 'foo']).must_equal '/d/1/foo'
+    body('path'=>[@obj, 'foo', 'bar']).must_equal '/d/1/foo/bar'
   end
 
   it "Roda#path raises an error for an unrecognized class" do
     # Strings
-    proc{body('path'=>:foo)}.should raise_error(Roda::RodaError)
+    proc{body('path'=>:foo)}.must_raise(Roda::RodaError)
   end
 
   it "Roda#path respects :add_script_name app option" do
     app.opts[:add_script_name] = true
 
     # Strings
-    body('path'=>'/foo/bar', 'SCRIPT_NAME'=>'/baz').should == '/baz/foo/bar'
+    body('path'=>'/foo/bar', 'SCRIPT_NAME'=>'/baz').must_equal '/baz/foo/bar'
 
     # Classes
-    body('path'=>@obj, 'SCRIPT_NAME'=>'/baz').should == '/baz/d/1/'
-    body('path'=>[@obj, 'foo'], 'SCRIPT_NAME'=>'/baz').should == '/baz/d/1/foo'
-    body('path'=>[@obj, 'foo', 'bar'], 'SCRIPT_NAME'=>'/baz').should == '/baz/d/1/foo/bar'
+    body('path'=>@obj, 'SCRIPT_NAME'=>'/baz').must_equal '/baz/d/1/'
+    body('path'=>[@obj, 'foo'], 'SCRIPT_NAME'=>'/baz').must_equal '/baz/d/1/foo'
+    body('path'=>[@obj, 'foo', 'bar'], 'SCRIPT_NAME'=>'/baz').must_equal '/baz/d/1/foo/bar'
   end
 
   it "Roda#path works in subclasses" do
     old_app = @app
     @app = Class.new(@app)
     @app.route{|r| path('/a')}
-    body.should == '/a'
+    body.must_equal '/a'
 
     @app.path(String){|b| "/foo#{b}"}
-    body.should == '/foo/a'
+    body.must_equal '/foo/a'
 
     @app = old_app
-    body('path'=>'/a').should == '/a'
+    body('path'=>'/a').must_equal '/a'
   end
 
   it "registers classes by reference by default" do
@@ -172,8 +172,8 @@ describe "path plugin" do
     def c2.name; 'C'; end
     @app.path(c1){'/c'}
     @app.route{|r| path(r.env['c'])}
-    body('c'=>c1.new).should == '/c'
-    proc{body('c'=>c2.new)}.should raise_error(Roda::RodaError)
+    body('c'=>c1.new).must_equal '/c'
+    proc{body('c'=>c2.new)}.must_raise(Roda::RodaError)
   end
 
   it ":by_name => option registers classes by name" do
@@ -184,29 +184,30 @@ describe "path plugin" do
     @app.plugin :path, :by_name=>true
     @app.path(c1){'/c'}
     @app.route{|r| path(r.env['c'])}
-    body('c'=>c1.new).should == '/c'
-    body('c'=>c2.new).should == '/c'
+    body('c'=>c1.new).must_equal '/c'
+    body('c'=>c2.new).must_equal '/c'
   end
 
   it "Roda.path_block returns the block used" do
     c = Class.new
     b = proc{|x| x.to_s}
     @app.path(c, &b)
-    @app.path_block(c).should == b
+    # Work around minitest bug
+    assert_equal @app.path_block(c), b
   end
 
   it "Roda.path doesn't work with classes without blocks" do
-    proc{app.path(Class.new)}.should raise_error(Roda::RodaError)
+    proc{app.path(Class.new)}.must_raise(Roda::RodaError)
   end
 
   it "Roda.path doesn't work with classes with paths or options" do
-    proc{app.path(Class.new, '/a'){}}.should raise_error(Roda::RodaError)
-    proc{app.path(Class.new, nil, :a=>1){}}.should raise_error(Roda::RodaError)
+    proc{app.path(Class.new, '/a'){}}.must_raise(Roda::RodaError)
+    proc{app.path(Class.new, nil, :a=>1){}}.must_raise(Roda::RodaError)
   end
 
   it "Roda.path doesn't work after freezing the app" do
     app.freeze
-    proc{app.path(Class.new){|obj| ''}}.should raise_error
+    proc{app.path(Class.new){|obj| ''}}.must_raise FrozenError
   end
 end
 

data/spec/plugin/per_thread_caching_spec.rb

@@ -16,12 +16,12 @@ describe "per_thread_caching plugin" do
     (0..10).map do |n|
       Thread.new do
         Thread.current[:n] = n
-        body('/a').should == '2'
-        body('/a').should == '22'
-        body('/a').should == '222'
-        body('/b').should == '2'
-        body('/b').should == '22'
-        body('/b').should == '222'
+        _(body('/a')).must_equal '2'
+        _(body('/a')).must_equal '22'
+        _(body('/a')).must_equal '222'
+        _(body('/b')).must_equal '2'
+        _(body('/b')).must_equal '22'
+        _(body('/b')).must_equal '222'
       end
     end.map{|t| t.join}
   end

data/spec/plugin/precompile_templates_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+begin
+  require 'tilt/erb'
+rescue LoadError
+  warn "tilt not installed, skipping precompiled_templates plugin test"  
+else
+describe "precompile_templates plugin" do 
+  it "adds support for template precompilation" do
+    app(:bare) do
+      plugin :render, :views=>'spec/views'
+      plugin :precompile_templates
+      route do |r|
+        @a = 1
+        render('iv')
+      end
+    end
+
+    app.render_opts[:cache][File.expand_path('spec/views/iv.erb')].must_equal nil
+    app.precompile_templates 'spec/views/iv.erb'
+    app.render_opts[:cache][File.expand_path('spec/views/iv.erb')].wont_equal nil
+    app.render_opts[:cache][File.expand_path('spec/views/iv.erb')].instance_variable_get(:@compiled_method)[[]].wont_equal nil
+    body.strip.must_equal '1'
+  end
+
+  it "adds support for template precompilation with :locals" do
+    app(:bare) do
+      plugin :render, :views=>'spec/views'
+      plugin :precompile_templates
+      route do |r|
+        render('about', :locals=>{:title=>'1'})
+      end
+    end
+
+    app.render_opts[:cache][File.expand_path('spec/views/about.erb')].must_equal nil
+    app.precompile_templates 'spec/views/about.erb', :locals=>[:title]
+    app.render_opts[:cache][File.expand_path('spec/views/about.erb')].wont_equal nil
+    app.render_opts[:cache][File.expand_path('spec/views/about.erb')].instance_variable_get(:@compiled_method)[[:title]].wont_equal nil
+    body.strip.must_equal '<h1>1</h1>'
+  end
+
+  it "adds support for template precompilation with sorting :locals" do
+    app(:bare) do
+      plugin :render, :views=>'spec/views'
+      plugin :precompile_templates, :sort_locals=>true
+      route do |r|
+        render('home', :locals=>{:name => "Agent Smith", :title => "Home"})
+      end
+    end
+
+    app.render_opts[:cache][File.expand_path('spec/views/home.erb')].must_equal nil
+    app.precompile_templates 'spec/views/h*.erb', :locals=>[:title, :name]
+    app.render_opts[:cache][File.expand_path('spec/views/home.erb')].wont_equal nil
+    app.render_opts[:cache][File.expand_path('spec/views/home.erb')].instance_variable_get(:@compiled_method)[[:name, :title]].wont_equal nil
+    body.strip.must_equal "<h1>Home</h1>\n<p>Hello Agent Smith</p>"
+  end
+
+  it "adds support for template precompilation with :inline" do
+    app(:bare) do
+      plugin :render, :views=>'spec/views'
+      plugin :precompile_templates
+      route do |r|
+        render(:inline=>'a', :cache_key=>'a')
+      end
+    end
+
+    app.render_opts[:cache]['a'].must_equal nil
+    app.precompile_templates :inline=>'a', :cache_key=>'a'
+    app.render_opts[:cache]['a'].wont_equal nil
+    app.render_opts[:cache]['a'].instance_variable_get(:@compiled_method)[[]].wont_equal nil
+    body.strip.must_equal "a"
+  end
+end
+end