roda 3.54.0 → 3.57.0

data/lib/roda/plugins/hash_routes.rb

@@ -3,58 +3,9 @@
 #
 class Roda
   module RodaPlugins
-    # The hash_routes plugin combines the O(1) dispatching speed of the static_routing plugin with
-    # the flexibility of the multi_route plugin.  For any point in the routing tree,
-    # it allows you dispatch to multiple routes where the next segment or the remaining path
-    # is a static string.
-    #
-    # For a basic replacement of the multi_route plugin, you can replace class level
-    # <tt>route('segment')</tt> calls with <tt>hash_branch('segment')</tt>:
-    #
-    #   class App < Roda
-    #     plugin :hash_routes
-    #
-    #     hash_branch("a") do |r|
-    #       # /a branch
-    #     end
-    #
-    #     hash_branch("b") do |r|
-    #       # /b branch
-    #     end
-    #
-    #     route do |r|
-    #       r.hash_branches
-    #     end
-    #   end
-    #
-    # With the above routing tree, the +r.hash_branches+ call in the main routing tree,
-    # will dispatch requests for the +/a+ and +/b+ branches of the tree to the appropriate
-    # routing blocks.
-    #
-    # In addition to supporting routing via the next segment, you can also support similar
-    # routing for entire remaining path using the +hash_path+ class method:
-    #
-    #   class App < Roda
-    #     plugin :hash_routes
-    #
-    #     hash_path("/a") do |r|
-    #       # /a path
-    #     end
-    #
-    #     hash_path("/a/b") do |r|
-    #       # /a/b path 
-    #     end
-    #
-    #     route do |r|
-    #       r.hash_paths
-    #     end
-    #   end
-    #
-    # With the above routing tree, the +r.hash_paths+ call will dispatch requests for the +/a+ and
-    # +/a/b+ request paths.
-    #
-    # You can combine the two approaches, and use +r.hash_routes+ to first try routing the
-    # full path, and then try routing the next segment:
+    # The hash_routes plugin builds on top of the hash_branches and hash_paths plugins, and adds
+    # a DSL for configuring hash branches and paths. It also adds an +r.hash_routes+ method for
+    # first attempting dispatch to the configured hash_paths, then to the configured hash_branches:
     #
     #   class App < Roda
     #     plugin :hash_routes
@@ -84,60 +35,14 @@ class Roda
     # +hash_path+ block.  Other requests for the +/a+ branch, and all requests for the +/b+
     # branch will be routed to the appropriate +hash_branch+ block.
     #
-    # Both +hash_branch+ and +hash_path+ support namespaces, which allows them to be used at
-    # any level of the routing tree.  Here is an example that uses namespaces for sub-branches:
-    #
-    #   class App < Roda
-    #     plugin :hash_routes
-    #
-    #     # Only one argument used, so the namespace defaults to '', and the argument
-    #     # specifies the route name
-    #     hash_branch("a") do |r|
-    #       # uses '/a' as the namespace when looking up routes,
-    #       # as that part of the path has been routed now
-    #       r.hash_routes
-    #     end
-    #
-    #     # Two arguments used, so first specifies the namespace and the second specifies
-    #     # the route name
-    #     hash_branch('', "b") do |r|
-    #       # uses :b as the namespace when looking up routes, as that was explicitly specified
-    #       r.hash_routes(:b)
-    #     end
-    #
-    #     hash_path("/a", "/b") do |r|
-    #       # /a/b path
-    #     end
-    #
-    #     hash_path("/a", "/c") do |r|
-    #       # /a/c path 
-    #     end
-    #
-    #     hash_path(:b, "/b") do |r|
-    #       # /b/b path
-    #     end
-    #
-    #     hash_path(:b, "/c") do |r|
-    #       # /b/c path 
-    #     end
-    #
-    #     route do |r|
-    #       # uses '' as the namespace, as no part of the path has been routed yet
-    #       r.hash_branches
-    #     end
-    #   end
-    #
-    # With the above routing tree, requests for the +/a+ and +/b+ branches will be
-    # dispatched to the appropriate +hash_branch+ block.  Those blocks will the dispatch
-    # to the +hash_path+ blocks, with the +/a+ branch using the implicit namespace of
-    # +/a+, and the +/b+ branch using the explicit namespace of +:b+.  In general, it
-    # is best for performance to explicitly specify the namespace when calling
-    # +r.hash_branches+, +r.hash_paths+, and +r.hash_routes+.
+    # It is best for performance to explicitly specify the namespace when calling
+    # +r.hash_routes+.
     #
     # Because specifying routes explicitly using the +hash_branch+ and +hash_path+
     # class methods can get repetitive, the hash_routes plugin offers a DSL for DRYing
