roda 2.2.0 → 2.3.0

data/spec/opts_spec.rb

@@ -4,14 +4,14 @@ describe "opts" do
   it "is inheritable and allows overriding" do
     c = Class.new(Roda)
     c.opts[:foo] = "bar"
-    c.opts[:foo].should == "bar"
+    c.opts[:foo].must_equal "bar"
 
     sc = Class.new(c)
-    sc.opts[:foo].should == "bar"
+    sc.opts[:foo].must_equal "bar"
 
     sc.opts[:foo] = "baz"
-    sc.opts[:foo].should == "baz"
-    c.opts[:foo].should == "bar"
+    sc.opts[:foo].must_equal "baz"
+    c.opts[:foo].must_equal "bar"
   end
 
   it "should be available as an instance methods" do
@@ -25,18 +25,18 @@ describe "opts" do
       end
     end
 
-    body.should == "Hello World"
+    body.must_equal "Hello World"
   end
 
   it "should only shallow clone by default" do
     c = Class.new(Roda)
     c.opts[:foo] = "bar"
-    c.opts[:foo].should == "bar"
+    c.opts[:foo].must_equal "bar"
 
     sc = Class.new(c)
     sc.opts[:foo].replace("baz")
 
-    sc.opts[:foo].should == "baz"
-    c.opts[:foo].should == "baz"
+    sc.opts[:foo].must_equal "baz"
+    c.opts[:foo].must_equal "baz"
   end
 end

data/spec/plugin/_erubis_escaping_spec.rb

@@ -21,7 +21,7 @@ describe "_erubis_escaping plugin" do
       end
     end
 
-    body.should == '&lt;&gt; <>'
+    body.must_equal '&lt;&gt; <>'
   end
 
   it "should consider classes in :escape_safe_classes as safe" do
@@ -36,7 +36,19 @@ describe "_erubis_escaping plugin" do
       end
     end
 
-    body.should == '&lt;&gt; <>'
+    body.must_equal '&lt;&gt; <>'
+  end
+
+  it "should covnert arguments to strings when escaping with safe classes" do
+    app(:bare) do
+      plugin :render, :escape=>true, :escape_safe_classes=>[]
+
+      route do |r|
+        render(:inline=>'<%= :"<>" %> <%== :"<>" %><%= :"<>" if false %>')
+      end
+    end
+
+    body.must_equal '&lt;&gt; <>'
   end
 
   it "should allow use of custom :escaper" do
@@ -52,7 +64,26 @@ describe "_erubis_escaping plugin" do
       end
     end
 
-    body.should == "ab''1 ab'1"
+    body.must_equal "ab''1 ab'1"
+  end
+
+  it "should allow for per-branch escaping via set_view options" do
+    app(:bare) do
+      plugin :render, :escape=>true
+      plugin :view_options
+
+      route do |r|
+        set_view_options :template_opts=>{:engine_class=>nil}
+        r.is 'a' do
+          set_view_options :template_opts=>{:engine_class=>render_opts[:template_opts][:engine_class]}
+          render(:inline=>'<%= "<>" %>')
+        end
+        render(:inline=>'<%= "<>" %>')
+      end
+    end
+
+    body('/a').must_equal '&lt;&gt;'
+    body.must_equal '<>'
   end
 end
 end

data/spec/plugin/all_verbs_spec.rb

@@ -15,15 +15,15 @@ describe "all_verbs plugin" do
       end
     end
 
-    body('REQUEST_METHOD'=>'DELETE').should == 'd'
-    body('REQUEST_METHOD'=>'HEAD').should == 'h'
-    body('REQUEST_METHOD'=>'OPTIONS').should == 'o'
-    body('REQUEST_METHOD'=>'PATCH').should == 'pa'
-    body('REQUEST_METHOD'=>'PUT').should == 'pu'
-    body('REQUEST_METHOD'=>'TRACE').should == 't'
+    body('REQUEST_METHOD'=>'DELETE').must_equal 'd'
+    body('REQUEST_METHOD'=>'HEAD').must_equal 'h'
+    body('REQUEST_METHOD'=>'OPTIONS').must_equal 'o'
+    body('REQUEST_METHOD'=>'PATCH').must_equal 'pa'
+    body('REQUEST_METHOD'=>'PUT').must_equal 'pu'
+    body('REQUEST_METHOD'=>'TRACE').must_equal 't'
     if Rack::Request.method_defined?(:link?)
