roda 3.108.0 → 3.109.0

data/lib/roda/plugins/ip_from_header.rb

@@ -20,11 +20,15 @@ class Roda
         app.opts[:ip_from_header_env_key] = "HTTP_#{header.upcase.tr('-', '_')}".freeze
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :ip_from_header_env_key)
+      end
+
       module RequestMethods
         # Return the IP address continained in the configured header, if present.
         # Fallback to the default behavior if not present.
         def ip
-          @env[roda_class.opts[:ip_from_header_env_key]] || super
+          @env[roda_class.ip_from_header_env_key] || super
         end
       end
     end

data/lib/roda/plugins/json.rb

@@ -1,7 +1,5 @@
 # frozen-string-literal: true
 
-require 'json'
-
 class Roda
   module RodaPlugins
     # The json plugin allows match blocks to return
@@ -57,6 +55,7 @@ class Roda
     # not support treating String, FalseClass, or NilClass values as JSON.
     module Json
       def self.load_dependencies(app, opts=OPTS)
+        app.plugin :_json
         app.plugin :custom_block_results
       end
 
@@ -69,10 +68,10 @@ class Roda
         classes.uniq!
         classes.freeze
         classes.each do |klass|
-          app.opts[:custom_block_results][klass] = :handle_json_block_result
+          app.custom_block_results[klass] = :handle_json_block_result
         end
 
-        app.opts[:json_result_serializer] = opts[:serializer] || app.opts[:json_result_serializer] || app.opts[:json_serializer] || :to_json.to_proc
+        app.opts[:json_result_serializer] = opts[:serializer] || app.json_result_serializer || app.json_serializer
 
         app.opts[:json_result_include_request] = opts[:include_request] if opts.has_key?(:include_request)
 
@@ -80,6 +79,10 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :json_result_serializer)
+        RodaPlugins.opt_attr_reader(self, :json_result_include_request, name: :json_result_include_request?)
+        RodaPlugins.opt_attr_reader(self, :json_result_content_type)
+
         # The classes that should be automatically converted to json
         def json_result_classes
           # RODA4: remove, only used by previous implementation.
@@ -91,7 +94,7 @@ class Roda
         # Handle a result for one of the registered JSON result classes
         # by converting the result to JSON.
         def handle_json_block_result(result)
-          @_response[RodaResponseHeaders::CONTENT_TYPE] ||= opts[:json_result_content_type]
+          @_response[RodaResponseHeaders::CONTENT_TYPE] ||= self.class.json_result_content_type
           @_request.send(:convert_to_json, result)
         end
       end
@@ -102,10 +105,9 @@ class Roda
         # Convert the given object to JSON.  Uses to_json by default,
         # but can use a custom serializer passed to the plugin.
         def convert_to_json(result)
-          opts = roda_class.opts
-          serializer = opts[:json_result_serializer]
+          serializer = roda_class.json_result_serializer
 
-          if opts[:json_result_include_request]
+          if roda_class.json_result_include_request?
             serializer.call(result, self)
           else
             serializer.call(result)

data/lib/roda/plugins/json_parser.rb

@@ -1,7 +1,5 @@
 # frozen-string-literal: true
 
-require 'json'
-
 class Roda
   module RodaPlugins
     # The json_parser plugin parses request bodies in JSON format
@@ -22,6 +20,10 @@ class Roda
       # simplecov:enable
       private_constant :MATCH_METHOD
 
+      def self.load_dependencies(app, opts=OPTS)
+        app.plugin :_json
+      end
+
       # Handle options for the json_parser plugin:
       # :content_type_regexp :: A regexp used to determine if the request's
       #                         content type is JSON. For backwards compatibility,
@@ -46,12 +48,12 @@ class Roda
       #          :always will wrap all values, and a value of :unless_hash will
       #          only wrap values that are not already hashes.
       def self.configure(app, opts=OPTS)
-        app.opts[:json_parser_error_handler] = opts[:error_handler] || app.opts[:json_parser_error_handler] || DEFAULT_ERROR_HANDLER
-        app.opts[:json_parser_parser] = opts[:parser] || app.opts[:json_parser_parser] || app.opts[:json_parser] || JSON.method(:parse)
+        app.opts[:json_parser_error_handler] = opts[:error_handler] || app.json_parser_error_handler || DEFAULT_ERROR_HANDLER
+        app.opts[:json_parser_parser] = opts[:parser] || app.json_parser_parser || app.json_parser
         app.opts[:json_parser_include_request] = opts[:include_request] if opts.has_key?(:include_request)
