roda 3.44.0 → 3.48.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b60182ef0483279ac1d1983495ba020c1803d6c1fe0fa84af882142f816f72bc
-  data.tar.gz: 20f6053b7c73fed454dc3f39e55a516d7a5461a4005356b5788480b8aab36f14
+  metadata.gz: 34691daba87a890b955df8a9c89ac11e3b5b2ce3ac4726b5d4dbd526aaa5c8ce
+  data.tar.gz: e2d8399a4a17a432d39e531ef25db62028622bd258194e930ef3d2b55a722bb8
 SHA512:
-  metadata.gz: 89359f0c972c236bee671606fc7254f4999c6fc03f1b0ef8ff7c9691b581b6e796197b9fbee6fd109ae4d1026624f041d2e64c6182dbf8c80818756543923c9d
-  data.tar.gz: 2d786d8641f5195a65874f3326abe07057748e4de2df7d0a8e8cd9439b6afceb08e65b6a3733e15b0289e273cc070033c1dc466e1909880410b4d05541fa04ae
+  metadata.gz: 728e35715a74a04b373b3fa36fe8a7b81298de6d6c159de0ad95e654346e8c55d593d9ad4f067a0d8e1a569434085b333549efcc0467b28158332493b2ab8087
+  data.tar.gz: ee4d3b86e0b15dae0126b6ad032cfbe3055e9a1010f3cd0cf2d847cfb12ca4910b61f0030baa3e94fac8ac52304ca60a2b7825f2080cf28d51579dfd3d8cefa6

data/CHANGELOG

@@ -1,3 +1,19 @@
+= 3.48.0 (2021-09-13)
+
+* Extract named_routes plugin from multi_route plugin (jeremyevans)
+
+= 3.47.0 (2021-08-13)
+
+* Automatically optimize remaining r.on calls with a single argument (jeremyevans)
+
+= 3.46.0 (2021-07-12)
+
+* Automatically optimize r.on/r.is/r.get/r.post methods with a single string, String, Integer, or regexp argument (jeremyevans)
+
+= 3.45.0 (2021-06-14)
+
+* Make typecast_params plugin check for null bytes in strings by default, with :allow_null_bytes option for previous behavior (jeremyevans)
+
 = 3.44.0 (2021-05-12)
 
 * Add optimized_segment_matchers plugin for optimized matchers for a single String class argument (jeremyevans)

data/README.rdoc

@@ -13,7 +13,6 @@ Website :: http://roda.jeremyevans.net
 Source :: http://github.com/jeremyevans/roda
 Bugs :: http://github.com/jeremyevans/roda/issues
 Google Group :: http://groups.google.com/group/ruby-roda
-IRC :: irc://chat.freenode.net/#roda
 
 == Goals
 
@@ -965,19 +964,17 @@ option. If you really want to turn path checking off, you can do so via the
 Roda does not ship with integrated support for code reloading, but there are rack-based
 reloaders that will work with Roda apps.
 