-    # the code up.  This DSL is used by calling the +hash_routes+ class method.  Below
-    # is a translation of the previous example to using the +hash_routes+ DSL:
+    # the code up.  This DSL is used by calling the +hash_routes+ class method.  The
+    # DSL used tries to mirror the standard Roda DSL, but it is not a normal routing
+    # tree (it's not possible to execute arbitrary code between branches during routing).
     #
     #   class App < Roda
     #     plugin :hash_routes
@@ -264,9 +169,12 @@ class Roda
     # * views
     # * all verb methods (get, post, etc.)
     module HashRoutes
+      def self.load_dependencies(app)
+        app.plugin :hash_branches
+        app.plugin :hash_paths
+      end
+
       def self.configure(app)
-        app.opts[:hash_branches] ||= {}
-        app.opts[:hash_paths] ||= {}
         app.opts[:hash_routes_methods] ||= {}
       end
 
@@ -359,24 +267,10 @@ class Roda
       module ClassMethods
         # Freeze the hash_routes metadata when freezing the app.
         def freeze
-          opts[:hash_branches].freeze.each_value(&:freeze)
-          opts[:hash_paths].freeze.each_value(&:freeze)
           opts[:hash_routes_methods].freeze
           super
         end
 
-        # Duplicate hash_routes metadata in subclass.
-        def inherited(subclass)
-          super
-
-          [:hash_branches, :hash_paths].each do |k|
-            h = subclass.opts[k]
-            opts[k].each do |namespace, routes|
-              h[namespace] = routes.dup
-            end
-          end
-        end
-
         # Invoke the DSL for configuring hash routes, see DSL for methods inside the
         # block.  If the block accepts an argument, yield the DSL instance.  If the
         # block does not accept an argument, instance_exec the block in the context
@@ -393,66 +287,9 @@ class Roda
 
           dsl
         end
-
-        # Add branch handler for the given namespace and segment. If called without
-        # a block, removes the existing branch handler if it exists.
-        def hash_branch(namespace='', segment, &block)
-          segment = "/#{segment}"
-          routes = opts[:hash_branches][namespace] ||= {}
-          if block
-            routes[segment] = define_roda_method(routes[segment] || "hash_branch_#{namespace}_#{segment}", 1, &convert_route_block(block))
-          elsif meth = routes[segment]
-            routes.delete(segment)
-            remove_method(meth)
-          end
-        end
-
-        # Add path handler for the given namespace and path. When the
-        # r.hash_paths method is called, checks the matching namespace
-        # for the full remaining path, and dispatch to that block if
-        # there is one.  If called without a block, removes the existing
-        # path handler if it exists.
-        def hash_path(namespace='', path, &block)
-          routes = opts[:hash_paths][namespace] ||= {}
-          if block
-            routes[path] = define_roda_method(routes[path] || "hash_path_#{namespace}_#{path}", 1, &convert_route_block(block))
-          elsif meth = routes[path]
-            routes.delete(path)
-            remove_method(meth)
-          end
-        end
       end
 
       module RequestMethods
-        # Checks the matching hash_branch namespace for a branch matching the next
-        # segment in the remaining path, and dispatch to that block if there is one.
-        def hash_branches(namespace=matched_path)
-          rp = @remaining_path
-
-          return unless rp.getbyte(0) == 47 # "/"
-
-          if routes = roda_class.opts[:hash_branches][namespace]
-            if segment_end = rp.index('/', 1)
-              if meth = routes[rp[0, segment_end]]
-                @remaining_path = rp[segment_end, 100000000]
-                always{scope.send(meth, self)}
-              end
-            elsif meth = routes[rp]
-              @remaining_path = ''
-              always{scope.send(meth, self)}
-            end
-          end
-        end
-
-        # Checks the matching hash_path namespace for a branch matching the 
-        # remaining path, and dispatch to that block if there is one.
-        def hash_paths(namespace=matched_path)
-          if (routes = roda_class.opts[:hash_paths][namespace]) && (meth = routes[@remaining_path])
-            @remaining_path = ''
-            always{scope.send(meth, self)}
-          end
-        end
-
         # Check for matches in both the hash_path and hash_branch namespaces for
         # a matching remaining path or next segment in the remaining path, respectively.
         def hash_routes(namespace=matched_path)

data/lib/roda/plugins/json_parser.rb

@@ -4,12 +4,16 @@ require 'json'
 
 class Roda
   module RodaPlugins