-        app.opts[:json_parser_content_type_regexp] = opts[:content_type_regexp] || app.opts[:json_parser_content_type_regexp]
+        app.opts[:json_parser_content_type_regexp] = opts[:content_type_regexp] || app.json_parser_content_type_regexp
 
-        unless app.opts[:json_parser_content_type_regexp]
+        unless app.json_parser_content_type_regexp
           # RODA4: Switch to /\Aapplication\/(?:vnd\.api\+)?json\b/i by default
           RodaPlugins.warn(':content_type_regexp option not provided to json_parser plugin, using /json/ for backwards compatibility, which may be insecure, using /\Aapplication\/json\b/i or /\Aapplication\/(?:vnd\.api\+)?json\b/i is recommended')
           app.opts[:json_parser_content_type_regexp] = /json/
@@ -67,6 +69,14 @@ class Roda
         end
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :json_parser_error_handler)
+        RodaPlugins.opt_attr_reader(self, :json_parser_parser)
+        RodaPlugins.opt_attr_reader(self, :json_parser_include_request, name: :json_parser_include_request?)
+        RodaPlugins.opt_attr_reader(self, :json_parser_content_type_regexp)
+        RodaPlugins.opt_attr_reader(self, :json_parser_wrap)
+      end
+
       module RequestMethods
         # If the Content-Type header in the request includes "json",
         # parse the request body as JSON.  Ignore an empty request body.
@@ -76,7 +86,7 @@ class Roda
             return post_params
           end
 
-          unless (input = env["rack.input"]) && (content_type = self.content_type) && roda_class.opts[:json_parser_content_type_regexp].send(MATCH_METHOD, content_type)
+          unless (input = env["rack.input"]) && (content_type = self.content_type) && roda_class.json_parser_content_type_regexp.send(MATCH_METHOD, content_type)
             return super
           end
 
@@ -85,10 +95,10 @@ class Roda
           begin
             json_params = parse_json(str)
           rescue
-            roda_class.opts[:json_parser_error_handler].call(self)
+            roda_class.json_parser_error_handler.call(self)
           end
 
-          wrap = roda_class.opts[:json_parser_wrap]
+          wrap = roda_class.json_parser_wrap
           if wrap == :always || (wrap == :unless_hash && !json_params.is_a?(Hash))
             json_params = {"_json"=>json_params}
           end
@@ -99,9 +109,13 @@ class Roda
         private
 
         def parse_json(str)
-          args = [str]
-          args << self if roda_class.opts[:json_parser_include_request]
-          roda_class.opts[:json_parser_parser].call(*args)
+          parser = roda_class.json_parser_parser
+
+          if roda_class.json_parser_include_request?
+            parser.call(str, self)
+          else
+            parser.call(str)
+          end
         end
         
         # Rack 3 dropped requirement that input be rewindable

data/lib/roda/plugins/mail_processor.rb

@@ -285,11 +285,14 @@ class Roda
       class UnhandledMail < StandardError; end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :mail_processor_string_routes)
+        RodaPlugins.opt_attr_reader(self, :mail_processor_regexp_routes)
+
         # Freeze the rcpt routes if they are present.
         def freeze
-          if string_routes = opts[:mail_processor_string_routes].freeze
+          if string_routes = mail_processor_string_routes.freeze
             string_routes.freeze
-            opts[:mail_processor_regexp_routes].freeze
+            mail_processor_regexp_routes.freeze
           end
           super
         end
@@ -337,12 +340,12 @@ class Roda
               unless string_meth
                 string_meth = define_roda_method("mail_processor_string_route_#{address}", 1, &convert_route_block(block))
               end
-              opts[:mail_processor_string_routes][address] = string_meth 
+              mail_processor_string_routes[address] = string_meth 
             when Regexp
               unless regexp_meth
                 regexp_meth = define_roda_method("mail_processor_regexp_route_#{address}", :any, &convert_route_block(block))
               end
-              opts[:mail_processor_regexp_routes][address] = regexp_meth
+              mail_processor_regexp_routes[address] = regexp_meth
             else
               raise RodaError, "invalid address format passed to rcpt, should be Array or String"
             end
@@ -382,7 +385,7 @@ class Roda
         # routes defined via the class-level +rcpt+ method, and then the
         # normal routing tree passed in as the block.
         def process_mail(&block)
