roda 3.28.0 → 3.29.0

data/doc/release_notes/2.5.1.txt

@@ -1,4 +0,0 @@
-= Improvements
-
-* The multi_route plugin now works correctly if the middleware plugin
-  is loaded after it.

data/doc/release_notes/2.6.0.txt

@@ -1,21 +0,0 @@
-= New Features
-
-* :params and :params! matchers have been added to the param_matchers
-  plugin, allowing you to match multiple params at the same time:
-
-    r.on :params=>%w'foo bar' do |foo, bar| end
-    # instead of
-    r.on({:param=>'foo'}, :param=>'bar') do |foo, bar| end
-
-= Other Improvements
-
-* When loading the csrf plugin multiple times, instead of loading the
-  middleware multiple times with different settings, merge options
-  in later plugin calls into a single middleware option hash, and
-  only load the middleware once.
-
-  This allows plugins to depend on the csrf plugin, while also
-  allowing the application to use the csrf plugin with options.
-
-* request.halt now works correctly when used inside a before hook when
-  using the hooks plugin.

data/doc/release_notes/2.7.0.txt

@@ -1,75 +0,0 @@
-= New Features
-
-* A default_status plugin has been added for changing the default
-  status for responses.  Previously, the default status was hard
-  coded to 200, this plugin allows you to change it.  The plugin
-  takes a block which is instance_evaled in the context of the
-  response:
-
-    plugin :default_status do
-      headers['Content-Type'] == 'foo' ? 201 : 200
-    end
-
-  Note that the default status for empty responses (used when no
-  route handles the response) is still 404, this just changes the
-  default for non-empty responses.
-
-* A response_request plugin has been added for giving the response
-  instance access to the related request.  This can be useful in
-  conjunction with the default_status plugin, if you want the
-  default status of the response to depend on the request, such as
-  using a different status for different request methods:
-
-    plugin :response_request
-    plugin :default_status do
-      request.post? ? 201 : 200
-    end
-
-* A run_handler plugin has been added, for modifying rack response
-  arrays before returning them when using r.run.  Additionally, it
-  allows for continuing with routing if the response returned by
-  r.run is a 404 response, using the :not_found=>:pass option:
-
-    plugin :run_handler
-    route do |r|
-      # Keep running code if RackAppFoo returns a 404 response
-      r.run RackAppFoo, :not_found=>:pass
-
-      # Change response status codes before returning.
-      r.run(RackAppBar) do |response|
-        response[0] = 200 if response[0] == 201
-      end
-    end
-
-* Roda.rewite_path in the path_rewriter extension now accepts a block
-  to allow for dynamic replacements. The block is yielded a MatchData
-  instance:
-
-    rewrite_path(/\A\/a/(\w+)/){|match| match[1].capitalize}
-    # PATH_INFO '/a/moo' => remaining_path '/a/Moo'
-
-    rewrite_path(/\A\/a/(\w+)/, :path_info => true) do |match|
-      match[1].capitalize
-    end
-    # PATH_INFO '/a/moo' => PATH_INFO '/a/Moo'
-
-* The :host matcher in the header_matchers plugin will now yield the
-  regexp captures to the block if given a regexp when the
-  :host_matcher_captures application option is set.  This behavior
-  will become the default behavior in Roda 3.  This will allow for
-  code like:
-
-    opts[:host_matcher_captures] = true
-    route do |r|
-      r.on :host=>/\A(\w+).example.com\z/ do |subdomain|
-        # ...
-      end
-    end
-
-= Other Improvements
-
-* RodaCache now uses a mutex to synchronize access on MRI.
-  Previously, it relied on the global interpreter lock, but testing
-  has shown that is not reliable in all cases.  RodaCache has always
-  used a mutex for synchronization on other ruby implementations,
-  this just extends that code to MRI as well.

data/doc/release_notes/2.8.0.txt

@@ -1,44 +0,0 @@
-= New Features
-
-* A multi_view plugin has been added, for easily setting up routing
-  for rendering multiple views:
-
-    plugin :multi_view
-
-    route do |r|
-      r.multi_view(['foo', 'bar', 'baz'])
-    end
-
-    # or:
-
-    route do |r|
-      r.multi_view(/(foo|bar|baz)/)
-    end
-
-    # or:
-
-    regexp = multi_view_compile(['foo', 'bar', 'baz'])
-    route do |r|
-      r.multi_view(regexp)
-    end
-
-    # all are equivalent to:
-
-    route do |r|
-      r.get 'foo' do
-        view('foo')
-      end
- 
-      r.get 'bar' do
-        view('bar')
-      end
-
-      r.get 'baz' do
-        view('baz')
-      end
-    end
-
-= Other Improvements
-
-* The content_for plugin now supports haml templates.  Previous only
-  erb templates were supported.