-    # The json_parser plugin parses request bodies in json format
+    # The json_parser plugin parses request bodies in JSON format
     # if the request's content type specifies json. This is mostly
     # designed for use with JSON API sites.
     #
     # This only parses the request body as JSON if the Content-Type
     # header for the request includes "json".
+    #
+    # The parsed JSON body will be available in +r.POST+, just as a
+    # parsed HTML form body would be. It will also be available in
+    # +r.params+ (which merges +r.GET+ with +r.POST+).
     module JsonParser
       DEFAULT_ERROR_HANDLER = proc{|r| r.halt [400, {}, []]}
 
@@ -25,7 +29,7 @@ class Roda
       #                     object as the second argument, so the parser needs
       #                     to respond to +call(str, request)+.
       # :wrap :: Whether to wrap uploaded JSON data in a hash with a "_json"
-      #          key.  Without this, calls to r.params will fail if a non-Hash
+      #          key.  Without this, calls to +r.params+ will fail if a non-Hash
       #          (such as an array) is uploaded in JSON format.  A value of
       #          :always will wrap all values, and a value of :unless_hash will
       #          only wrap values that are not already hashes.

data/lib/roda/plugins/middleware.rb

@@ -73,11 +73,16 @@ class Roda
       #                   and rack response for all requests passing through the middleware,
       #                   after either the middleware or next app handles the request
       #                   and returns a response.
+      # :forward_response_headers :: Whether changes to the response headers made inside
+      #                              the middleware's route block should be applied to the
+      #                              final response when the request is forwarded to the app.
+      #                              Defaults to false.
       def self.configure(app, opts={}, &block)
         app.opts[:middleware_env_var] = opts[:env_var] if opts.has_key?(:env_var)
         app.opts[:middleware_env_var] ||= 'roda.forward_next'
         app.opts[:middleware_configure] = block if block
         app.opts[:middleware_handle_result] = opts[:handle_result]
+        app.opts[:middleware_forward_response_headers] = opts[:forward_response_headers]
       end
 
       # Forwarder instances are what is actually used as middleware.
@@ -108,6 +113,10 @@ class Roda
 
           if call_next
             res = @app.call(env)
+
+            if modified_headers = env.delete('roda.response_headers')
+              res[1] = modified_headers.merge(res[1])
+            end
           end
 
           if handle_result = @mid.opts[:middleware_handle_result]
@@ -135,7 +144,10 @@ class Roda
         def call(&block)
           super do |r|
             res = instance_exec(r, &block) # call Fallback
-            throw :next, true if r.forward_next
+            if r.forward_next
+              r.env['roda.response_headers'] = response.headers if opts[:middleware_forward_response_headers]
+              throw :next, true
+            end
             res
           end
         end
@@ -144,7 +156,10 @@ class Roda
         # that the next middleware is called.
         def _roda_run_main_route(r)
           res = super
-          throw :next, true if r.forward_next
+          if r.forward_next
+            r.env['roda.response_headers'] = response.headers if opts[:middleware_forward_response_headers]
+            throw :next, true
+          end
           res
         end
       end

data/lib/roda/plugins/multi_public.rb

@@ -1,5 +1,13 @@
 # frozen-string-literal: true
 
+begin
+  require 'rack/files'
+rescue LoadError
+  # :nocov:
+  require 'rack/file'
+  # :nocov:
+end
+
 #
 class Roda
   module RodaPlugins

data/lib/roda/plugins/multi_route.rb

@@ -8,7 +8,7 @@ class Roda
     # which will check # if the first segment in the path matches a named route,
     # and dispatch to that named route.
     #
-    # The hash_routes plugin offers a +r.hash_routes+ method that is similar to
+    # The hash_branches plugin offers a +r.hash_branches+ method that is similar to
     # and performs better than the +r.multi_route+ method, and it is recommended
     # to consider using that instead of this plugin.
     #

data/lib/roda/plugins/multi_view.rb

@@ -16,10 +16,6 @@ class Roda
     # +multi_view_compile+ class method that will take an array of view template
     # names and construct a regexp that can be passed to +r.multi_view+.
     #
-    # The hash_routes plugin offers a views method that is similar to and performs
-    # better than the +r.multi_view+ method, and it is recommended to consider
-    # using that instead of this plugin.
-    #
     # Example:
     #
     #   plugin :multi_view

data/lib/roda/plugins/named_routes.rb

@@ -145,8 +145,7 @@ class Roda
             routes = opts[:namespaced_routes][namespace] ||= {}
             if block
               routes[name] = define_roda_method(routes[name] || "named_routes_#{namespace}_#{name}", 1, &convert_route_block(block))
-            elsif meth = routes[name]
-              routes.delete(name)
+            elsif meth = routes.delete(name)
               remove_method(meth)
             end
           else