-          if string_routes = opts[:mail_processor_string_routes]
+          if string_routes = self.class.mail_processor_string_routes
             addresses = mail_recipients
 
             addresses.each do |address|
@@ -392,7 +395,7 @@ class Roda
               end
             end
 
-            opts[:mail_processor_regexp_routes].each do |regexp, meth|
+            self.class.mail_processor_regexp_routes.each do |regexp, meth|
               addresses.each do |address|
                 if md = regexp.match(address)
                   _roda_handle_route{send(meth, @_request, *md.captures)}

data/lib/roda/plugins/mailer.rb

@@ -136,10 +136,12 @@ class Roda
       # Set the options for the mailer.  Options:
       # :content_type :: The default content type for emails (default: text/plain)
       def self.configure(app, opts=OPTS)
-        app.opts[:mailer] = (app.opts[:mailer]||OPTS).merge(opts).freeze
+        app.opts[:mailer] = (app.mailer_opts||OPTS).merge(opts).freeze
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :mailer, name: :mailer_opts)
+
         # Return a Mail::Message instance for the email for the given request path
         # and arguments.   Any arguments given are yielded to the appropriate +r.mail+
         # block after any usual match block arguments. You can further manipulate the
@@ -177,7 +179,7 @@ class Roda
         def mail(*args)
           if @env["REQUEST_METHOD"] == "MAIL"
             # RODA4: Make terminal match the default
-            send(roda_class.opts[:mailer][:terminal] ? :_verb : :if_match, args) do |*vs|
+            send(roda_class.mailer_opts[:terminal] ? :_verb : :if_match, args) do |*vs|
               yield(*(vs + @env['roda.mail_args']))
             end
           end
@@ -202,7 +204,7 @@ class Roda
               block.call if block
             end
 
-            if content_type = header_content_type || roda_class.opts[:mailer][:content_type]
+            if content_type = header_content_type || roda_class.mailer_opts[:content_type]
               if mail.multipart?
                 if /multipart\/mixed/ =~ mail.content_type &&
                    mail.parts.length >= 2 &&

data/lib/roda/plugins/match_affix.rb

@@ -39,13 +39,18 @@ class Roda
         app.opts[:match_suffix] = suffix if suffix
       end
       
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :match_prefix)
+        RodaPlugins.opt_attr_reader(self, :match_suffix)
+      end
+
       module RequestClassMethods
         private
 
         # Use the match prefix and suffix provided when loading the plugin, or fallback
         # to Roda's default prefix/suffix if one was not provided.
         def consume_pattern(pattern)
-          /\A#{roda_class.opts[:match_prefix] || "/"}(?:#{pattern})#{roda_class.opts[:match_suffix] || "(?=\/|\z)"}/
+          /\A#{roda_class.match_prefix || "/"}(?:#{pattern})#{roda_class.match_suffix || "(?=\/|\z)"}/
         end
       end
 

data/lib/roda/plugins/match_hook_args.rb

@@ -40,20 +40,22 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :match_hook_args)
+
         # Freeze the array of hook methods when freezing the app
         def freeze
-          opts[:match_hook_args].freeze
+          match_hook_args.freeze
           super
         end
 
         # Add a match hook that will be called with matchers and block args.
         def add_match_hook(&block)
-          opts[:match_hook_args] << define_roda_method("match_hook_args", :any, &block)
+          match_hook_args << define_roda_method("match_hook_args", :any, &block)
 
-          if opts[:match_hook_args].length == 1
-            class_eval("alias _match_hook_args #{opts[:match_hook_args].first}", __FILE__, __LINE__)
+          if match_hook_args.length == 1
+            class_eval("alias _match_hook_args #{match_hook_args.first}", __FILE__, __LINE__)
           else