-      body('REQUEST_METHOD'=>'LINK').should == 'l'
-      body('REQUEST_METHOD'=>'UNLINK').should == 'u'
+      body('REQUEST_METHOD'=>'LINK').must_equal 'l'
+      body('REQUEST_METHOD'=>'UNLINK').must_equal 'u'
     end
   end
 end

data/spec/plugin/assets_spec.rb

@@ -2,12 +2,16 @@ require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
 require 'fileutils'
 
 begin
-  for lib in %w'tilt sass'
-    require lib
+  begin
+  require 'tilt/sass'
+  rescue LoadError
+    for lib in %w'tilt sass'
+      require lib
+    end
+    run_tests = true
+  rescue LoadError
+    warn "#{lib} not installed, skipping assets plugin test"
   end
-  run_tests = true
-rescue LoadError
-  warn "#{lib} not installed, skipping assets plugin test"
 end
 
 if run_tests
@@ -50,127 +54,128 @@ if run_tests
     it 'assets_opts should use correct paths given options' do
       fpaths = [:js_path, :css_path, :compiled_js_path, :compiled_css_path]
       rpaths = [:js_prefix, :css_prefix, :compiled_js_prefix, :compiled_css_prefix]
-      app.assets_opts.values_at(*fpaths).should == %w"spec/assets/js/ spec/assets/css/ spec/assets/app spec/assets/app".map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == %w"assets/js/ assets/css/ assets/app assets/app"
+      app.assets_opts.values_at(*fpaths).must_equal %w"spec/assets/js/ spec/assets/css/ spec/assets/app spec/assets/app".map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal %w"assets/js/ assets/css/ assets/app assets/app"
 
       app.plugin :assets, :path=>'bar/', :public=>'foo/', :prefix=>'as/', :js_dir=>'j/', :css_dir=>'c/', :compiled_name=>'a'
-      app.assets_opts.values_at(*fpaths).should == %w"bar/j/ bar/c/ foo/as/a foo/as/a".map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == %w"as/j/ as/c/ as/a as/a"
+      app.assets_opts.values_at(*fpaths).must_equal %w"bar/j/ bar/c/ foo/as/a foo/as/a".map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal %w"as/j/ as/c/ as/a as/a"
 
       app.plugin :assets, :path=>'bar', :public=>'foo', :prefix=>'as', :js_dir=>'j', :css_dir=>'c', :compiled_name=>'a'
-      app.assets_opts.values_at(*fpaths).should == %w"bar/j/ bar/c/ foo/as/a foo/as/a".map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == %w"as/j/ as/c/ as/a as/a"
+      app.assets_opts.values_at(*fpaths).must_equal %w"bar/j/ bar/c/ foo/as/a foo/as/a".map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal %w"as/j/ as/c/ as/a as/a"
 
       app.plugin :assets, :compiled_js_dir=>'cj', :compiled_css_dir=>'cs', :compiled_path=>'cp'
-      app.assets_opts.values_at(*fpaths).should == %w"bar/j/ bar/c/ foo/cp/cj/a foo/cp/cs/a".map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == %w"as/j/ as/c/ as/cj/a as/cs/a"
+      app.assets_opts.values_at(*fpaths).must_equal %w"bar/j/ bar/c/ foo/cp/cj/a foo/cp/cs/a".map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal %w"as/j/ as/c/ as/cj/a as/cs/a"
 
       app.plugin :assets, :compiled_js_route=>'cjr', :compiled_css_route=>'ccr', :js_route=>'jr', :css_route=>'cr'
-      app.assets_opts.values_at(*fpaths).should == %w"bar/j/ bar/c/ foo/cp/cj/a foo/cp/cs/a".map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == %w"as/jr/ as/cr/ as/cjr/a as/ccr/a"
+      app.assets_opts.values_at(*fpaths).must_equal %w"bar/j/ bar/c/ foo/cp/cj/a foo/cp/cs/a".map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal %w"as/jr/ as/cr/ as/cjr/a as/ccr/a"
 
       app.plugin :assets, :compiled_js_route=>'cj', :compiled_css_route=>'cs', :js_route=>'j', :css_route=>'c'
-      app.assets_opts.values_at(*fpaths).should == %w"bar/j/ bar/c/ foo/cp/cj/a foo/cp/cs/a".map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == %w"as/j/ as/c/ as/cj/a as/cs/a"
+      app.assets_opts.values_at(*fpaths).must_equal %w"bar/j/ bar/c/ foo/cp/cj/a foo/cp/cs/a".map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal %w"as/j/ as/c/ as/cj/a as/cs/a"
 
       app.plugin :assets