-For most applications, {rack-unreloader}[https://github.com/jeremyevans/rack-unreloader]
-is probably the fastest approach to reloading while still being fairly safe, as it
-reloads just files that have been modified, and unloads constants defined in the files
-before reloading them.  However, it requires modifying your application code to use
-rack-unreloader specific APIs.
-
-A similar solution that reloads files and unloads constants is ActiveSupport::Dependencies.
-ActiveSupport::Dependencies doesn't require modifying your application code, but it modifies
-some core methods, including +require+ and +const_missing+. It requires less configuration,
-but depends that you follow Rails' file and class naming conventions. It also provides
-autoloading (on the fly) of files when a missing constant is accessed. If your application
-does not rely on autoloading then +require_dependency+ must be used to require the dependencies
-or they won't be reloaded.
+{Zeitwerk}[https://github.com/fxn/zeitwerk] (which Rails now uses for reloading) can be used
+with Roda.  It requires minimal setup and handles most cases. It overrides +require+ when
+activated. If it can meet the needs of your application, it's probably the best approach.
+
+{rack-unreloader}[https://github.com/jeremyevans/rack-unreloader] uses a fast
+approach to reloading while still being fairly safe, as it only reloads files that have
+been modified, and unloads constants defined in the files before reloading them. It can handle
+advanced cases that Zeitwerk does not support, such as classes defined in multiple files
+(common when using separate route files for different routing branches in the same application).
+However, rack-unreloader does not modify core classes and using it requires modifying your
+application code to use rack-unreloader specific APIs, which may not be simple.
 
 {AutoReloader}[https://github.com/rosenfeld/auto_reloader] provides transparent reloading for
 all files reached from one of the +reloadable_paths+ option entries, by detecting new top-level

data/doc/release_notes/3.45.0.txt

@@ -0,0 +1,22 @@
+= Improvements
+
+* The typecast_params plugin checks now checks for null bytes by
+  default before typecasting.  If null bytes are present, it raises
+  an error.  Most applications do not require null bytes in
+  parameters, and in some cases allowing them can lead to security
+  issues, especially when parameters are passed to C extensions.
+  In general, the benefit of forbidding null bytes in parameters is
+  greater than the cost.
+  
+  If you would like to continue allowing null bytes, use the
+  :allow_null_bytes option when loading the plugin.
+
+  Note that this change does not affect uploaded files, since those
+  are expected to contain null bytes.
+
+= Backwards Compatibility
+
+* The change to the typecast_params plugin to raise an error for
+  null bytes can break applications that are expecting null bytes
+  to be passed in parameters.  Such applications should use the
+  :allow_null_bytes option when loading the plugin.

data/doc/release_notes/3.46.0.txt

@@ -0,0 +1,19 @@
+= Improvements
+
+* The r.on, r.is, r.get and r.post methods (and other verb methods
+  if using the all_verbs plugin) have now been optimized when using
+  a single string or regexp matcher, or the String or Integer class
+  matcher.  Since those four matchers are the most common types of
+  matchers passed to the methods, this can significantly improve
+  routing performance (about 50% in the r10k benchmark).
+
+  This optimization is automatically applied when freezing
+  applications, if the related methods have not been modified by
+  plugins.
+
+  This optimization does come at the expense of a small decrease
+  in routing performance (3-4%) for unoptimized cases, but the
+  majority of applications will see a overall performance benefit
+  from this change.
+
+* Other minor performance improvements have been made.

data/doc/release_notes/3.47.0.txt

@@ -0,0 +1,13 @@
+= Improvements
+
+* The r.on optimization added in 3.46.0 has been extended to optimize
+  all single argument calls. This results in the following speedups
+  based on argument type:
+
+  * Hash matching: 10%
+  * Array/Symbol/Class matching: 15%
+  * Proc matching: 25%
+  * true matching: 45%
+  * false/nil matching: 65%
+
+* Other minor performance improvements have been made.

data/doc/release_notes/3.48.0.txt

@@ -0,0 +1,10 @@
+= New Features
+
+* A named_routes plugin has been added, for defining named route
+  blocks that you can dispatch to with r.route.  This feature was
+  previously available as part of the multi_route plugin, but there
+  are cases where the r.route method and support for named routes is
+  helpful even when the multi_route plugin is not used (such as when
+  the hash_routes plugin is used instead of the multi_route plugin).
+  The multi_route plugin now depends on the named_routes plugin, so
+  this change should not cause any backwards compatibility issues.

data/lib/roda/plugins/_optimized_matching.rb

@@ -0,0 +1,177 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The _optimized_matching plugin is automatically used internally to speed
+    # up matching when a single argument String instance, String class, Integer
+    # class, or Regexp matcher is passed to +r.on+, +r.is_+, or a verb method
+    # such as +r.get+ or +r.post+.
+    # 
+    # The optimization works by avoiding the +if_match+ method if possible.
+    # Instead of clearing the captures array on every call, and having the
+    # matching append to the captures, it checks directly for the match,
+    # and on succesful match, it yields directly to the block without using
+    # the captures array.
+    module OptimizedMatching 
+      TERM = Base::RequestMethods::TERM
+
+      module RequestMethods
+        # Optimize the r.is method handling of a single string, String, Integer,
+        # regexp, or true, argument.
+        def is(*args, &block)
+          case args.length
+          when 1
+            _is1(args, &block)
+          when 0
+            always(&block) if @remaining_path.empty?
+          else
+            if_match(args << TERM, &block)
+          end
+        end
+
+        # Optimize the r.on method handling of a single string, String, Integer,
+        # or regexp argument.  Inline the related matching code to avoid the
+        # need to modify @captures.
+        def on(*args, &block)
+          case args.length
+          when 1
+            case matcher = args[0]
+            when String
+              always{yield} if _match_string(matcher)
+            when Class
+              if matcher == String
+                rp = @remaining_path
+                if rp.getbyte(0) == 47
+                  if last = rp.index('/', 1)
+                    @remaining_path = rp[last, rp.length]
+                    always{yield rp[1, last-1]}
+                  elsif (len = rp.length) > 1
+                    @remaining_path = ""
+                    always{yield rp[1, len]}
+                  end
+                end
+              elsif matcher == Integer
+                if matchdata = /\A\/(\d+)(?=\/|\z)/.match(@remaining_path)
+                  @remaining_path = matchdata.post_match
+                  always{yield(matchdata[1].to_i)}
+                end
+              else
+                path = @remaining_path
+                captures = @captures.clear
+                meth = :"_match_class_#{matcher}"
+                if respond_to?(meth, true)
+                  # Allow calling private methods, as match methods are generally private
+                  if send(meth, &block)
+                    block_result(yield(*captures))
+                    throw :halt, response.finish
+                  else
+                    @remaining_path = path
+                    false
+                  end
+                else
+                  unsupported_matcher(matcher)
+                end
+              end
+            when Regexp
+              if matchdata = self.class.cached_matcher(matcher){matcher}.match(@remaining_path)
+                @remaining_path = matchdata.post_match
+                always{yield(*matchdata.captures)}
+              end
+            when true
+              always(&block)
+            when false, nil
+              # nothing
+            else
+              path = @remaining_path
+              captures = @captures.clear
+
+              matched = case matcher
+              when Array
+                _match_array(matcher)
+              when Hash
+                _match_hash(matcher)
+              when Symbol
+                _match_symbol(matcher)
+              when Proc
+                matcher.call
+              else
+                unsupported_matcher(matcher)
+              end
+
+              if matched
+                block_result(yield(*captures))
+                throw :halt, response.finish
+              else
+                @remaining_path = path
+                false
+              end
+            end
+          when 0
+            always(&block)
+          else
+            if_match(args, &block)
+          end
+        end
+
+        private
+
+        # Optimize the r.get/r.post method handling of a single string, String, Integer,
+        # regexp, or true, argument.
+        def _verb(args, &block)
+          case args.length
+          when 0
+            always(&block)
+          when 1
+            _is1(args, &block)
+          else
+            if_match(args << TERM, &block)
+          end
+        end
+
+        # Internals of r.is/r.get/r.post optimization.  Inline the related matching
+        # code to avoid the need to modify @captures.
+        def _is1(args, &block)
+          case matcher = args[0]
+          when String
+            rp = @remaining_path
+            if _match_string(matcher)
+              if @remaining_path.empty?
+                always{yield}
+              else
+                @remaining_path = rp
+                nil
+              end
+            end
+          when Class
+            if matcher == String
+              rp = @remaining_path
+              if rp.getbyte(0) == 47 && !rp.index('/', 1) && (len = rp.length) > 1
+                @remaining_path = ''
+                always{yield rp[1, len]}
+              end
+            elsif matcher == Integer
+              if matchdata = /\A\/(\d+)\z/.match(@remaining_path)
+                @remaining_path = ''
+                always{yield(matchdata[1].to_i)}
+              end
+            else
+              if_match(args << TERM, &block)
+            end
+          when Regexp
+            if (matchdata = self.class.cached_matcher(matcher){matcher}.match(@remaining_path)) && matchdata.post_match.empty?
+              @remaining_path = ''
+              always{yield(*matchdata.captures)}
+            end
+          when true
+            always(&block) if @remaining_path.empty?
+          else
+            if_match(args << TERM, &block)
+          end
+        end
+      end
+    end
+
+    register_plugin(:_optimized_matching, OptimizedMatching)
+  end
+end

data/lib/roda/plugins/assets.rb

@@ -152,6 +152,22 @@ class Roda
     # together and not compressed during compilation.  You can use the
     # :css_compressor and :js_compressor options to specify the compressor to use.
     #
+    # It is also possible to use the built-in compression options in the CSS or JS
+    # compiler, assuming the compiler supports such options.  For example, with
+    # sass/sassc, you can use:
+    #
+    #   plugin :assets,
+    #     css_opts: {style: :compressed}
+    #
+    # === Source Maps (CSS)
+    #
+    # The assets plugin does not have direct support for source maps, so it is
+    # recommended you use embedded source maps if supported by the CSS compiler.
+    # For sass/sassc, you can use:
+    #
+    #   plugin :assets,
+    #     css_opts: {:source_map_embed=>true, source_map_contents: true, source_map_file: "."}
+    #
     # === With Asset Groups
     #
     # When using asset groups, a separate compiled file will be produced per

data/lib/roda/plugins/content_for.rb

@@ -62,8 +62,7 @@ class Roda
       end
 
       # Configure whether to append or overwrite if content_for
-      # is called multiple times to set data. Overwrite is default, use
-      # the :append option to append.
+      # is called multiple times with the same key.
       def self.configure(app, opts = OPTS)
         app.opts[:append_content_for] = opts.fetch(:append, true)
       end

data/lib/roda/plugins/mail_processor.rb

@@ -566,7 +566,7 @@ class Roda
             end
             false
           when Regexp
-            if md = content.match(val)
+            if md = val.match(content)
               @captures.concat(md.captures)
             end
           else

data/lib/roda/plugins/multi_route.rb

@@ -3,15 +3,10 @@
 #
 class Roda
   module RodaPlugins
-    # The multi_route plugin allows for multiple named routes, which the
-    # main route block can dispatch to by name at any point by calling +route+.
-    # If the named route doesn't handle the request, execution will continue,
-    # and if the named route does handle the request, the response returned by
-    # the named route will be returned.
-    #
-    # In addition, this plugin adds the +r.multi_route+ method, which will check
-    # if the first segment in the path matches a named route, and dispatch
-    # to that named route.
+    # The multi_route plugin builds on the named_routes plugin and allows for
+    # dispatching to multiple named routes # by calling the +r.multi_route+ method,
+    # 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
     # and performs better than the +r.multi_route+ method, and it is recommended
@@ -35,23 +30,14 @@ class Roda
     #
     #   route do |r|
     #     r.multi_route
-    #
-    #     # or
-    #
-    #     r.on "foo" do
-    #       r.route 'foo'
-    #     end
-    #
-    #     r.on "bar" do
-    #       r.route 'bar'
-    #     end
     #   end
     #
-    # Note that in multi-threaded code, you should not attempt to add a
-    # named route after accepting requests.
+    # Note that only named routes with string names will be dispatched to by the
+    # +r.multi_route+ method. Named routes with other names can be dispatched to
+    # using the named_routes plugin API, but will not be automatically dispatched
+    # to by +r.multi_route+.
     #
-    # If you want to use the +r.multi_route+ method, use string names for the
-    # named routes.  Also, you can provide a block to +r.multi_route+ that is
+    # You can provide a block to +r.multi_route+ that is
     # called if the route matches but the named route did not handle the
     # request:
     #
@@ -62,20 +48,10 @@ class Roda
     # If a block is not provided to multi_route, the return value of the named
     # route block will be used.
     #
-    # == Routing Files
-    #
-    # The convention when using the multi_route plugin is to have a single
-    # named route per file, and these routing files should be stored in
-    # a routes subdirectory in your application.  So for the above example, you
-    # would use the following files:
-    #
-    #   routes/bar.rb
-    #   routes/foo.rb
-    #
     # == Namespace Support
     #
     # The multi_route plugin also has support for namespaces, allowing you to
-    # use r.multi_route at multiple levels in your routing tree.  Example:
+    # use +r.multi_route+ at multiple levels in your routing tree.  Example:
     #
     #   route('foo') do |r|
     #     r.multi_route('foo')
@@ -103,81 +79,38 @@ class Roda
     #
     #   route do |r|
     #     r.multi_route
-    #
-    #     # or
-    #
-    #     r.on "foo" do
-    #       r.on("baz"){r.route("baz", "foo")}
-    #       r.on("quux"){r.route("quux", "foo")}
-    #     end
-    #
-    #     r.on "bar" do
-    #       r.on("baz"){r.route("baz", "bar")}
-    #       r.on("quux"){r.route("quux", "bar")}
-    #     end
     #   end
-    #
-    # === Routing Files
-    #
-    # The convention when using namespaces with the multi_route plugin is to
-    # store the routing files in subdirectories per namespace. So for the
-    # above example, you would have the following routing files:
-    #
-    #   routes/bar.rb
-    #   routes/bar/baz.rb
-    #   routes/bar/quux.rb
-    #   routes/foo.rb
-    #   routes/foo/baz.rb
-    #   routes/foo/quux.rb
     module MultiRoute
+      def self.load_dependencies(app)
+        app.plugin :named_routes
+      end
+
       # Initialize storage for the named routes.
       def self.configure(app)
-        app.opts[:namespaced_routes] ||= {}
         app::RodaRequest.instance_variable_set(:@namespaced_route_regexps, {})
       end
 
       module ClassMethods
-        # Freeze the namespaced routes and setup the regexp matchers so that there can be no thread safety issues at runtime.
+        # Freeze the multi_route regexp matchers so that there can be no thread safety issues at runtime.
         def freeze
-          opts[:namespaced_routes].freeze.each do |k,v|
-            v.freeze
+          super
+          opts[:namespaced_routes].each_key do |k|
             self::RodaRequest.named_route_regexp(k)
           end
           self::RodaRequest.instance_variable_get(:@namespaced_route_regexps).freeze
-          super
         end
 
         # Copy the named routes into the subclass when inheriting.
         def inherited(subclass)
           super
-          nsr = subclass.opts[:namespaced_routes]
-          opts[:namespaced_routes].each{|k, v| nsr[k] = v.dup}
           subclass::RodaRequest.instance_variable_set(:@namespaced_route_regexps, {})
         end
 
-        # The names for the currently stored named routes
-        def named_routes(namespace=nil)
-          unless routes = opts[:namespaced_routes][namespace]
-            raise RodaError, "unsupported multi_route namespace used: #{namespace.inspect}"
-          end
-          routes.keys
-        end
-
-        # Return the named route with the given name.
-        def named_route(name, namespace=nil)
-          opts[:namespaced_routes][namespace][name]
-        end
-
-        # If the given route has a name, treat it as a named route and
-        # store the route block.  Otherwise, this is the main route, so
-        # call super.
+        # Clear the multi_route regexp matcher for the namespace.
         def route(name=nil, namespace=nil, &block)
+          super
           if name
-            routes = opts[:namespaced_routes][namespace] ||= {}
-            routes[name] = define_roda_method(routes[name] || "multi_route_#{namespace}_#{name}", 1, &convert_route_block(block))
             self::RodaRequest.clear_named_route_regexp!(namespace)
-          else
-            super(&block)
           end
         end
       end
@@ -206,19 +139,14 @@ class Roda
         # is given, yield to the block.
         def multi_route(namespace=nil)
           on self.class.named_route_regexp(namespace) do |section|
-            r = route(section, namespace)
+            res = route(section, namespace)
             if block_given?
               yield
             else
-              r
+              res
             end
           end
         end
-
-        # Dispatch to the named route with the given name.
-        def route(name, namespace=nil)
-          scope.send(roda_class.named_route(name, namespace), self)
-        end
       end
     end
 

data/lib/roda/plugins/named_routes.rb

@@ -0,0 +1,160 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The named_routes plugin allows for multiple named routes, which the
+    # main route block can dispatch to by name at any point by calling +r.route+.
+    # If the named route doesn't handle the request, execution will continue,
+    # and if the named route does handle the request, the response returned by
+    # the named route will be returned.
+    #
+    # Example:
+    #
+    #   plugin :multi_route
+    #
+    #   route('foo') do |r|
+    #     r.is 'bar' do
+    #       '/foo/bar'
+    #     end
+    #   end
+    #
+    #   route('bar') do |r|
+    #     r.is 'foo' do
+    #       '/bar/foo'
+    #     end
+    #   end
+    #
+    #   route do |r|
+    #     r.on "foo" do
+    #       r.route 'foo'
+    #     end
+    #
+    #     r.on "bar" do
+    #       r.route 'bar'
+    #     end
+    #   end
+    #
+    # Note that in multi-threaded code, you should not attempt to add a
+    # named route after accepting requests.
+    #
+    # == Routing Files
+    #
+    # The convention when using the named_routes plugin is to have a single
+    # named route per file, and these routing files should be stored in
+    # a routes subdirectory in your application.  So for the above example, you
+    # would use the following files:
+    #
+    #   routes/bar.rb
+    #   routes/foo.rb
+    #
+    # == Namespace Support
+    #
+    # The named_routes plugin also has support for namespaces, allowing you to
+    # use +r.route+ at multiple levels in your routing tree.  Example:
+    #
+    #   route('foo') do |r|
+    #     r.on("baz"){r.route("baz", "foo")}
+    #     r.on("quux"){r.route("quux", "foo")}
+    #   end
+    #
+    #   route('bar') do |r|
+    #     r.on("baz"){r.route("baz", "bar")}
+    #     r.on("quux"){r.route("quux", "bar")}
+    #   end
+    #
+    #   route('baz', 'foo') do |r|
+    #     # handles /foo/baz prefix
+    #   end
+    #
+    #   route('quux', 'foo') do |r|
+    #     # handles /foo/quux prefix
+    #   end
+    #
+    #   route('baz', 'bar') do |r|
+    #     # handles /bar/baz prefix
+    #   end
+    #
+    #   route('quux', 'bar') do |r|
+    #     # handles /bar/quux prefix
+    #   end
+    #
+    #   route do |r|
+    #     r.on "foo" do
+    #       r.route("foo")
+    #     end
+    #
+    #     r.on "bar" do
+    #       r.route("bar")
+    #     end
+    #   end
+    #
+    # === Routing Files
+    #
+    # The convention when using namespaces with the multi_route plugin is to
+    # store the routing files in subdirectories per namespace. So for the
+    # above example, you would have the following routing files:
+    #
+    #   routes/bar.rb
+    #   routes/bar/baz.rb
+    #   routes/bar/quux.rb
+    #   routes/foo.rb
+    #   routes/foo/baz.rb
+    #   routes/foo/quux.rb
+    module NamedRoutes
+      # Initialize storage for the named routes.
+      def self.configure(app)
+        app.opts[:namespaced_routes] ||= {}
+      end
+
+      module ClassMethods
+        # Freeze the namespaced routes so that there can be no thread safety issues at runtime.
+        def freeze
+          opts[:namespaced_routes].freeze.each_value(&:freeze)
+          super
+        end
+
+        # Copy the named routes into the subclass when inheriting.
+        def inherited(subclass)
+          super
+          nsr = subclass.opts[:namespaced_routes]
+          opts[:namespaced_routes].each{|k, v| nsr[k] = v.dup}
+        end
+
+        # The names for the currently stored named routes
+        def named_routes(namespace=nil)
+          unless routes = opts[:namespaced_routes][namespace]
+            raise RodaError, "unsupported multi_route namespace used: #{namespace.inspect}"
+          end
+          routes.keys
+        end
+
+        # Return the named route with the given name.
+        def named_route(name, namespace=nil)
+          opts[:namespaced_routes][namespace][name]
+        end
+
+        # If the given route has a name, treat it as a named route and
+        # store the route block.  Otherwise, this is the main route, so
+        # call super.
+        def route(name=nil, namespace=nil, &block)
+          if name
+            routes = opts[:namespaced_routes][namespace] ||= {}
+            routes[name] = define_roda_method(routes[name] || "multi_route_#{namespace}_#{name}", 1, &convert_route_block(block))
+          else
+            super(&block)
+          end
+        end
+      end
+
+      module RequestMethods
+        # Dispatch to the named route with the given name.
+        def route(name, namespace=nil)
+          scope.send(roda_class.named_route(name, namespace), self)
+        end
+      end
+    end
+
+    register_plugin(:named_routes, NamedRoutes)
+  end
+end

data/lib/roda/plugins/type_routing.rb

@@ -184,7 +184,7 @@ class Roda
           path = super
 
           if opts[:use_extension]
-            if m = path.match(opts[:extension_regexp])
+            if m = opts[:extension_regexp].match(path)
               @type_routing_extension =  @requested_type = m[2].to_sym
               path = m[1]
             end

data/lib/roda/plugins/typecast_params.rb

@@ -260,6 +260,11 @@ class Roda
     # strip leading and trailing whitespace from parameter string values before processing, which
     # you can do by passing the <tt>strip: :all</tt> option when loading the plugin.
     #
+    # By default, the typecast_params conversion procs check that null bytes are not allowed
+    # in param string values. This check for null bytes occurs prior to any type conversion.
+    # If you would like to skip this check and allow null bytes in param string values,
+    # you can do by passing the <tt>:allow_null_bytes</tt> option when loading the plugin.
+    #
     # By design, typecast_params only deals with string keys, it is not possible to use
     # symbol keys as arguments to the conversion methods and have them converted.
     module TypecastParams
@@ -356,6 +361,14 @@ class Roda
         end
       end
 
+      module AllowNullByte
+        private
+
+        # Allow ASCII NUL bytes ("\0") in parameter string values.
+        def check_null_byte(v)
+        end
+      end
+
       module StringStripper
         private
 
@@ -391,7 +404,10 @@ class Roda
           convert_array_meth = :"_convert_array_#{type}"
           define_method(convert_array_meth) do |v|
             raise Error, "expected array but received #{v.inspect}" unless v.is_a?(Array)
-            v.map!{|val| send(convert_meth, val)}
+            v.map! do |val|
+              check_null_byte(val)
+              send(convert_meth, val)
+            end
           end
 
           private convert_meth, convert_array_meth
@@ -927,12 +943,20 @@ class Roda
           end
         end
 
+        # Raise an Error if the value is a string containing a null byte.
+        def check_null_byte(v)
+          if v.is_a?(String) && v.index("\0")
+            handle_error(nil, :null_byte, "string parameter contains null byte", true)
+          end
+        end
+
         # Get the value of +key+ for the object, and convert it to the expected type using +meth+.
         # If the value either before or after conversion is nil, return the +default+ value.
         def process(meth, key, default)
           v = param_value(key)
 
           unless v.nil?
+            check_null_byte(v)
             v = send(meth, v)
           end
 
@@ -992,6 +1016,9 @@ class Roda
         if opts[:strip] == :all
           app::TypecastParams.send(:include, StringStripper)
         end
+        if opts[:allow_null_bytes]
+          app::TypecastParams.send(:include, AllowNullByte)
+        end
       end
 
       module ClassMethods

data/lib/roda/request.rb

@@ -24,7 +24,7 @@ class Roda
 
         # Return the cached pattern for the given object.  If the object is
         # not already cached, yield to get the basic pattern, and convert the
-        # basic pattern to a pattern that does not partial segments.
+        # basic pattern to a pattern that does not match partial segments.
         def cached_matcher(obj)
           cache = @match_pattern_cache
 
@@ -234,9 +234,7 @@ class Roda
 
         # An alias of remaining_path. If a plugin changes remaining_path then
         # it should override this method to return the untouched original.
-        def real_remaining_path
-          remaining_path
-        end
+        alias real_remaining_path remaining_path
 
         # Match POST requests.  If no arguments are provided, matches all POST
         # requests, otherwise, matches only POST requests where the arguments
@@ -336,7 +334,7 @@ class Roda
         # Use <tt>r.get true</tt> to handle +GET+ requests where the current
         # path is empty.
         def root(&block)
-          if remaining_path == "/" && is_get?
+          if @remaining_path == "/" && is_get?
             always(&block)
           end
         end
@@ -519,7 +517,7 @@ class Roda
         # SCRIPT_NAME to include the matched path, removes the matched
         # path from PATH_INFO, and updates captures with any regex captures.
         def consume(pattern)
-          if matchdata = remaining_path.match(pattern)
+          if matchdata = pattern.match(@remaining_path)
             @remaining_path = matchdata.post_match
             captures = matchdata.captures
             captures = yield(*captures) if block_given?
@@ -548,7 +546,7 @@ class Roda
 
         # Whether the current path is considered empty.
         def empty_path?
-          remaining_path.empty?
+          @remaining_path.empty?
         end
 
         # If all of the arguments match, yields to the match block and

data/lib/roda/version.rb

@@ -4,7 +4,7 @@ class Roda
   RodaMajorVersion = 3
 
   # The minor version of Roda, updated for new feature releases of Roda.
-  RodaMinorVersion = 44
+  RodaMinorVersion = 48
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

data/lib/roda.rb

@@ -212,6 +212,10 @@ class Roda
             if @middleware.empty? && use_new_dispatch_api?
               plugin :direct_call
             end
+
+            if ([:on, :is, :_verb, :_match_class_String, :_match_class_Integer, :_match_string, :_match_regexp, :empty_path?, :if_match, :match, :_match_class]).all?{|m| self::RodaRequest.instance_method(m).owner == RequestMethods}
+              plugin :_optimized_matching
+            end
           end
 
           build_rack_app

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.44.0
+  version: 3.48.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-12 00:00:00.000000000 Z
+date: 2021-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -215,6 +215,10 @@ extra_rdoc_files:
 - doc/release_notes/3.42.0.txt
 - doc/release_notes/3.43.0.txt
 - doc/release_notes/3.44.0.txt
+- doc/release_notes/3.45.0.txt
+- doc/release_notes/3.46.0.txt
+- doc/release_notes/3.47.0.txt
+- doc/release_notes/3.48.0.txt
 - doc/release_notes/3.5.0.txt
 - doc/release_notes/3.6.0.txt
 - doc/release_notes/3.7.0.txt
@@ -266,6 +270,10 @@ files:
 - doc/release_notes/3.42.0.txt
 - doc/release_notes/3.43.0.txt
 - doc/release_notes/3.44.0.txt
+- doc/release_notes/3.45.0.txt
+- doc/release_notes/3.46.0.txt
+- doc/release_notes/3.47.0.txt
+- doc/release_notes/3.48.0.txt
 - doc/release_notes/3.5.0.txt
 - doc/release_notes/3.6.0.txt
 - doc/release_notes/3.7.0.txt
@@ -276,6 +284,7 @@ files:
 - lib/roda/plugins.rb
 - lib/roda/plugins/_after_hook.rb
 - lib/roda/plugins/_before_hook.rb
+- lib/roda/plugins/_optimized_matching.rb
 - lib/roda/plugins/_symbol_regexp_matchers.rb
 - lib/roda/plugins/all_verbs.rb
 - lib/roda/plugins/assets.rb
@@ -332,6 +341,7 @@ files:
 - lib/roda/plugins/multi_run.rb
 - lib/roda/plugins/multi_view.rb
 - lib/roda/plugins/multibyte_string_matcher.rb
+- lib/roda/plugins/named_routes.rb
 - lib/roda/plugins/named_templates.rb
 - lib/roda/plugins/not_allowed.rb
 - lib/roda/plugins/not_found.rb
@@ -407,7 +417,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Routing tree web toolkit