-            class_eval("def _match_hook_args(v, a); #{opts[:match_hook_args].map{|m| "#{m}(v, a)"}.join(';')} end", __FILE__, __LINE__)
+            class_eval("def _match_hook_args(v, a); #{match_hook_args.map{|m| "#{m}(v, a)"}.join(';')} end", __FILE__, __LINE__)
           end
 
           public :_match_hook_args

data/lib/roda/plugins/middleware.rb

@@ -136,10 +136,10 @@ class Roda
         def initialize(mid, app, *args, &block)
           @mid = Class.new(mid)
           RodaPlugins.set_temp_name(@mid){"#{mid}::middleware_subclass"}
-          if @mid.opts[:middleware_next_if_not_found]
+          if @mid.middleware_next_if_not_found?
             @mid.plugin(:not_found, &NEXT_PROC)
           end
-          if configure = @mid.opts[:middleware_configure]
+          if configure = @mid.middleware_configure
             configure.call(@mid, *args, &block)
           elsif block || !args.empty?
             raise RodaError, "cannot provide middleware args or block unless loading middleware plugin with a block"
@@ -154,7 +154,7 @@ class Roda
           res = nil
 
           call_next = catch(:next) do
-            env[@mid.opts[:middleware_env_var]] = true
+            env[@mid.middleware_env_var] = true
             res = @mid.call(env)
             false
           end
@@ -167,7 +167,7 @@ class Roda
             end
           end
 
-          if handle_result = @mid.opts[:middleware_handle_result]
+          if handle_result = @mid.middleware_handle_result
             handle_result.call(env, res)
           end
 
@@ -176,6 +176,12 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :middleware_env_var)
+        RodaPlugins.opt_attr_reader(self, :middleware_configure)
+        RodaPlugins.opt_attr_reader(self, :middleware_handle_result)
+        RodaPlugins.opt_attr_reader(self, :middleware_forward_response_headers)
+        RodaPlugins.opt_attr_reader(self, :middleware_next_if_not_found, name: :middleware_next_if_not_found?)
+
         # Create a Forwarder instead of a new instance if a non-Hash is given.
         def new(app, *args, &block)
           if app.is_a?(Hash)
@@ -193,7 +199,7 @@ class Roda
           super do |r|
             res = instance_exec(r, &block) # call Fallback
             if r.forward_next
-              r.env['roda.response_headers'] = response.headers if opts[:middleware_forward_response_headers]
+              r.env['roda.response_headers'] = response.headers if self.class.middleware_forward_response_headers
               throw :next, true
             end
             res
@@ -205,7 +211,7 @@ class Roda
         def _roda_run_main_route(r)
           res = super
           if r.forward_next
-            r.env['roda.response_headers'] = response.headers if opts[:middleware_forward_response_headers]
+            r.env['roda.response_headers'] = response.headers if self.class.middleware_forward_response_headers
             throw :next, true
           end
           res
@@ -216,7 +222,7 @@ class Roda
         # Whether to forward the request to the next application.  Set only if
         # this request is being performed for middleware.
         def forward_next
-          env[roda_class.opts[:middleware_env_var]]
+          env[roda_class.middleware_env_var]
         end
       end
     end

data/lib/roda/plugins/module_include.rb

@@ -83,7 +83,7 @@ class Roda
               klass.send(:include, mod)
             end
 
-            mod.module_eval(&block) if block
+            mod.module_eval(&block) if block # RODA4: Switch to module_exec
           end
 
           mod

data/lib/roda/plugins/multi_public.rb

@@ -72,7 +72,7 @@ class Roda
 
       # Use the given directories to setup servers.  Any opts are passed to the public plugin.
       def self.configure(app, directories, _=OPTS)
-        roots = app.opts[:multi_public_servers] = (app.opts[:multi_public_servers] || {}).dup
+        roots = app.opts[:multi_public_servers] = (app.multi_public_servers || {}).dup
         directories.each do |key, path|
           path, headers, mime = path
           roots[key] = RACK_FILES.new(app.expand_path(path), headers||{}, mime||'text/plain')
@@ -80,11 +80,15 @@ class Roda
         roots.freeze
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :multi_public_servers)
+      end
+
       module RequestMethods
         # Serve files from the directory corresponding to the given key if the file exists and
         # this is a GET request.
         def multi_public(key)
-          public_serve_with(roda_class.opts[:multi_public_servers].fetch(key))
+          public_serve_with(roda_class.multi_public_servers.fetch(key))
         end
       end
     end

data/lib/roda/plugins/multi_route.rb

@@ -94,7 +94,7 @@ class Roda
         # Freeze the multi_route regexp matchers so that there can be no thread safety issues at runtime.
         def freeze
           super
-          opts[:namespaced_routes].each_key do |k|
+          namespaced_routes.each_key do |k|
             self::RodaRequest.named_route_regexp(k)
           end
           self::RodaRequest.instance_variable_get(:@namespaced_route_regexps).freeze

data/lib/roda/plugins/multi_run.rb