-      app.assets_opts.values_at(*fpaths).should == %w"bar/j/ bar/c/ foo/cp/cj/a foo/cp/cs/a".map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == %w"as/j/ as/c/ as/cj/a as/cs/a"
+      app.assets_opts.values_at(*fpaths).must_equal %w"bar/j/ bar/c/ foo/cp/cj/a foo/cp/cs/a".map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal %w"as/j/ as/c/ as/cj/a as/cs/a"
 
       app.plugin :assets, :compiled_js_dir=>'', :compiled_css_dir=>nil, :compiled_js_route=>nil, :compiled_css_route=>nil
-      app.assets_opts.values_at(*fpaths).should == %w"bar/j/ bar/c/ foo/cp/a foo/cp/a".map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == %w"as/j/ as/c/ as/a as/a"
+      app.assets_opts.values_at(*fpaths).must_equal %w"bar/j/ bar/c/ foo/cp/a foo/cp/a".map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal %w"as/j/ as/c/ as/a as/a"
 
       app.plugin :assets, :js_dir=>'', :css_dir=>nil, :js_route=>nil, :css_route=>nil
-      app.assets_opts.values_at(*fpaths).should == %w"bar/ bar/ foo/cp/a foo/cp/a".map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == %w"as/ as/ as/a as/a"
+      app.assets_opts.values_at(*fpaths).must_equal %w"bar/ bar/ foo/cp/a foo/cp/a".map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal %w"as/ as/ as/a as/a"
 
       app.plugin :assets, :public=>''
-      app.assets_opts.values_at(*fpaths).should == %w"bar/ bar/ cp/a cp/a".map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == %w"as/ as/ as/a as/a"
+      app.assets_opts.values_at(*fpaths).must_equal %w"bar/ bar/ cp/a cp/a".map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal %w"as/ as/ as/a as/a"
 
       app.plugin :assets, :path=>'', :compiled_path=>nil
-      app.assets_opts.values_at(*fpaths).should == ['', '', 'a', 'a'].map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == ['as/', 'as/', 'as/a', 'as/a']
+      app.assets_opts.values_at(*fpaths).must_equal ['', '', 'a', 'a'].map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal ['as/', 'as/', 'as/a', 'as/a']
 
       app.plugin :assets, :prefix=>''
-      app.assets_opts.values_at(*fpaths).should == ['', '', 'a', 'a'].map{|s| File.join(Dir.pwd, s)}
-      app.assets_opts.values_at(*rpaths).should == ['', '', 'a', 'a']
+      app.assets_opts.values_at(*fpaths).must_equal ['', '', 'a', 'a'].map{|s| File.join(Dir.pwd, s)}
+      app.assets_opts.values_at(*rpaths).must_equal ['', '', 'a', 'a']
 
       app.plugin :assets, :compiled_name=>nil
-      app.assets_opts.values_at(*fpaths).should == ['', ''].map{|s| File.join(Dir.pwd, s)} + ['', ''].map{|s| File.join(Dir.pwd, s).chop}
-      app.assets_opts.values_at(*rpaths).should == ['', '', '', '']
+      app.assets_opts.values_at(*fpaths).must_equal ['', ''].map{|s| File.join(Dir.pwd, s)} + ['', ''].map{|s| File.join(Dir.pwd, s).chop}
+      app.assets_opts.values_at(*rpaths).must_equal ['', '', '', '']
     end
 
     it 'assets_opts should use headers and dependencies given options' do
       keys = [:css_headers, :js_headers, :dependencies]
-      app.assets_opts.values_at(*keys).should == [{'Content-Type'=>"text/css; charset=UTF-8"}, {'Content-Type'=>"application/javascript; charset=UTF-8"}, {}]
+      app.assets_opts.values_at(*keys).must_equal [{'Content-Type'=>"text/css; charset=UTF-8"}, {'Content-Type'=>"application/javascript; charset=UTF-8"}, {}]
 
       app.plugin :assets, :headers=>{'A'=>'B'}, :dependencies=>{'a'=>'b'}
-      app.assets_opts.values_at(*keys).should == [{'Content-Type'=>"text/css; charset=UTF-8", 'A'=>'B'}, {'Content-Type'=>"application/javascript; charset=UTF-8", 'A'=>'B'}, {'a'=>'b'}]
+      app.assets_opts.values_at(*keys).must_equal [{'Content-Type'=>"text/css; charset=UTF-8", 'A'=>'B'}, {'Content-Type'=>"application/javascript; charset=UTF-8", 'A'=>'B'}, {'a'=>'b'}]
 
       app.plugin :assets, :css_headers=>{'C'=>'D'}, :js_headers=>{'E'=>'F'}, :dependencies=>{'c'=>'d'}