data/doc/release_notes/2.9.0.txt

@@ -1,6 +0,0 @@
-= New Features
-
-* The content_for plugin now supports passing the content as a
-  string argument instead of a block:
-
-    <% content_for :foo, "Some content" %>

data/spec/all.rb

@@ -1 +0,0 @@
-(Dir['./spec/*_spec.rb'] + Dir['./spec/plugin/*_spec.rb']).each{|f| require f}

data/spec/assets/css/app.scss

@@ -1 +0,0 @@
-body { color: red; }

data/spec/assets/css/no_access.css

@@ -1 +0,0 @@
-no access

data/spec/assets/css/raw.css

@@ -1 +0,0 @@
-body { color: blue; }

data/spec/assets/js/head/app.js

@@ -1 +0,0 @@
-console.log('test')

data/spec/composition_spec.rb

@@ -1,31 +0,0 @@
-require_relative "spec_helper"
-
-describe "r.run" do
-  it "should allow composition of apps" do
-    a = app do |r|
-      r.on "services", :id do |id|
-        "View #{id}"
-      end
-    end
-
-    app(:new) do |r|
-      r.on "provider" do
-        r.run a
-      end
-    end
-
-    body("/provider/services/101").must_equal 'View 101'
-  end
-
-  it "modifies SCRIPT_NAME/PATH_INFO when calling run" do
-    a = app{|r| "#{r.script_name}|#{r.path_info}"}
-    app{|r| r.on("a"){r.run a}}
-    body("/a/b").must_equal "/a|/b"
-  end
-
-  it "restores SCRIPT_NAME/PATH_INFO before returning from run" do
-    a = app{|r| "#{r.script_name}|#{r.path_info}"}
-    app{|r| s = catch(:halt){r.on("a"){r.run a}}; "#{s[2].join}%#{r.script_name}|#{r.path_info}"}
-    body("/a/b").must_equal "/a|/b%|/a/b"
-  end
-end

data/spec/define_roda_method_spec.rb