@@ -70,12 +70,15 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :multi_run_apps)
+        RodaPlugins.opt_attr_reader(self, :multi_run_app_blocks)
+
         # Convert app blocks into apps by calling them, in order to force autoloads
         # and to speed up subsequent calls.
         # Freeze the multi_run apps so that there can be no thread safety issues at runtime.
         def freeze
-          app_blocks = opts[:multi_run_app_blocks]
-          apps = opts[:multi_run_apps]
+          app_blocks = multi_run_app_blocks
+          apps = multi_run_apps
           app_blocks.each do |prefix, block|
             apps[prefix] = block.call
           end
@@ -85,12 +88,6 @@ class Roda
           super
         end
 
-        # Hash storing rack applications to dispatch to, keyed by the prefix
-        # for the application.
-        def multi_run_apps
-          opts[:multi_run_apps]
-        end
-
         # Add a rack application to dispatch to for the given prefix when
         # r.multi_run is called. If a block is given, it is called every time
         # there is a request for the route to get the app to call. If neither
@@ -100,14 +97,14 @@ class Roda
           prefix = prefix.to_s
           if app 
             raise Roda::RodaError, "cannot provide both app and block to Roda.run" if block
-            opts[:multi_run_apps][prefix] = app
-            opts[:multi_run_app_blocks].delete(prefix)
+            multi_run_apps[prefix] = app
+            multi_run_app_blocks.delete(prefix)
           elsif block
-            opts[:multi_run_apps].delete(prefix)
-            opts[:multi_run_app_blocks][prefix] = block
+            multi_run_apps.delete(prefix)
+            multi_run_app_blocks[prefix] = block
           else
-            opts[:multi_run_apps].delete(prefix)
-            opts[:multi_run_app_blocks].delete(prefix)
+            multi_run_apps.delete(prefix)
+            multi_run_app_blocks.delete(prefix)
           end
           self::RodaRequest.refresh_multi_run_regexp!
         end
@@ -117,7 +114,7 @@ class Roda
         # Refresh the multi_run_regexp, using the stored route prefixes,
         # preferring longer routes before shorter routes.
         def refresh_multi_run_regexp!
-          @multi_run_regexp = /(#{Regexp.union((roda_class.opts[:multi_run_apps].keys + roda_class.opts[:multi_run_app_blocks].keys).sort.reverse)})/
+          @multi_run_regexp = /(#{Regexp.union((roda_class.multi_run_apps.keys + roda_class.multi_run_app_blocks.keys).sort.reverse)})/
         end
 
         # Refresh the multi_run_regexp if it hasn't been loaded yet.
@@ -132,8 +129,7 @@ class Roda
         def multi_run
           on self.class.multi_run_regexp do |prefix|
             yield prefix if defined?(yield)
-            opts = scope.opts
-            run(opts[:multi_run_apps][prefix] || opts[:multi_run_app_blocks][prefix].call)
+            run(roda_class.multi_run_apps[prefix] || roda_class.multi_run_app_blocks[prefix].call)
           end
         end
       end

data/lib/roda/plugins/named_routes.rb

@@ -111,22 +111,24 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :namespaced_routes)
+
         # Freeze the namespaced routes so that there can be no thread safety issues at runtime.
         def freeze
-          opts[:namespaced_routes].freeze.each_value(&:freeze)
+          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}
+          nsr = subclass.namespaced_routes
+          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]
+          unless routes = namespaced_routes[namespace]
             raise RodaError, "unsupported named_routes namespace used: #{namespace.inspect}"
           end
           routes.keys
@@ -134,7 +136,7 @@ class Roda
 
         # Return the named route with the given name.
         def named_route(name, namespace=nil)
-          opts[:namespaced_routes][namespace][name]
+          namespaced_routes[namespace][name]
         end
 
         # If the given route has a name, treat it as a named route and
@@ -142,7 +144,7 @@ class Roda
         # call super.
         def route(name=nil, namespace=nil, &block)
           if name
-            routes = opts[:namespaced_routes][namespace] ||= {}
+            routes = namespaced_routes[namespace] ||= {}
             if block
               routes[name] = define_roda_method(routes[name] || "named_routes_#{namespace}_#{name}", 1, &convert_route_block(block))
             elsif meth = routes.delete(name)

data/lib/roda/plugins/named_templates.rb

@@ -61,15 +61,17 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :named_templates)
+
         # Freeze the named templates so that there can be no thread safety issues at runtime.
         def freeze