-      app.assets_opts.values_at(*keys).should == [{'Content-Type'=>"text/css; charset=UTF-8", 'A'=>'B', 'C'=>'D'}, {'Content-Type'=>"application/javascript; charset=UTF-8", 'A'=>'B', 'E'=>'F'}, {'a'=>'b', 'c'=>'d'}]
+      app.assets_opts.values_at(*keys).must_equal [{'Content-Type'=>"text/css; charset=UTF-8", 'A'=>'B', 'C'=>'D'}, {'Content-Type'=>"application/javascript; charset=UTF-8", 'A'=>'B', 'E'=>'F'}, {'a'=>'b', 'c'=>'d'}]
 
       app.plugin :assets
-      app.assets_opts.values_at(*keys).should == [{'Content-Type'=>"text/css; charset=UTF-8", 'A'=>'B', 'C'=>'D'}, {'Content-Type'=>"application/javascript; charset=UTF-8", 'A'=>'B', 'E'=>'F'}, {'a'=>'b', 'c'=>'d'}]
+      app.assets_opts.values_at(*keys).must_equal [{'Content-Type'=>"text/css; charset=UTF-8", 'A'=>'B', 'C'=>'D'}, {'Content-Type'=>"application/javascript; charset=UTF-8", 'A'=>'B', 'E'=>'F'}, {'a'=>'b', 'c'=>'d'}]
 
       app.plugin :assets
-      app.assets_opts.values_at(*keys).should == [{'Content-Type'=>"text/css; charset=UTF-8", 'A'=>'B', 'C'=>'D'}, {'Content-Type'=>"application/javascript; charset=UTF-8", 'A'=>'B', 'E'=>'F'}, {'a'=>'b', 'c'=>'d'}]
+      app.assets_opts.values_at(*keys).must_equal [{'Content-Type'=>"text/css; charset=UTF-8", 'A'=>'B', 'C'=>'D'}, {'Content-Type'=>"application/javascript; charset=UTF-8", 'A'=>'B', 'E'=>'F'}, {'a'=>'b', 'c'=>'d'}]
 
       app.plugin :assets, :headers=>{'Content-Type'=>'C', 'E'=>'G'}
-      app.assets_opts.values_at(*keys).should == [{'Content-Type'=>"C", 'A'=>'B', 'C'=>'D', 'E'=>'G'}, {'Content-Type'=>"C", 'A'=>'B', 'E'=>'F'}, {'a'=>'b', 'c'=>'d'}]
+      app.assets_opts.values_at(*keys).must_equal [{'Content-Type'=>"C", 'A'=>'B', 'C'=>'D', 'E'=>'G'}, {'Content-Type'=>"C", 'A'=>'B', 'E'=>'F'}, {'a'=>'b', 'c'=>'d'}]
 
       app.plugin :assets, :css_headers=>{'A'=>'B1'}, :js_headers=>{'E'=>'F1'}, :dependencies=>{'c'=>'d1'}
-      app.assets_opts.values_at(*keys).should == [{'Content-Type'=>"C", 'A'=>'B1', 'C'=>'D', 'E'=>'G'}, {'Content-Type'=>"C", 'A'=>'B', 'E'=>'F1'}, {'a'=>'b', 'c'=>'d1'}]
+      app.assets_opts.values_at(*keys).must_equal [{'Content-Type'=>"C", 'A'=>'B1', 'C'=>'D', 'E'=>'G'}, {'Content-Type'=>"C", 'A'=>'B', 'E'=>'F1'}, {'a'=>'b', 'c'=>'d1'}]
     end
 
     it 'should handle rendering assets, linking to them, and accepting requests for them when not compiling' do
       html = body('/test')
-      html.scan(/<link/).length.should == 2
+      html.scan(/<link/).length.must_equal 2
       html =~ %r{href="(/assets/css/app\.scss)"}
       css = body($1)
       html =~ %r{href="(/assets/css/raw\.css)"}
       css2 = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/assets/js/head/app\.js)"}
       js = body($1)
-      css.should =~ /color: red;/
-      css2.should =~ /color: blue;/
-      js.should include('console.log')
+      css.must_match(/color: red;/)
+      css2.must_match(/color: blue;/)
+      js.must_include('console.log')
     end
 
     it 'should handle rendering assets, linking to them, and accepting requests for them  when :add_script_name app option is used' do
       app.opts[:add_script_name] = true
       app.plugin :assets
       html = body('/test', 'SCRIPT_NAME'=>'/foo')
