roda 3.55.0 → 3.58.0

data/lib/roda/plugins/hash_paths.rb

@@ -0,0 +1,128 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The hash_paths plugin allows for O(1) dispatch to multiple routes at any point
+    # in the routing tree.  It is useful when you have a large number of specific routes
+    # to dispatch to at any point in the routing tree.
+    #
+    # You configure the hash paths to dispatch to using the +hash_path+ class method,
+    # specifying the remaining path, with a block to handle that path.  Then you dispatch
+    # to the configured paths using +r.hash_paths+:
+    #
+    #   class App < Roda
+    #     plugin :hash_paths
+    #
+    #     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.
+    #
+    # The +hash_path+ class method supports namespaces, which allows +r.hash_paths+ 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_paths
+    #
+    #     # Two arguments provided, so first argument is the namespace
+    #     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|
+    #       r.on 'a' do
+    #         # No argument given, so uses the already matched path as the namespace,
+    #         # which is '/a' in this case.
+    #         r.hash_paths
+    #       end
+    #
+    #       r.on 'b' do
+    #         # uses :b as the namespace when looking up routes, as that was explicitly specified
+    #         r.hash_paths(:b)
+    #       end
+    #     end
+    #   end
+    #
+    # With the above routing tree, requests for the +/a+ branch will be handled by the first
+    # +r.hash_paths+ call, and requests for the +/b+ branch will be handled by the second
+    # +r.hash_paths+ call.  Those will dispatch to the configured hash paths for the +/a+ and
+    # +:b+ namespaces.
+    #
+    # It is best for performance to explicitly specify the namespace when calling
+    # +r.hash_paths+.
+    module HashPaths
+      def self.configure(app)
+        app.opts[:hash_paths] ||= {}
+      end
+
+      module ClassMethods
+        # Freeze the hash_paths metadata when freezing the app.
+        def freeze
+          opts[:hash_paths].freeze.each_value(&:freeze)
+          super
+        end
+
+        # Duplicate hash_paths metadata in subclass.
+        def inherited(subclass)
+          super
+
+          h = subclass.opts[:hash_paths]
+          opts[:hash_paths].each do |namespace, routes|
+            h[namespace] = routes.dup
+          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.delete(path)
+            remove_method(meth)
+          end
+        end
+      end
+
+      module RequestMethods
+        # 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
+      end
+    end
+
+    register_plugin(:hash_paths, HashPaths)
+  end
+end

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/heartbeat.rb

@@ -14,13 +14,6 @@ class Roda
     #
     #   plugin :heartbeat, path: '/status'
     module Heartbeat
-      # :nocov:
-      HEADER_CLASS = (defined?(Rack::Headers) && Rack::Headers.is_a?(Class)) ? Rack::Headers : Hash
-      # :nocov:
-      private_constant :HEADER_CLASS
-
-      HEARTBEAT_RESPONSE = [200, {'Content-Type'=>'text/plain'}.freeze, ['OK'.freeze].freeze].freeze
-
       # Set the heartbeat path to the given path.
       def self.configure(app, opts=OPTS)
         app.opts[:heartbeat_path] = (opts[:path] || app.opts[:heartbeat_path] || "/heartbeat").dup.freeze
@@ -32,9 +25,11 @@ class Roda
         # If the request is for a heartbeat path, return the heartbeat response.
         def _roda_before_20__heartbeat
           if env['PATH_INFO'] == opts[:heartbeat_path]
-            response = HEARTBEAT_RESPONSE.dup
-            response[1] = HEADER_CLASS[response[1]]
-            throw :halt, response
+            response = @_response
+            response.status = 200
+            response['Content-Type'] = 'text/plain'
+            response.write 'OK'
+            throw :halt, response.finish
           end
         end
       end

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/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/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