roda 3.28.0 → 3.29.0

data/spec/plugin/param_matchers_spec.rb

@@ -1,69 +0,0 @@
-require_relative "../spec_helper"
-
-describe "param_matchers plugin" do 
-  it "param! matcher should yield a param only if given and not empty" do
-    app(:param_matchers) do |r|
-      r.get "signup", :param! => "email" do |email|
-        email
-      end
-
-      "No email"
-    end
-
-    io = StringIO.new
-    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 matcher should yield a param only if given" do
-    app(:param_matchers) do |r|
-      r.get "signup", :param=>"email" do |email|
-        email
-      end
-
-      "No email"
-    end
-
-    io = StringIO.new
-    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
-
-  it "params! matcher should yield the params only if all are given and not empty" do
-    app(:param_matchers) do |r|
-      r.get "signup", :params! => %w"em ail" do |em, ail|
-        em + ail
-      end
-
-      "No email"
-    end
-
-    io = StringIO.new
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "em=foo&ail=john@doe.com").must_equal 'foojohn@doe.com'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "em=&ail=john@doe.com").must_equal 'No email'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "em=foo&ail=").must_equal 'No email'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "em=&ail=").must_equal 'No email'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "em=foo").must_equal 'No email'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "ail=john@doe.com").must_equal 'No email'
-  end
-
-  it "params matcher should yield the params only if all are given" do
-    app(:param_matchers) do |r|
-      r.get "signup", :params=>%w"em ail" do |em, ail|
-        em + ail
-      end
-
-      "No email"
-    end
-
-    io = StringIO.new
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "em=foo&ail=john@doe.com").must_equal 'foojohn@doe.com'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "em=&ail=john@doe.com").must_equal 'john@doe.com'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "em=foo&ail=").must_equal 'foo'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "em=&ail=").must_equal ''
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "em=foo").must_equal 'No email'
-    body("/signup", "rack.input" => io, "QUERY_STRING" => "ail=john@doe.com").must_equal 'No email'
-  end
-end

data/spec/plugin/params_capturing_spec.rb

@@ -1,33 +0,0 @@
-require_relative "../spec_helper"
-
-describe "params_capturing plugin" do 
-  it "should add captures to r.params for symbol matchers" do
-    app(:params_capturing) do |r|
-      r.on('foo', :y, :z, :w) do |y, z, w|
-        (r.params.values_at('y', 'z', 'w') + [y, z, w, r.params['captures'].length]).join('-')
-      end
-
-      r.on(/(quux)/, /(foo)(bar)/) do |q, foo, bar|
-        "y-#{r.params['captures'].join}-#{q}-#{foo}-#{bar}"
-      end
-
-      r.on(/(quux)/, :y) do |q, y|
-        r.on(:x) do |x|
-          "y-#{r.params['y']}-#{r.params['x']}-#{q}-#{y}-#{x}-#{r.params['captures'].length}"
-        end
-
-        "y-#{r.params['y']}-#{q}-#{y}-#{r.params['captures'].length}"
-      end
-
-      r.on(:x) do |x|
-        "x-#{x}-#{r.params['x']}-#{r.params['captures'].length}"
-      end
-    end
-
-    body('/blarg', 'rack.input'=>StringIO.new).must_equal 'x-blarg-blarg-1'
-    body('/foo/1/2/3', 'rack.input'=>StringIO.new).must_equal '1-2-3-1-2-3-3'
-    body('/quux/foobar', 'rack.input'=>StringIO.new).must_equal 'y-quuxfoobar-quux-foo-bar'
-    body('/quux/asdf', 'rack.input'=>StringIO.new).must_equal 'y--quux-asdf-2'
-    body('/quux/asdf/890', 'rack.input'=>StringIO.new).must_equal 'y--890-quux-asdf-890-3'
-  end
-end

data/spec/plugin/partials_spec.rb

@@ -1,43 +0,0 @@
-require_relative "../spec_helper"
-
-begin
-  require 'tilt/erb'
-rescue LoadError
-  warn "tilt not installed, skipping partials plugin test"  
-else
-  describe "partials plugin" do
-    before do
-      app(:bare) do
-        plugin :partials, :views=>"./spec/views"
-
-        route do |r|
-          r.is "partial" do
-            partial("test", :locals=>{:title => "About Roda"})
-          end
-
-          r.is "partial/subdir" do
-            partial("about/test", :locals=>{:title => "About Roda"})
-          end
-
-          r.is "partial/inline" do
-            partial(:inline=>"Hello <%= name %>", :locals=>{:name => "Agent Smith"})
-          end
-        
-        end
-      end
-    end
-
-    it "partial renders without layout, and prepends _ to template" do
-      body("/partial").strip.must_equal "<h1>About Roda</h1>"
-    end
-
-    it "partial renders without layout, and prepends _ to template" do
-      body("/partial/subdir").strip.must_equal "<h1>Subdir: About Roda</h1>"
-    end
-
-    it "partial handles inline partials" do
-      body("/partial/inline").strip.must_equal "Hello Agent Smith"
-    end
-
-  end
-end

data/spec/plugin/pass_spec.rb

@@ -1,29 +0,0 @@
-require_relative "../spec_helper"
-
-describe "pass plugin" do 
-  it "skips the current block if pass is called" do
-    app(:pass) do |r|
-      r.root do
-        r.pass if env['FOO']
-        'root'
-      end
-
-      r.on :id do |id|
-        r.pass if id == 'foo'
-        id
-      end
-
-      r.on :x, :y do |x, y|
-        x + y
-      end
-    end
-
-    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