-      html.scan(/<link/).length.should == 2
+      html.scan(/<link/).length.must_equal 2
       html =~ %r{href="/foo(/assets/css/app\.scss)"}
       css = body($1)
       html =~ %r{href="/foo(/assets/css/raw\.css)"}
       css2 = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="/foo(/assets/js/head/app\.js)"}
       js = body($1)
-      css.should =~ /color: red;/
-      css2.should =~ /color: blue;/
+      css.must_match(/color: red;/)
+      css2.must_match(/color: blue;/)
+      js.must_include('console.log')
     end
 
     it 'should handle rendering assets, linking to them, and accepting requests for them when not compiling, with different options' do
       app.plugin :assets, :path=>'spec/', :js_dir=>'assets/js', :css_dir=>'assets/css', :prefix=>'a',
         :js_route=>'foo', :css_route=>'bar', :add_suffix=>true, :css_opts=>{:style=>:compressed}
       html = body('/test')
-      html.scan(/<link/).length.should == 2
+      html.scan(/<link/).length.must_equal 2
       html =~ %r{href="(/a/bar/app\.scss.css)"}
       css = body($1)
       html =~ %r{href="(/a/bar/raw\.css.css)"}
       css2 = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/a/foo/head/app\.js.js)"}
       js = body($1)
-      css.should =~ /color:red\}/
-      css2.should =~ /color: blue;/
-      js.should include('console.log')
+      css.must_match(/color:red\}/)
+      css2.must_match(/color: blue;/)
+      js.must_include('console.log')
     end
 
     it 'should handle rendering assets, linking to them, and accepting requests for them when not compiling with a multi-level hash' do
@@ -183,17 +188,17 @@ if run_tests
         end
       end
       html = body('/test')
-      html.scan(/<link/).length.should == 2
+      html.scan(/<link/).length.must_equal 2
       html =~ %r{href="(/assets/css/app\.scss)"}
       css = body($1)
       html =~ %r{href="(/assets/css/raw\.css)"}
       css2 = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/assets/js/head/app\.js)"}
       js = body($1)
-      css.should =~ /color: red;/
-      css2.should =~ /color: blue;/
-      js.should include('console.log')
+      css.must_match(/color: red;/)
+      css2.must_match(/color: blue;/)
+      js.must_include('console.log')
     end
 
     it 'should handle :group_subdirs => false' do
@@ -206,31 +211,31 @@ if run_tests
         end
       end
       html = body('/test')
-      html.scan(/<link/).length.should == 2
+      html.scan(/<link/).length.must_equal 2
       html =~ %r{href="(/assets/css/app\.scss)"}
       css = body($1)
       html =~ %r{href="(/assets/css/raw\.css)"}
       css2 = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/assets/js/head/app\.js)"}
       js = body($1)
-      css.should =~ /color: red;/
-      css2.should =~ /color: blue;/
-      js.should include('console.log')
+      css.must_match(/color: red;/)
+      css2.must_match(/color: blue;/)
+      js.must_include('console.log')
     end
 
     it 'should handle compiling assets, linking to them, and accepting requests for them' do
       app.compile_assets
       html = body('/test')
-      html.scan(/<link/).length.should == 1
+      html.scan(/<link/).length.must_equal 1
       html =~ %r{href="(/assets/app\.[a-f0-9]{40}\.css)"}
       css = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
       js = body($1)
-      css.should =~ /color: ?red/
-      css.should =~ /color: ?blue/
-      js.should include('console.log')
+      css.must_match(/color: ?red/)
+      css.must_match(/color: ?blue/)
+      js.must_include('console.log')
     end
 
     it 'should handle compiling assets, linking to them, and accepting requests for them when :add_script_name app option is used' do
@@ -240,12 +245,12 @@ if run_tests
       html = body('/test', 'SCRIPT_NAME'=>'/foo')
       html =~ %r{href="/foo(/assets/app\.[a-f0-9]{40}\.css)"}
       css = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="/foo(/assets/app\.head\.[a-f0-9]{40}\.js)"}
       js = body($1)
-      css.should =~ /color: ?red/
-      css.should =~ /color: ?blue/
-      js.should include('console.log')
+      css.must_match(/color: ?red/)
+      css.must_match(/color: ?blue/)
+      js.must_include('console.log')
     end
 
     it 'should handle compiling assets, linking to them, and accepting requests for them, with different options' do