@@ -1,274 +0,0 @@
-require_relative "spec_helper"
-
-describe "Roda.define_roda_method" do
-  before do
-    @scope = app.new({'PATH_INFO'=>'/'})
-  end
-
-  it "should define methods using block" do
-    m0 = app.define_roda_method("x", 0){1}
-    m0.must_be_kind_of Symbol
-    m0.must_match(/\A_roda_x_\d+\z/)
-    @scope.send(m0).must_equal 1
-
-    m1 = app.define_roda_method("x", 1){|x| [x, 2]}
-    m1.must_be_kind_of Symbol
-    m1.must_match(/\A_roda_x_\d+\z/)
-    @scope.send(m1, 3).must_equal [3, 2]
-  end
-
-  it "should define private methods" do
-    proc{@scope.public_send(app.define_roda_method("x", 0){1})}.must_raise NoMethodError
-  end
-
-  it "should accept symbols as method name and return the same symbol" do
-    m0 = app.define_roda_method(:_roda_foo, 0){1}
-    m0.must_equal :_roda_foo
-    @scope.send(m0).must_equal 1
-  end
-
-  it "should handle optional arguments and splats for expected_arity 0" do
-    m2 = app.define_roda_method("x", 0){|*x| [x, 3]}
-    @scope.send(m2).must_equal [[], 3]
-
-    m3 = app.define_roda_method("x", 0){|x=5| [x, 4]}
-    @scope.send(m3).must_equal [5, 4]
-
-    m4 = app.define_roda_method("x", 0){|x=6, *y| [x, y, 5]}
-    @scope.send(m4).must_equal [6, [], 5]
-  end
-
-  it "should should optional arguments and splats for expected_arity 1" do
-    m2 = app.define_roda_method("x", 1){|y, *x| [y, x, 3]}
-    @scope.send(m2, :a).must_equal [:a, [], 3]
-
-    m3 = app.define_roda_method("x", 1){|y, x=5| [y, x, 4]}
-    @scope.send(m3, :b).must_equal [:b, 5, 4]
-
-    m4 = app.define_roda_method("x", 1){|y, x=6, *z| [y, x, z, 5]}
-    @scope.send(m4, :c).must_equal [:c, 6, [], 5]
-  end
-
-  it "should handle differences in arity" do
-    m0 = app.define_roda_method("x", 0){|x| [x, 1]}
-    @scope.send(m0).must_equal [nil, 1]
-
-    m1 = app.define_roda_method("x", 1){2}
-    @scope.send(m1, 3).must_equal 2
-
-    m1 = app.define_roda_method("x", 1){|x, y| [x, y]}
-    @scope.send(m1, 4).must_equal [4, nil]
-  end
-
-  it "should raise for unexpected expected_arity" do
-    proc{app.define_roda_method("x", 2){|x|}}.must_raise Roda::RodaError
-  end
-
-  it "should fail if :check_arity false app option is used and a block with invalid arity is passed" do
-    app.opts[:check_arity] = false
-    m0 = app.define_roda_method("x", 0){|x| [x, 1]}
-    proc{@scope.send(m0)}.must_raise ArgumentError
-
-    m1 = app.define_roda_method("x", 1){2}
-    proc{@scope.send(m1, 1)}.must_raise ArgumentError
-  end
-
-  deprecated "should warn if :check_arity :warn app option is used and a block with invalid arity is passed" do
-    app.opts[:check_arity] = :warn
-    m0 = app.define_roda_method("x", 0){|x| [x, 1]}
-    @scope.send(m0).must_equal [nil, 1]
-
-    m1 = app.define_roda_method("x", 1){2}
-    @scope.send(m1, 3).must_equal 2
-  end
-
-  [false, true].each do |warn_dynamic_arity| 
-    meth = warn_dynamic_arity ? :deprecated : :it
-    send meth, "should handle expected_arity :any and do dynamic arity check/fix" do
-      if warn_dynamic_arity
-        app.opts[:check_dynamic_arity] = :warn
-      end
-
-      m0 = app.define_roda_method("x", :any){1}
-      @scope.send(m0).must_equal 1
-      @scope.send(m0, 2).must_equal 1
-
-      m1 = app.define_roda_method("x", :any){|x| [x, 1]}
-      @scope.send(m1).must_equal [nil, 1]
-      @scope.send(m1, 2).must_equal [2, 1]
-      @scope.send(m1, 2, 3).must_equal [2, 1]
-
-      m2 = app.define_roda_method("x", :any){|x=5| [x, 2]}
-      @scope.send(m2).must_equal [5, 2]
-      @scope.send(m2, 2).must_equal [2, 2]
-      @scope.send(m2, 2, 3).must_equal [2, 2]
-
-      m3 = app.define_roda_method("x", :any){|y, x=5| [x, y, 3]}
-      @scope.send(m3).must_equal [5, nil, 3]
-      @scope.send(m3, 2).must_equal [5, 2, 3]
-      @scope.send(m3, 2, 3).must_equal [3, 2, 3]
-      @scope.send(m3, 2, 3, 4).must_equal [3, 2, 3]
-
-      m4 = app.define_roda_method("x", :any){|*z| [z, 1]}
-      @scope.send(m4).must_equal [[], 1]
-      @scope.send(m4, 2).must_equal [[2], 1]
-
-      m5 = app.define_roda_method("x", :any){|x, *z| [x, z, 1]}
-      @scope.send(m5).must_equal [nil, [], 1]
-      @scope.send(m5, 2).must_equal [2, [], 1]
-      @scope.send(m5, 2, 3).must_equal [2, [3], 1]
-
-      m6 = app.define_roda_method("x", :any){|x=5, *z| [x, z, 2]}
-      @scope.send(m6).must_equal [5, [], 2]
-      @scope.send(m6, 2).must_equal [2, [], 2]
-      @scope.send(m6, 2, 3).must_equal [2, [3], 2]
-
-      m7 = app.define_roda_method("x", :any){|y, x=5, *z| [x, y, z, 3]}
-      @scope.send(m7).must_equal [5, nil, [], 3]
-      @scope.send(m7, 2).must_equal [5, 2, [], 3]
-      @scope.send(m7, 2, 3).must_equal [3, 2, [], 3]
-      @scope.send(m7, 2, 3, 4).must_equal [3, 2, [4], 3]
-    end
-  end
-
-  it "should not fix dynamic arity issues if :check_dynamic_arity false app option is used" do
-    app.opts[:check_dynamic_arity] = false
-
-    m0 = app.define_roda_method("x", :any){1}
-    @scope.send(m0).must_equal 1
-    proc{@scope.send(m0, 2)}.must_raise ArgumentError
-
-    m1 = app.define_roda_method("x", :any){|x| [x, 1]}
-    proc{@scope.send(m1)}.must_raise ArgumentError
-    @scope.send(m1, 2).must_equal [2, 1]
-    proc{@scope.send(m1, 2, 3)}.must_raise ArgumentError
-
-    m2 = app.define_roda_method("x", :any){|x=5| [x, 2]}
-    @scope.send(m2).must_equal [5, 2]
-    @scope.send(m2, 2).must_equal [2, 2]
-    proc{@scope.send(m2, 2, 3)}.must_raise ArgumentError
-
-    m3 = app.define_roda_method("x", :any){|y, x=5| [x, y, 3]}
-    proc{@scope.send(m3)}.must_raise ArgumentError
-    @scope.send(m3, 2).must_equal [5, 2, 3]
-    @scope.send(m3, 2, 3).must_equal [3, 2, 3]
-    proc{@scope.send(m3, 2, 3, 4)}.must_raise ArgumentError
-
-    m4 = app.define_roda_method("x", :any){|*z| [z, 1]}
-    @scope.send(m4).must_equal [[], 1]
-    @scope.send(m4, 2).must_equal [[2], 1]
-
-    m5 = app.define_roda_method("x", :any){|x, *z| [x, z, 1]}
-    proc{@scope.send(m5)}.must_raise ArgumentError
-    @scope.send(m5, 2).must_equal [2, [], 1]
-    @scope.send(m5, 2, 3).must_equal [2, [3], 1]
-
-    m6 = app.define_roda_method("x", :any){|x=5, *z| [x, z, 2]}
-    @scope.send(m6).must_equal [5, [], 2]
-    @scope.send(m6, 2).must_equal [2, [], 2]
-    @scope.send(m6, 2, 3).must_equal [2, [3], 2]
-
-    m7 = app.define_roda_method("x", :any){|y, x=5, *z| [x, y, z, 3]}
-    proc{@scope.send(m7)}.must_raise ArgumentError
-    @scope.send(m7, 2).must_equal [5, 2, [], 3]
-    @scope.send(m7, 2, 3).must_equal [3, 2, [], 3]
-    @scope.send(m7, 2, 3, 4).must_equal [3, 2, [4], 3]
-  end
-
-  if RUBY_VERSION > '2.1'
-    it "should raise for required keyword arguments for expected_arity 0 or 1" do
-      proc{eval("app.define_roda_method('x', 0){|b:| [b, 1]}", binding)}.must_raise Roda::RodaError
-      proc{eval("app.define_roda_method('x', 0){|c=1, b:| [c, b, 1]}", binding)}.must_raise Roda::RodaError
-      proc{eval("app.define_roda_method('x', 1){|x, b:| [b, 1]}", binding)}.must_raise Roda::RodaError
-      proc{eval("app.define_roda_method('x', 1){|x, c=1, b:| [c, b, 1]}", binding)}.must_raise Roda::RodaError
-    end
-
-    it "should ignore keyword arguments for expected_arity 0" do
-      @scope.send(eval("app.define_roda_method('x', 0){|b:2| [b, 1]}", binding)).must_equal [2, 1]
-      @scope.send(eval("app.define_roda_method('x', 0){|**b| [b, 1]}", binding)).must_equal [{}, 1]
-      @scope.send(eval("app.define_roda_method('x', 0){|c=1, b:2| [c, b, 1]}", binding)).must_equal [1, 2, 1]
-      @scope.send(eval("app.define_roda_method('x', 0){|c=1, **b| [c, b, 1]}", binding)).must_equal [1, {}, 1]
-      @scope.send(eval("app.define_roda_method('x', 0){|x, b:2| [x, b, 1]}", binding)).must_equal [nil, 2, 1]
-      @scope.send(eval("app.define_roda_method('x', 0){|x, **b| [x, b, 1]}", binding)).must_equal [nil, {}, 1]
-      @scope.send(eval("app.define_roda_method('x', 0){|x, c=1, b:2| [x, c, b, 1]}", binding)).must_equal [nil, 1, 2, 1]
-      @scope.send(eval("app.define_roda_method('x', 0){|x, c=1, **b| [x, c, b, 1]}", binding)).must_equal [nil, 1, {}, 1]
-    end
-
-    it "should ignore keyword arguments for expected_arity 1" do
-      @scope.send(eval("app.define_roda_method('x', 1){|b:2| [b, 1]}", binding), 3).must_equal [2, 1]
-      @scope.send(eval("app.define_roda_method('x', 1){|**b| [b, 1]}", binding), 3).must_equal [{}, 1]
-      @scope.send(eval("app.define_roda_method('x', 1){|c=1, b:2| [c, b, 1]}", binding), 3).must_equal [3, 2, 1]
-      @scope.send(eval("app.define_roda_method('x', 1){|c=1, **b| [c, b, 1]}", binding), 3).must_equal [3, {}, 1]
-      @scope.send(eval("app.define_roda_method('x', 1){|x, b:2| [x, b, 1]}", binding), 3).must_equal [3, 2, 1]
-      @scope.send(eval("app.define_roda_method('x', 1){|x, **b| [x, b, 1]}", binding), 3).must_equal [3, {}, 1]
-      @scope.send(eval("app.define_roda_method('x', 1){|x, c=1, b:2| [x, c, b, 1]}", binding), 3).must_equal [3, 1, 2, 1]
-      @scope.send(eval("app.define_roda_method('x', 1){|x, c=1, **b| [x, c, b, 1]}", binding), 3).must_equal [3, 1, {}, 1]
-    end
-
-    it "should handle expected_arity :any with keyword arguments" do
-      if RUBY_VERSION >= '2.7' && RUBY_VERSION < '3'
-        suppress = proc do |&b|
-          begin
-            stderr = $stderr
-            $stderr = StringIO.new
-            b.call
-          ensure
-            $stderr = stderr
-          end
-        end
-      else
-        suppress = proc{|&b| b.call}
-      end
-
-      m = eval('app.define_roda_method("x", :any){|b:2| b}', binding)
-      @scope.send(m).must_equal 2
-      @scope.send(m, 4).must_equal 2
-      @scope.send(m, b: 3).must_equal 3
-      @scope.send(m, 4, b: 3).must_equal 3
-
-      m = eval('app.define_roda_method("x", :any){|b:| b}', binding)
-      proc{@scope.send(m)}.must_raise ArgumentError
-      proc{@scope.send(m, 4)}.must_raise ArgumentError
-      @scope.send(m, b: 3).must_equal 3
-      @scope.send(m, 4, b: 3).must_equal 3
-
-      m = eval('app.define_roda_method("x", :any){|**b| b}', binding)
-      @scope.send(m).must_equal({})
-      @scope.send(m, 4).must_equal({})
-      @scope.send(m, b: 3).must_equal(b: 3)
-      @scope.send(m, 4, b: 3).must_equal(b: 3)
-
-      m = eval('app.define_roda_method("x", :any){|x, b:9| [x, b, 1]}', binding)
-      suppress.call{@scope.send(m)[1..-1]}.must_equal [9, 1]
-      @scope.send(m, 2).must_equal [2, 9, 1]
-      @scope.send(m, 2, 3).must_equal [2, 9, 1]
-      eval("@scope.send(m, {b: 4}#{', **{}' if RUBY_VERSION > '2'})").must_equal [{b: 4}, 9, 1]
-      @scope.send(m, 2, b: 4).must_equal [2, 4, 1]
-      @scope.send(m, 2, 3, b: 4).must_equal [2, 4, 1]
-
-      m = eval('app.define_roda_method("x", :any){|x, b:| [x, b, 1]}', binding)
-      proc{suppress.call{@scope.send(m)}}.must_raise ArgumentError
-      proc{@scope.send(m, 2)}.must_raise ArgumentError
-      proc{@scope.send(m, 2, 3)}.must_raise ArgumentError
-      proc{eval("@scope.send(m, {b: 4}#{', **{}' if RUBY_VERSION > '2'})")}.must_raise ArgumentError
-      @scope.send(m, 2, b: 4).must_equal [2, 4, 1]
-      @scope.send(m, 2, 3, b: 4).must_equal [2, 4, 1]
-
-      m = eval('app.define_roda_method("x", :any){|x, **b| [x, b, 1]}', binding)
-      suppress.call{@scope.send(m)[1..-1]}.must_equal [{}, 1]
-      @scope.send(m, 2).must_equal [2, {}, 1]
-      @scope.send(m, 2, 3).must_equal [2, {}, 1]
-      eval("@scope.send(m, {b: 4}#{', **{}' if RUBY_VERSION > '2'})").must_equal [{b: 4}, {}, 1]
-      @scope.send(m, 2, b: 4).must_equal [2, {b: 4}, 1]
-      @scope.send(m, 2, 3, b: 4).must_equal [2, {b: 4}, 1]
-
-      m = eval('m = app.define_roda_method("x", :any){|x=5, b:9| [x, b, 2]}', binding)
-      @scope.send(m).must_equal [5, 9, 2]
-      @scope.send(m, 2).must_equal [2, 9, 2]
-      @scope.send(m, 2, 3).must_equal [2, 9, 2]
-      @scope.send(m, b: 4).must_equal [5, 4, 2]
-      @scope.send(m, 2, b: 4).must_equal [2, 4, 2]
-      @scope.send(m, 2, 3, b: 4).must_equal [2, 4, 2]
-    end
-  end
-end