data/lib/roda/plugins/not_allowed.rb

@@ -17,6 +17,9 @@ class Roda
     # will return a 200 response for <tt>GET /</tt> and a 405
     # response for <tt>POST /</tt>.
     #
+    # This plugin changes the +r.root+ method to return a 405 status
+    # for non-GET requests to +/+.
+    #
     # This plugin also changes the +r.is+ method so that if you use
     # a verb method inside +r.is+, it returns a 405 status if none
     # of the verb methods match.  So this code:
@@ -100,6 +103,15 @@ class Roda
           end
         end
 
+        # Treat +r.root+ similar to <tt>r.get ''</tt>, using a 405
+        # response for non-GET requests.
+        def root
+          super
+          if @remaining_path == "/"  && !is_get?
+            always{method_not_allowed("GET")}
+          end
+        end
+
         # Setup methods for all verbs.  If inside an is block and not given
         # arguments, record the verb used.  If given an argument, add an is
         # check with the arguments.
@@ -129,6 +141,7 @@ class Roda
           res = response
           res.status = 405
           res['Allow'] = verbs
+          nil
         end
       end
     end

data/lib/roda/plugins/public.rb

@@ -2,6 +2,14 @@
 
 require 'uri'
 
+begin
+  require 'rack/files'
+rescue LoadError
+  # :nocov:
+  require 'rack/file'
+  # :nocov:
+end
+
 #
 class Roda
   module RodaPlugins

data/lib/roda/plugins/render.rb

@@ -495,8 +495,10 @@ class Roda
 
         # Render the given template.  If there is a default layout
         # for the class, take the result of the template rendering
-        # and render it inside the layout.  See Render for details.
-        def view(template, opts = (content = _optimized_view_content(template); OPTS))
+        # and render it inside the layout.  Blocks passed to view
+        # are passed to render when rendering the template.
+        # See Render for details.
+        def view(template, opts = (content = _optimized_view_content(template) unless defined?(yield); OPTS), &block)
           if content
             # First, check if the optimized layout method has already been created,
             # and use it if so.  This way avoids the extra conditional and local variable
@@ -516,7 +518,7 @@ class Roda
             end
           else
             opts = parse_template_opts(template, opts)
-            content = opts[:content] || render_template(opts)
+            content = opts[:content] || render_template(opts, &block)
           end
 
           if layout_opts  = view_layout_opts(opts)

data/lib/roda/plugins/route_csrf.rb

@@ -4,6 +4,7 @@ require 'base64'
 require 'openssl'
 require 'securerandom'
 require 'uri'
+require 'rack/utils'
 
 class Roda
   module RodaPlugins

data/lib/roda/plugins/run_append_slash.rb

@@ -34,7 +34,7 @@ class Roda
         # path internally, or a redirect is issued when configured with
         # <tt>use_redirects: true</tt>.
         def run(*)
-          if remaining_path.empty?
+          if @remaining_path.empty?
             if scope.opts[:run_append_slash_redirect]
               redirect("#{path}/")
             else

data/lib/roda/plugins/run_require_slash.rb

@@ -0,0 +1,46 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The run_require_slash plugin makes +r.run+ a no-op if the remaining
+    # path is not empty and does not start with +/+. The Rack SPEC requires that
+    # +PATH_INFO+ start with a slash if not empty, so this plugin prevents
+    # dispatching to the application with an environment that would violate the
+    # Rack SPEC.
+    #
+    # You are unlikely to want to use this plugin unless are consuming partial
+    # segments of the request path, or using the match_affix plugin to change
+    # how routing is done:
+    #
+    #   plugin :match_affix, "", /(\/|\z)/
+    #   route do |r|
+    #     r.on "/a" do
+    #       r.on "b" do
+    #         r.run App
+    #       end
+    #     end
+    #   end
+    #
+    #   # with run_require_slash: 
+    #   # GET /a/b/e => App not dispatched to
+    #   # GET /a/b => App gets "" as PATH_INFO
+    #
+    #   # with run_require_slash: 
+    #   # GET /a/b/e => App gets "e" as PATH_INFO, violating rack SPEC
+    #   # GET /a/b => App gets "" as PATH_INFO
+    module RunRequireSlash
+      module RequestMethods
+        # Calls the given rack app only if the remaining patch is empty or
+        # starts with a slash.
+        def run(*)
+          if @remaining_path.empty? || @remaining_path.start_with?('/')
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:run_require_slash, RunRequireSlash)
+  end
+end

data/lib/roda/plugins/sessions.rb