@@ -253,15 +258,15 @@ if run_tests
         :public=>'spec/assets', :path=>'spec', :compiled_js_route=>'foo', :compiled_css_route=>'bar'
       app.compile_assets
       html = body('/test')
-      html.scan(/<link/).length.should == 1
+      html.scan(/<link/).length.must_equal 1
       html =~ %r{href="(/a/bar/app\.[a-f0-9]{40}\.css)"}
       css = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/a/foo/app\.head\.[a-f0-9]{40}\.js)"}
       js = body($1)
-      css.should =~ /color: ?red/
-      css.should =~ /color: ?blue/
-      js.should include('console.log')
+      css.must_match(/color: ?red/)
+      css.must_match(/color: ?blue/)
+      js.must_include('console.log')
     end
 
     it 'should handle rendering assets, linking to them, and accepting requests for them when not compiling with a multi-level hash' do
@@ -275,15 +280,15 @@ if run_tests
         end
       end
       html = body('/test')
-      html.scan(/<link/).length.should == 1
+      html.scan(/<link/).length.must_equal 1
       html =~ %r{href="(/assets/app\.assets\.css\.[a-f0-9]{40}\.css)"}
       css = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/assets/app\.assets\.js\.head\.[a-f0-9]{40}\.js)"}
       js = body($1)
-      css.should =~ /color: ?red/
-      css.should =~ /color: ?blue/
-      js.should include('console.log')
+      css.must_match(/color: ?red/)
+      css.must_match(/color: ?blue/)
+      js.must_include('console.log')
     end
 
     it 'should handle rendering assets, linking to them, and accepting requests for them when not compiling with a multi-level hash when :add_script_name app option is used' do
@@ -298,15 +303,15 @@ if run_tests
         end
       end
       html = body('/test', 'SCRIPT_NAME'=>'/foo')
-      html.scan(/<link/).length.should == 1
+      html.scan(/<link/).length.must_equal 1
       html =~ %r{href="/foo(/assets/app\.assets\.css\.[a-f0-9]{40}\.css)"}
       css = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="/foo(/assets/app\.assets\.js\.head\.[a-f0-9]{40}\.js)"}
       js = body($1)
-      css.should =~ /color: ?red/
-      css.should =~ /color: ?blue/
-      js.should include('console.log')
+      css.must_match(/color: ?red/)
+      css.must_match(/color: ?blue/)
+      js.must_include('console.log')
     end
 
     it 'should handle :group_subdirs => false when compiling' do
@@ -320,189 +325,198 @@ if run_tests
         end
       end
       html = body('/test')
-      html.scan(/<link/).length.should == 1
+      html.scan(/<link/).length.must_equal 1
       html =~ %r{href="(/assets/app\.assets\.css\.[a-f0-9]{40}\.css)"}
       css = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/assets/app\.assets\.js\.head\.[a-f0-9]{40}\.js)"}
       js = body($1)
-      css.should =~ /color: ?red/
-      css.should =~ /color: ?blue/
-      js.should include('console.log')
+      css.must_match(/color: ?red/)
+      css.must_match(/color: ?blue/)
+      js.must_include('console.log')
     end
 
     it 'should handle automatically creating directories when compiling assets' do
       app.plugin :assets, :public=>'spec/public'
       app.compile_assets
       html = body('/test')
-      html.scan(/<link/).length.should == 1
+      html.scan(/<link/).length.must_equal 1
       html =~ %r{href="(/assets/app\.[a-f0-9]{40}\.css)"}
       css = body($1)
-      html.scan(/<script/).length.should == 1
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
       js = body($1)
-      css.should =~ /color: ?red/
-      css.should =~ /color: ?blue/
-      js.should include('console.log')
+      css.must_match(/color: ?red/)
+      css.must_match(/color: ?blue/)
+      js.must_include('console.log')
     end
 
     it 'should handle compiling only css assets' do
       app.compile_assets(:css)
       html = body('/test')
-      html.scan(/<link/).length.should == 1
+      html.scan(/<link/).length.must_equal 1
       html =~ %r{href="(/assets/app\.[a-f0-9]{40}\.css)"}
       css = body($1)
-      html.scan(/<script/).length.should == 0
-      css.should =~ /color: ?red/
-      css.should =~ /color: ?blue/
+      html.scan(/<script/).length.must_equal 0
+      css.must_match(/color: ?red/)
+      css.must_match(/color: ?blue/)
     end
 
     it 'should handle compiling only js assets' do
       app.compile_assets(:js)
       html = body('/test')