@@ -1,42 +0,0 @@
-require_relative "../spec_helper"
-
-describe "path_matchers plugin" do 
-  it ":extension matcher should match given file extension" do
-    app(:path_matchers) do |r|
-      r.on "css" do
-        r.on :extension=>"css" do |file|
-          file
-        end
-      end
-    end
-
-    body("/css/reset.css").must_equal 'reset'
-    status("/css/reset.bar").must_equal 404
-  end
-
-  it ":suffix matcher should match given suffix" do
-    app(:path_matchers) do |r|
-      r.on "css" do
-        r.on :suffix=>".css" do |file|
-          file
-        end
-      end
-    end
-
-    body("/css/reset.css").must_equal 'reset'
-    status("/css/reset.bar").must_equal 404
-  end
-
-  it ":prefix matcher should match given prefix" do
-    app(:path_matchers) do |r|
-      r.on "css" do
-        r.on :prefix=>"reset" do |file|
-          file
-        end
-      end
-    end
-
-    body("/css/reset.css").must_equal '.css'
-    status("/css/foo.bar").must_equal 404
-  end
-end

data/spec/plugin/path_rewriter_spec.rb

@@ -1,45 +0,0 @@
-require_relative "../spec_helper"
-
-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')
-      rewrite_path(/\A\/(dynamic1)/){|match| "/#{match[1].capitalize}"}
-      rewrite_path(/\A\/(dynamic2)/, :path_info=>true){|match| "/#{match[1].capitalize}"}
-      proc{rewrite_path('/a', '/z'){|match| "/x"}}.must_raise(Roda::RodaError)
-      proc{rewrite_path('/a', {:path_info=>true}, :path_info=>true)}.must_raise(Roda::RodaError)
-      proc{rewrite_path('/a', {:path_info=>true}, :path_info=>true){|match| "/x"}}.must_raise(Roda::RodaError)
-
-      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'
-    body('/dynamic1').must_equal '/dynamic1:/Dynamic1'
-    body('/dynamic2').must_equal '/Dynamic2:/Dynamic2'
-
-    app.freeze
-    body('/a').must_equal '/a:/b'
-    proc{app.rewrite_path '/a', '/b'}.must_raise
-  end
-end

data/spec/plugin/path_spec.rb

@@ -1,222 +0,0 @@
-require_relative "../spec_helper"
-
-describe "path plugin" do 
-  def path_app(*args, &block)
-    app(:bare) do
-      plugin :path
-      path(*args, &block)
-      route{|r| send(r.path_info)}
-    end
-  end
-
-  def path_script_name_app(*args, &block)
-    app(:bare) do
-      opts[:add_script_name] = true
-      plugin :path
-      path(*args, &block)
-      route{|r| send(r.path_info)}
-    end
-  end
-
-  def path_block_app(b, *args, &block)
-    path_app(*args, &block)
-    app.route{|r| send(r.path_info, &b)}
-  end
-
-  it "adds path method for defining named paths" do
-    app(:bare) do
-      plugin :path
-      path :foo, "/foo"
-      path :bar do |o|
-        "/bar/#{o}"
-      end
-      path :baz do |&block|
-        "/baz/#{block.call}"
-      end
-
-      route do |r|
-        "#{foo_path}#{bar_path('a')}#{baz_path{'b'}}"
-      end
-    end
-
-    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'){}}.must_raise(Roda::RodaError)
-  end
-
-  it "raises if neither path nor block are given" do
-    app.plugin :path
-    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)}.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").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').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').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').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').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).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).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).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")}.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).must_equal "http://example.org:81/bar/foo"
-  end
-end
-
-describe "path plugin" do 
-  before do
-    app(:bare) do
-      plugin :path
-      route{|r| path(*env['path'])}
-    end
-
-
-    c = Class.new{attr_accessor :a}
-    app.path(c){|obj, *args| "/d/#{obj.a}/#{File.join(*args)}"}
-    @obj = c.new
-    @obj.a = 1
-  end
-
-  it "Roda#path respects classes and symbols registered via Roda.path" do
-    # Strings
-    body('path'=>'/foo/bar').must_equal '/foo/bar'
-
-    # Classes
-    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)}.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').must_equal '/baz/foo/bar'
-
-    # Classes
-    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.must_equal '/a'
-
-    @app.path(String){|b| "/foo#{b}"}
-    body.must_equal '/foo/a'
-
-    @app = old_app
-    body('path'=>'/a').must_equal '/a'
-  end
-
-  it "registers classes by reference by default" do
-    c1 = Class.new
-    def c1.name; 'C'; end
-    c2 = Class.new
-    def c2.name; 'C'; end
-    @app.path(c1){'/c'}
-    @app.route{|r| path(r.env['c'])}
-    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
-    c1 = Class.new
-    def c1.name; 'C'; end
-    c2 = Class.new
-    def c2.name; 'C'; end
-    @app.plugin :path, :by_name=>true
-    @app.path(c1){'/c'}
-    @app.route{|r| path(r.env['c'])}
-    body('c'=>c1.new).must_equal '/c'
-    body('c'=>c2.new).must_equal '/c'
-  end
-
-  it ":by_name defaults to true in development" do
-    with_rack_env('development') do
-      app(:path){}
-    end
-    app.opts[:path_class_by_name].must_equal true
-    app(:path){}
-    app.opts[:path_class_by_name].must_equal false
-  end
-
-  it "Roda.path_block returns the block used" do
-    c = Class.new
-    b = proc{|x| x.to_s}
-    @app.path(c, &b)
-    # Work around minitest bug
-    app.path_block(c).must_equal b
-  end
-
-  it "Roda.path doesn't work with classes without blocks" do
-    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'){}}.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| ''}}.must_raise
-  end
-end
-