-          opts[:named_templates].freeze
+          named_templates.freeze
           super
         end
 
         # Store a new template block and options for the given template name.
         def template(name, options=nil, &block)
-          opts[:named_templates][name.to_s] = [options, define_roda_method("named_templates_#{name}", 0, &block)].freeze
+          named_templates[name.to_s] = [options, define_roda_method("named_templates_#{name}", 0, &block)].freeze
           nil
         end
       end
@@ -80,7 +82,7 @@ class Roda
         # If a template name is given and it matches a named template, call
         # the named template block to get the inline template to use.
         def find_template(options)
-          if options[:template] && (template_opts, meth = opts[:named_templates][template_name(options)]; meth)
+          if options[:template] && (template_opts, meth = self.class.named_templates[template_name(options)]; meth)
             if template_opts
               options = template_opts.merge(options)
             else

data/lib/roda/plugins/path.rb

@@ -80,11 +80,15 @@ class Roda
       # Regexp for valid constant names, to prevent code execution.
       VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
 
+      def self.load_dependencies(app, opts = OPTS)
+        app.plugin :_add_script_name
+      end
+
       # Initialize the path classes when loading the plugin. Options:
       # :by_name :: Register classes by name, which is friendlier when reloading code (defaults to
       #             true in development mode)
       def self.configure(app, opts=OPTS)
-        app.instance_eval do
+        app.instance_exec do
           self.opts[:path_class_by_name] = opts.fetch(:by_name, ENV['RACK_ENV'] == 'development')
           self.opts[:path_classes] ||= {}
           self.opts[:path_class_methods] ||= {}
@@ -95,15 +99,14 @@ class Roda
       end
 
       module ClassMethods
-        # Hash of recognizes classes for path instance method.  Keys are classes, values are procs.
-        def path_classes
-          opts[:path_classes]
-        end
+        RodaPlugins.opt_attr_reader(self, :path_classes)
+        RodaPlugins.opt_attr_reader(self, :path_class_by_name, name: :path_class_by_name?)
+        RodaPlugins.opt_attr_reader(self, :path_class_methods)
 
         # Freeze the path classes when freezing the app.
         def freeze
           path_classes.freeze
-          opts[:path_classes_methods].freeze
+          path_class_methods.freeze
           super
         end
 
@@ -113,7 +116,7 @@ class Roda
             raise RodaError, "can't provide path when calling path with a class" if path && !class_name
             raise RodaError, "can't provide options when calling path with a class" unless opts.empty?
             raise RodaError, "must provide a block when calling path with a class" unless block
-            if self.opts[:path_class_by_name]
+            if path_class_by_name?
               if class_name
                 name = name.to_s
               else
@@ -125,7 +128,7 @@ class Roda
               name = Object.class_eval(name, __FILE__, __LINE__)
             end
             path_classes[name] = block
-            self.opts[:path_class_methods][name] = define_roda_method("path_#{name}", :any, &block)
+            path_class_methods[name] = define_roda_method("path_#{name}", :any, &block)
             return
           end
 
@@ -147,7 +150,7 @@ class Roda
           url = opts[:url]
           url_only = opts[:url_only]
           relative = opts[:relative]
-          add_script_name = opts.fetch(:add_script_name, self.opts[:add_script_name])
+          add_script_name = opts.fetch(:add_script_name){add_script_name?}
 
           if relative
             if (url || url_only)
@@ -209,7 +212,7 @@ class Roda
         # Return the block related to the given class, or nil if there is no block.
         def path_block(klass)
           # RODA4: Remove
-          if opts[:path_class_by_name]
+          if path_class_by_name?
             klass = klass.name
           end
           path_classes[klass]
@@ -222,14 +225,13 @@ class Roda
         # :add_script_name option is true, this prepends the SCRIPT_NAME to the path.
         def path(obj, *args, &block)
           app = self.class
-          opts = app.opts
-          klass =  opts[:path_class_by_name] ? obj.class.name : obj.class
-          unless meth = opts[:path_class_methods][klass]
+          klass =  app.path_class_by_name? ? obj.class.name : obj.class
+          unless meth = app.path_class_methods[klass]
             raise RodaError, "unrecognized object given to Roda#path: #{obj.inspect}"
           end
 
           path = send(meth, obj, *args, &block)
-          path = request.script_name.to_s + path if opts[:add_script_name]
+          path = request.script_name.to_s + path if app.add_script_name?
           path
         end