-      html.scan(/<link/).length.should == 0
-      html.scan(/<script/).length.should == 1
+      html.scan(/<link/).length.must_equal 0
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
       js = body($1)
-      js.should include('console.log')
+      js.must_include('console.log')
     end
 
     it 'should handle compiling asset subfolders' do
       app.compile_assets([:js, :head])
       html = body('/test')
-      html.scan(/<link/).length.should == 0
-      html.scan(/<script/).length.should == 1
+      html.scan(/<link/).length.must_equal 0
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
       js = body($1)
-      js.should include('console.log')
+      js.must_include('console.log')
     end
 
     it 'should handle compiling assets when only a single asset type is present' do
       app.plugin :assets, :css=>nil
       app.compile_assets
       html = body('/test')
-      html.scan(/<link/).length.should == 0
-      html.scan(/<script/).length.should == 1
+      html.scan(/<link/).length.must_equal 0
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
       js = body($1)
-      js.should include('console.log')
+      js.must_include('console.log')
     end
 
     it 'should handle compiling assets when an empty array is used' do
       app.plugin :assets, :css=>[]
       app.compile_assets
       html = body('/test')
-      html.scan(/<link/).length.should == 0
-      html.scan(/<script/).length.should == 1
+      html.scan(/<link/).length.must_equal 0
+      html.scan(/<script/).length.must_equal 1
       html =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
       js = body($1)
-      js.should include('console.log')
+      js.must_include('console.log')
     end
 
-    it '#assets should include attributes given' do
-      app.allocate.assets([:js, :head], 'a'=>'b').should == '<script type="text/javascript" a="b" src="/assets/js/head/app.js"></script>'
+    it '#assets must_include attributes given' do
+      app.allocate.assets([:js, :head], 'a'=>'b').must_equal '<script type="text/javascript" a="b" src="/assets/js/head/app.js"></script>'
     end
 
     it '#assets should escape attribute values given' do
-      app.allocate.assets([:js, :head], 'a'=>'b"e').should == '<script type="text/javascript" a="b&quot;e" src="/assets/js/head/app.js"></script>'
+      app.allocate.assets([:js, :head], 'a'=>'b"e').must_equal '<script type="text/javascript" a="b&quot;e" src="/assets/js/head/app.js"></script>'
     end
 
     it 'requests for assets should return 304 if the asset has not been modified' do
       loc = '/assets/js/head/app.js'
       lm = header('Last-Modified', loc)
-      status(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).should == 304
-      body(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).should == ''
+      status(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).must_equal 304
+      body(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).must_equal ''
     end
 
     it 'requests for assets should not return 304 if the asset has been modified' do
       loc = '/assets/js/head/app.js'
       lm = header('Last-Modified', loc)
       File.utime(js_atime, js_mtime+1, js_file)
-      status(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).should == 200
-      body(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).should include('console.log')
+      status(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).must_equal 200
+      body(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).must_include('console.log')
     end
 
     it 'requests for assets should return 304 if the dependency of an asset has not been modified' do
       app.plugin :assets, :dependencies=>{js_file=>css_file}
       loc = '/assets/js/head/app.js'
       lm = header('Last-Modified', loc)
-      status(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).should == 304
-      body(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).should == ''
+      status(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).must_equal 304
+      body(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).must_equal ''
     end
 
     it 'requests for assets should return 200 if the dependency of an asset has been modified' do
       app.plugin :assets, :dependencies=>{js_file=>css_file}
       loc = '/assets/js/head/app.js'
       lm = header('Last-Modified', loc)
-      File.utime(css_atime, [css_mtime+1, js_mtime+1].max, css_file)
-      status(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).should == 200
-      body(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).should include('console.log')
+      File.utime(css_atime, [css_mtime+2, js_mtime+2].max, css_file)
+      status(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).must_equal 200
+      body(loc, 'HTTP_IF_MODIFIED_SINCE'=>lm).must_include('console.log')
     end
 
     it 'should do a terminal match for assets' do
-      status('/assets/css/app.scss/foo').should == 404
+      status('/assets/css/app.scss/foo').must_equal 404
     end
 
     it 'should only allow files that you specify' do
-      status('/assets/css/no_access.css').should == 404
+      status('/assets/css/no_access.css').must_equal 404
     end
 
     it 'should not add routes for empty asset types' do
       app.plugin :assets, :css=>nil
       a = app::RodaRequest.assets_matchers