@@ -14,6 +14,7 @@ require 'base64'
 require 'json'
 require 'securerandom'
 require 'zlib'
+require 'rack/utils'
 
 class Roda
   module RodaPlugins

data/lib/roda/plugins/sinatra_helpers.rb

@@ -1,5 +1,15 @@
 # frozen-string-literal: true
 
+require 'rack/mime'
+begin
+  require 'rack/files'
+rescue LoadError
+  # :nocov:
+  require 'rack/file'
+  # :nocov:
+end
+
+
 #
 class Roda
   module RodaPlugins

data/lib/roda/plugins/static.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require 'rack/static'
+
 #
 class Roda
   module RodaPlugins

data/lib/roda/plugins/static_routing.rb

@@ -50,7 +50,7 @@ class Roda
     # while still handling the request methods differently.
     module StaticRouting
       def self.load_dependencies(app)
-        app.plugin :hash_routes
+        app.plugin :hash_paths
       end
 
       module ClassMethods

data/lib/roda/plugins/status_303.rb

@@ -17,10 +17,13 @@ class Roda
         private
 
         def default_redirect_status
-          if env['HTTP_VERSION'] == 'HTTP/1.1' && !is_get?
-            303
-          else
+          return super if is_get?
+
+          case http_version
+          when 'HTTP/1.0', 'HTTP/0.9', nil
             super
+          else
+            303
           end
         end
       end

data/lib/roda/plugins/status_handler.rb

@@ -15,24 +15,53 @@ class Roda
     #   status_handler(403) do
     #     "You are forbidden from seeing that!"
     #   end
+    #
     #   status_handler(404) do
     #     "Where did it go?"
     #   end
     #
+    #   status_handler(405, keep_headers: ['Accept']) do
+    #     "Use a different method!"
+    #   end
+    #
     # Before a block is called, any existing headers on the response will be
-    # cleared.  So if you want to be sure the headers are set even in your block,
-    # you need to reset them in the block.
+    # cleared, unless the +:keep_headers+ option is used.  If the +:keep_headers+
+    # option is used, the value should be an array, and only the headers listed
+    # in the array will be kept.
     module StatusHandler
+      CLEAR_HEADERS = :clear.to_proc
+      private_constant :CLEAR_HEADERS
+
       def self.configure(app)
         app.opts[:status_handler] ||= {}
       end
 
       module ClassMethods
         # Install the given block as a status handler for the given HTTP response code.
-        def status_handler(code, &block)
+        def status_handler(code, opts=OPTS, &block)
           # For backwards compatibility, pass request argument if block accepts argument
           arity = block.arity == 0 ? 0 : 1
-          opts[:status_handler][code] = [define_roda_method(:"_roda_status_handler_#{code}", arity, &block), arity]
+          handle_headers = case keep_headers = opts[:keep_headers]
+          when nil, false
+            CLEAR_HEADERS
+          when Array
+            # :nocov:
+            if Rack.release >= '2.3'
+              keep_headers = keep_headers.map(&:downcase)
+            end
+            # :nocov:
+            lambda{|headers| headers.delete_if{|k,_| !keep_headers.include?(k)}}
+          else
+            raise RodaError, "Invalid :keep_headers option"
+          end
+
+          meth = define_roda_method(:"_roda_status_handler__#{code}", arity, &block)
+          self.opts[:status_handler][code] = define_roda_method(:"_roda_status_handler_#{code}", 1) do |result|
+            res = @_response
+            res.status = result[0]
+            handle_headers.call(res.headers)
+            result.replace(_roda_handle_route{arity == 1 ? send(meth, @_request) : send(meth)})
+          end
         end
 
         # Freeze the hash of status handlers so that there can be no thread safety issues at runtime.
@@ -47,11 +76,8 @@ class Roda
 
         # If routing returns a response we have a handler for, call that handler.
         def _roda_after_20__status_handler(result)
-          if result && (meth, arity = opts[:status_handler][result[0]]; meth) && (v = result[2]).is_a?(Array) && v.empty?
-            res = @_response
-            res.headers.clear
-            res.status = result[0]
-            result.replace(_roda_handle_route{arity == 1 ? send(meth, @_request) : send(meth)})
+          if result && (meth = opts[:status_handler][result[0]]) && (v = result[2]).is_a?(Array) && v.empty?
+            send(meth, result)
           end
         end
       end

data/lib/roda/plugins/symbol_status.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require 'rack/utils'
+
 class Roda
   module RodaPlugins
     # The symbol_status plugin patches the +status=+ response method to

data/lib/roda/plugins/unescape_path.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require 'rack/utils'
+
 #
 class Roda
   module RodaPlugins