-      a.length.should == 1
-      a.first.length.should == 2
-      a.first.first.should == 'js'
-      'assets/js/head/app.js'.should =~ a.first.last
-      'assets/js/head/app2.js'.should_not =~ a.first.last
+      a.length.must_equal 1
+      a.first.length.must_equal 2
+      a.first.first.must_equal 'js'
+      'assets/js/head/app.js'.must_match a.first.last
+      'assets/js/head/app2.js'.wont_match a.first.last
     end
 
     it 'should not add routes if no asset types' do
       app.plugin :assets, :js=>nil, :css=>nil
-      app::RodaRequest.assets_matchers.should == []
+      app::RodaRequest.assets_matchers.must_equal []
     end
 
     it 'should support :precompiled option' do
       app.plugin :assets, :precompiled=>metadata_file
-      File.exist?(metadata_file).should == false
-      app.allocate.assets([:js, :head]).should == '<script type="text/javascript"  src="/assets/js/head/app.js"></script>'
+      File.exist?(metadata_file).must_equal false
+      app.allocate.assets([:js, :head]).must_equal '<script type="text/javascript"  src="/assets/js/head/app.js"></script>'
 
       app.compile_assets
-      File.exist?(metadata_file).should == true
-      app.allocate.assets([:js, :head]).should =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
+      File.exist?(metadata_file).must_equal true
+      app.allocate.assets([:js, :head]).must_match %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
 
       app.plugin :assets, :compiled=>false, :precompiled=>false
-      app.allocate.assets([:js, :head]).should == '<script type="text/javascript"  src="/assets/js/head/app.js"></script>'
+      app.allocate.assets([:js, :head]).must_equal '<script type="text/javascript"  src="/assets/js/head/app.js"></script>'
 
       app.plugin :assets, :precompiled=>metadata_file
-      app.allocate.assets([:js, :head]).should =~ %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
+      app.allocate.assets([:js, :head]).must_match %r{src="(/assets/app\.head\.[a-f0-9]{40}\.js)"}
+    end
+
+    it 'should work correctly with json plugin when r.assets is the last method called' do
+      app.plugin :assets
+      app.plugin :json
+      app.route do |r|
+        r.assets
+      end
+      status.must_equal 404
     end
   end
 
   describe 'assets plugin' do
     it "app :root option affects :views default" do
       app.plugin :assets
-      app.assets_opts[:path].should == File.join(Dir.pwd, 'assets')
-      app.assets_opts[:js_path].should == File.join(Dir.pwd, 'assets/js/')
-      app.assets_opts[:css_path].should == File.join(Dir.pwd, 'assets/css/')
+      app.assets_opts[:path].must_equal File.join(Dir.pwd, 'assets')
+      app.assets_opts[:js_path].must_equal File.join(Dir.pwd, 'assets/js/')
+      app.assets_opts[:css_path].must_equal File.join(Dir.pwd, 'assets/css/')
 
       app.opts[:root] = '/foo'
       app.plugin :assets
-      app.assets_opts[:path].should == '/foo/assets'
-      app.assets_opts[:js_path].should == '/foo/assets/js/'
-      app.assets_opts[:css_path].should == '/foo/assets/css/'
+      app.assets_opts[:path].must_equal '/foo/assets'
+      app.assets_opts[:js_path].must_equal '/foo/assets/js/'
+      app.assets_opts[:css_path].must_equal '/foo/assets/css/'
 
       app.opts[:root] = '/foo/bar'
       app.plugin :assets
-      app.assets_opts[:path].should == '/foo/bar/assets'
-      app.assets_opts[:js_path].should == '/foo/bar/assets/js/'
-      app.assets_opts[:css_path].should == '/foo/bar/assets/css/'
+      app.assets_opts[:path].must_equal '/foo/bar/assets'
+      app.assets_opts[:js_path].must_equal '/foo/bar/assets/js/'
+      app.assets_opts[:css_path].must_equal '/foo/bar/assets/css/'
 
       app.opts[:root] = nil
       app.plugin :assets
-      app.assets_opts[:path].should == File.join(Dir.pwd, 'assets')
-      app.assets_opts[:js_path].should == File.join(Dir.pwd, 'assets/js/')
-      app.assets_opts[:css_path].should == File.join(Dir.pwd, 'assets/css/')
+      app.assets_opts[:path].must_equal File.join(Dir.pwd, 'assets')
+      app.assets_opts[:js_path].must_equal File.join(Dir.pwd, 'assets/js/')
+      app.assets_opts[:css_path].must_equal File.join(Dir.pwd, 'assets/css/')
     end
   end
 end