roda 3.108.0 → 3.109.0

data/lib/roda/plugins/path_rewriter.rb

@@ -53,10 +53,13 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :remaining_path_rewrites)
+        RodaPlugins.opt_attr_reader(self, :path_info_rewrites)
+
         # Freeze the path rewrite metadata.
         def freeze
-          opts[:remaining_path_rewrites].freeze
-          opts[:path_info_rewrites].freeze
+          remaining_path_rewrites.freeze
+          path_info_rewrites.freeze
           super
         end
 
@@ -75,7 +78,7 @@ class Roda
           end
 
           was = /\A#{Regexp.escape(was)}/ unless was.is_a?(Regexp)
-          array = @opts[opts[:path_info] ? :path_info_rewrites : :remaining_path_rewrites]
+          array = opts[:path_info] ? path_info_rewrites : remaining_path_rewrites
           array << [was, is.dup.freeze].freeze
         end
       end
@@ -85,10 +88,10 @@ class Roda
         def initialize(scope, env)
           path_info = env['PATH_INFO']
 
-          rewrite_path(scope.class.opts[:path_info_rewrites], path_info)
+          rewrite_path(scope.class.path_info_rewrites, path_info)
           super
           remaining_path = @remaining_path = @remaining_path.dup
-          rewrite_path(scope.class.opts[:remaining_path_rewrites], remaining_path)
+          rewrite_path(scope.class.remaining_path_rewrites, remaining_path)
         end
 
         private

data/lib/roda/plugins/permissions_policy.rb

@@ -280,7 +280,7 @@ class Roda
 
       # Yield the current Permissions Policy to the block.
       def self.configure(app, opts=OPTS)
-        policy = app.opts[:permissions_policy] = if policy = app.opts[:permissions_policy]
+        policy = app.opts[:permissions_policy] = if policy = app.permissions_policy
           policy.dup
         else
           Policy.new
@@ -296,6 +296,10 @@ class Roda
         policy.freeze
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :permissions_policy)
+      end
+
       module InstanceMethods
         # If a block is given, yield the current permission policy.  Returns the
         # current permissions policy.
@@ -315,7 +319,7 @@ class Roda
 
         # The current permissions policy to be used for this response.
         def permissions_policy
-          @permissions_policy ||= roda_class.opts[:permissions_policy].dup
+          @permissions_policy ||= roda_class.permissions_policy.dup
         end
 
         # Do not set a permissions policy header for this response.
@@ -329,7 +333,7 @@ class Roda
         def set_default_headers
           super
           unless @skip_permissions_policy
-            (@permissions_policy || roda_class.opts[:permissions_policy]).set_header(headers)
+            (@permissions_policy || roda_class.permissions_policy).set_header(headers)
           end
         end
       end

data/lib/roda/plugins/public.rb

@@ -69,19 +69,15 @@ class Roda
       # :zstd :: Whether to serve already zstd-compressed files with a .zst extension
       #          for clients supporting "zstd" transfer encoding.
       def self.configure(app, opts={})
-        if opts[:root]
-          app.opts[:public_root] = app.expand_path(opts[:root])
-        elsif !app.opts[:public_root]
-          app.opts[:public_root] = app.expand_path("public")
-        end
-        app.opts[:public_server] = RACK_FILES.new(app.opts[:public_root], opts[:headers]||{}, opts[:default_mime] || 'text/plain')
+        app.opts[:public_root] = app.expand_path(opts[:root] || app.public_root || "public")
+        app.opts[:public_server] = RACK_FILES.new(app.public_root, opts[:headers]||{}, opts[:default_mime] || 'text/plain')
 
         unless encodings = opts[:encodings]
           if ENCODING_MAP.any?{|k,| opts.has_key?(k)}
             encodings = ENCODING_MAP.map{|k, v| [v, ENCODING_EXTENSIONS[v]] if opts[k]}.compact
           end
         end
-        encodings = (encodings || app.opts[:public_encodings] || EMPTY_ARRAY).map(&:dup).freeze
+        encodings = (encodings || app.public_encodings || EMPTY_ARRAY).map(&:dup).freeze
         encodings.each do |a|
           a << /\b#{a[0]}\b/
         end
@@ -89,10 +85,16 @@ class Roda
         app.opts[:public_encodings] = encodings
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :public_root)
+        RodaPlugins.opt_attr_reader(self, :public_server)
+        RodaPlugins.opt_attr_reader(self, :public_encodings)
+      end
+
       module RequestMethods
         # Serve files from the public directory if the file exists and this is a GET request.
         def public
-          public_serve_with(roda_class.opts[:public_server])
+          public_serve_with(roda_class.public_server)
         end
 
         private
@@ -124,11 +126,10 @@ class Roda
           path = PARSER.unescape(real_remaining_path)
           return if path.include?("\0")
 
-          roda_opts = roda_class.opts
           path = ::File.join(server.root, *public_path_segments(path))
 
           if accept_encoding = env['HTTP_ACCEPT_ENCODING']
-            roda_opts[:public_encodings].each do |enc, ext, regexp|
+            roda_class.public_encodings.each do |enc, ext, regexp|
               if regexp.send(MATCH_METHOD, accept_encoding)
                 public_serve_compressed(server, path, ext, enc)
               end

data/lib/roda/plugins/recheck_precompiled_assets.rb

@@ -57,7 +57,7 @@ class Roda
         precompiled_file = app.assets_opts[:precompiled]
         prev_mtime = ::File.mtime(precompiled_file)
         app.instance_exec do
-          opts[:assets] = opts[:assets].merge(:compiled=>_compiled_assets_initial_hash.replace(assets_opts[:compiled])).freeze
+          opts[:assets] = assets_opts.merge(:compiled=>_compiled_assets_initial_hash.replace(assets_opts[:compiled])).freeze
 
           define_singleton_method(:recheck_precompiled_assets) do
             new_mtime = ::File.mtime(precompiled_file)

data/lib/roda/plugins/redirect_http_to_https.rb

@@ -53,13 +53,16 @@ class Roda
       #                uses a hash that redirects GET and HEAD requests with a 301 status,
       #                and other request methods with a 307 status.
       def self.configure(app, opts=OPTS)
-        previous = app.opts[:redirect_http_to_https] || DEFAULTS
-        opts = app.opts[:redirect_http_to_https] = previous.merge(opts)
+        opts = app.opts[:redirect_http_to_https] = (app.redirect_http_to_https_opts || DEFAULTS).merge(opts)
         opts[:port_string] = opts[:port] ? ":#{opts[:port]}".freeze : "".freeze
         opts[:prefix] = opts[:host] ? "https://#{opts[:host]}#{opts[:port_string]}".freeze : nil
         opts.freeze
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :redirect_http_to_https, name: :redirect_http_to_https_opts)
+      end
+
       module RequestMethods
         # Redirect HTTP requests to HTTPS. While this doesn't secure the
         # current request, it makes it more likely that the browser will submit
@@ -67,7 +70,7 @@ class Roda
         def redirect_http_to_https
           return if ssl?
 
-          opts = roda_class.opts[:redirect_http_to_https]
+          opts = roda_class.redirect_http_to_https_opts
 
           res = response
 

data/lib/roda/plugins/render.rb

@@ -323,15 +323,15 @@ class Roda
 
       # Setup default rendering options.  See Render for details.
       def self.configure(app, opts=OPTS)
-        if app.opts[:render]
-          orig_cache = app.opts[:render][:cache]
-          orig_method_cache = app.opts[:render][:template_method_cache]
-          opts = app.opts[:render][:orig_opts].merge(opts)
+        if app.render_opts
+          orig_cache = app.render_opts[:cache]
+          orig_method_cache = app.render_opts[:template_method_cache]
+          opts = app.render_opts[:orig_opts].merge(opts)
         end
         app.opts[:render] = opts.dup
-        app.opts[:render][:orig_opts] = opts
+        app.render_opts[:orig_opts] = opts
 
-        opts = app.opts[:render]
+        opts = app.render_opts
         opts[:engine] = (opts[:engine] || "erb").dup.freeze
         opts[:views] = app.expand_path(opts[:views]||"views").freeze
         opts[:check_paths] = true unless opts.has_key?(:check_paths)
@@ -580,7 +580,7 @@ class Roda
         # affecting the parent class.
         def inherited(subclass)
           super
-          opts = subclass.opts[:render] = subclass.opts[:render].dup
+          opts = subclass.opts[:render] = subclass.render_opts.dup
           if COMPILED_METHOD_SUPPORT
             opts[:template_method_cache] = (opts[:cache_class] || RodaCache).new
           end
@@ -588,10 +588,7 @@ class Roda
           opts.freeze
         end
 
-        # Return the render options for this class.
-        def render_opts
-          opts[:render]
-        end
+        RodaPlugins.opt_attr_reader(self, :render, name: :render_opts)
 
         private
 
@@ -603,13 +600,13 @@ class Roda
             # in order for the precompile_templates plugin to work correctly.
             instance.send(:retrieve_template, instance.send(:view_layout_opts, OPTS))
 
-            if COMPILED_METHOD_SUPPORT && (layout_template = render_opts[:optimize_layout]) && !opts[:render][:optimized_layout_method_created]
+            if COMPILED_METHOD_SUPPORT && (layout_template = render_opts[:optimize_layout]) && !render_opts[:optimized_layout_method_created]
                 instance.send(:retrieve_template, :template=>layout_template, :cache_key=>nil, :template_method_cache_key => :_roda_layout)
-                layout_method = opts[:render][:template_method_cache][:_roda_layout]
+                layout_method = render_opts[:template_method_cache][:_roda_layout]
                 define_method(:_layout_method){layout_method}
                 private :_layout_method
                 alias_method(:_layout_method, :_layout_method)
-                opts[:render] = opts[:render].merge(:optimized_layout_method_created=>true)
+                opts[:render] = render_opts.merge(:optimized_layout_method_created=>true)
             end
           end
         end
@@ -650,7 +647,7 @@ class Roda
             # If we have an optimized template method but no optimized layout method, create the
             # optimized layout method if possible and use it.  If you can't create the optimized
             # layout method, fall through to the slower approach.
-            if layout_template = self.class.opts[:render][:optimize_layout]
+            if layout_template = self.class.render_opts[:optimize_layout]
               retrieve_template(:template=>layout_template, :cache_key=>nil, :template_method_cache_key => :_roda_layout)
               if layout_method = _layout_method
                 return _call_optimized_template_method(layout_method, OPTS){content}
@@ -695,7 +692,7 @@ class Roda
 
           # Return a symbol containing the optimized layout method
           def _layout_method
-            self.class.opts[:render][:template_method_cache][:_roda_layout]
+            self.class.render_opts[:template_method_cache][:_roda_layout]
           end
 
           # Use an optimized render path for templates with a hash of locals.  Returns the result
@@ -766,37 +763,25 @@ class Roda
           end
 
           if RUBY_VERSION >= '3'
-            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-              def _call_optimized_template_method((meth, fixed_locals), locals, &block)
-                if fixed_locals
-                  send(meth, **locals, &block)
-                else
-                  send(meth, locals, &block)
-                end
+            def _call_optimized_template_method((meth, fixed_locals), locals, &block)
+              if fixed_locals
+                send(meth, **locals, &block)
+              else
+                send(meth, locals, &block)
               end
-            RUBY
+            end
           # simplecov:disable
-          elsif RUBY_VERSION >= '2'
-            class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-              def _call_optimized_template_method((meth, fixed_locals), locals, &block)
-                if fixed_locals
-                  if locals.empty?
-                    send(meth, &block)
-                  else
-                    send(meth, **locals, &block)
-                  end
+          else
+            def _call_optimized_template_method((meth, fixed_locals), locals, &block)
+              if fixed_locals
+                if locals.empty?
+                  send(meth, &block)
                 else
-                  send(meth, locals, &block)
+                  send(meth, **locals, &block)
                 end
+              else
+                send(meth, locals, &block)
               end
-            RUBY
-          else
-            # Call the optimized template method.  This is designed to be used with the
-            # method cache, which caches the method name and whether the method uses
-            # fixed locals.  Methods with fixed locals need to be called with a keyword
-            # splat.
-            def _call_optimized_template_method((meth, fixed_locals), locals, &block)
-              send(meth, locals, &block)
             end
           end
           # simplecov:enable
@@ -844,7 +829,7 @@ class Roda
         # Given the template name and options, set the template class, template path/content,
         # template block, and locals to use for the render in the passed options.
         def find_template(opts)
-          render_opts = self.class.opts[:render]
+          render_opts = self.class.render_opts
           engine_override = opts[:engine]
           engine = opts[:engine] ||= render_opts[:engine]
           if content = opts[:inline]
@@ -908,7 +893,7 @@ class Roda
           end
           cached_template(opts) do
             opts = found_template_opts || find_template(opts)
-            render_opts = self.class.opts[:render]
+            render_opts = self.class.render_opts
             template_opts = render_opts[:template_opts]
             if engine_opts = render_opts[:engine_opts][opts[:engine]]
               template_opts = template_opts.merge(engine_opts)
@@ -993,14 +978,14 @@ class Roda
       end
 
       module AssumeFixedLocalsInstanceMethods
+        private
+
         # simplecov:disable
         if RUBY_VERSION >= '3.0'
         # simplecov:enable
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            def _call_optimized_template_method((meth,_), locals, &block)
-              send(meth, **locals, &block)
-            end
-          RUBY
+          def _call_optimized_template_method((meth,_), locals, &block)
+            send(meth, **locals, &block)
+          end
         end
       end
     end

data/lib/roda/plugins/render_coverage.rb

@@ -42,11 +42,14 @@ class Roda
       # strip.
       def self.configure(app, opts=OPTS)
         app.opts[:render_coverage_strip_paths] = opts[:strip_paths].map{|f| File.expand_path(f)} if opts.has_key?(:strip_paths)
-        coverage_dir = app.opts[:render_coverage_dir] = opts[:dir] || app.opts[:render_coverage_dir] || 'coverage/views'
+        coverage_dir = app.opts[:render_coverage_dir] = opts[:dir] || app.render_coverage_dir || 'coverage/views'
         Dir.mkdir(coverage_dir) unless File.directory?(coverage_dir)
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :render_coverage_strip_paths)
+        RodaPlugins.opt_attr_reader(self, :render_coverage_dir)
+
         # Set a compiled path on the created template, if the path for
         # the template is in one of the allowed_views.
         def create_template(opts, template_opts)
@@ -54,10 +57,10 @@ class Roda
 
           path = File.expand_path(opts[:path])
           compiled_path = nil
-          (self.opts[:render_coverage_strip_paths] || render_opts[:allowed_paths]).each do |dir|
+          (render_coverage_strip_paths || render_opts[:allowed_paths]).each do |dir|
             dir += "/" unless dir.end_with?("/")
             if path.start_with?(dir)
-              compiled_path = File.join(self.opts[:render_coverage_dir], path[dir.length, 10000000].tr('/', '-'))
+              compiled_path = File.join(render_coverage_dir, path[dir.length, 10000000].tr('/', '-'))
               break
             end
           end

data/lib/roda/plugins/render_locals.rb

@@ -32,14 +32,20 @@ class Roda
       end
 
       def self.configure(app, opts=OPTS)
-        app.opts[:render_locals] = (app.opts[:render_locals] || {}).merge(opts[:render]||{}).freeze
-        app.opts[:layout_locals] = (app.opts[:layout_locals] || {}).merge(opts[:layout]||{}).freeze
+        app.opts[:render_locals] = (app.render_locals || {}).merge(opts[:render]||{}).freeze
+        app.opts[:layout_locals] = (app.layout_locals || {}).merge(opts[:layout]||{}).freeze
         if opts.has_key?(:merge)
           app.opts[:merge_locals] = opts[:merge]
-          app.opts[:layout_locals] = app.opts[:render_locals].merge(app.opts[:layout_locals]).freeze
+          app.opts[:layout_locals] = app.render_locals.merge(app.layout_locals).freeze
         end
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :render_locals)
+        RodaPlugins.opt_attr_reader(self, :layout_locals)
+        RodaPlugins.opt_attr_reader(self, :merge_locals, name: :merge_locals?)
+      end
+
       module InstanceMethods
         private
 
@@ -56,11 +62,11 @@ class Roda
         end
 
         def render_locals
-          opts[:render_locals]
+          self.class.render_locals
         end
 
         def layout_locals
-          opts[:layout_locals]
+          self.class.layout_locals
         end
 
         # If this isn't the layout template, then use the plugin's render locals as the default locals.
@@ -79,7 +85,7 @@ class Roda
         # If using a layout, then use the plugin's layout locals as the default locals.
         def view_layout_opts(opts)
           if layout_opts = super
-            merge_locals = layout_opts.has_key?(:merge_locals) ? layout_opts[:merge_locals] : self.opts[:merge_locals] 
+            merge_locals = layout_opts.fetch(:merge_locals){self.class.merge_locals?}
 
             locals = {}
             locals.merge!(layout_locals)

data/lib/roda/plugins/request_aref.rb

@@ -20,7 +20,7 @@ class Roda
       def self.configure(app, setting)
         case setting
         when :allow, :raise, :warn
-          app::RodaRequest.class_eval do
+          app::RodaRequest.class_exec do
             alias_method(:[],  :"request_aref_#{setting}")
             alias_method(:[]=, :"request_aset_#{setting}")
             public :[], :[]=

data/lib/roda/plugins/response_content_type.rb

@@ -50,12 +50,16 @@ class Roda
           else
             mime_types.dup
           end
-          app.opts[:repsonse_content_types] = mime_types.freeze
+          app.opts[:response_content_types] = mime_types.freeze
         else
-          app.opts[:repsonse_content_types] ||= {}
+          app.opts[:response_content_types] ||= {}
         end
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :response_content_types)
+      end
+
       module ResponseMethods
         # Return the content-type of the response. Will be nil if it has
         # not yet been explicitly set.
@@ -68,7 +72,7 @@ class Roda
         # type with the given file extension. If the symbol is not
         # a recognized mime type, raises KeyError.
         def content_type=(mime_type)
-          mime_type = roda_class.opts[:repsonse_content_types].fetch(mime_type) if mime_type.is_a?(Symbol)
+          mime_type = roda_class.response_content_types.fetch(mime_type) if mime_type.is_a?(Symbol)
           @headers[RodaResponseHeaders::CONTENT_TYPE] = mime_type
         end
       end

data/lib/roda/plugins/route_csrf.rb

@@ -196,7 +196,7 @@ class Roda
       end
 
       def self.configure(app, opts=OPTS, &block)
-        options = app.opts[:route_csrf] = (app.opts[:route_csrf] || DEFAULTS).merge(opts)
+        options = app.opts[:route_csrf] = (app.route_csrf_opts || DEFAULTS).merge(opts)
         if block || opts[:csrf_failure].is_a?(Proc)
           if block && opts[:csrf_failure]
             raise RodaError, "Cannot specify both route_csrf plugin block and :csrf_failure option"
@@ -212,6 +212,10 @@ class Roda
         options.freeze
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :route_csrf, name: :route_csrf_opts)
+      end
+
       module InstanceMethods
         # Check that the submitted CSRF token is valid, if the request requires a CSRF token.
         # If the CSRF token is valid or the request does not require a CSRF token, return nil.
@@ -358,6 +362,7 @@ class Roda
           end
 
           if (rack_csrf_key = opts[:upgrade_from_rack_csrf_key]) && (rack_csrf_value = session[rack_csrf_key]) && csrf_compare(rack_csrf_value, encoded_token)
+            # RODA4: Remove :upgrade_from_rack_csrf_key support
             return
           end
 
@@ -392,7 +397,7 @@ class Roda
         
         # Helper for getting the plugin options.
         def csrf_options
-          opts[:route_csrf]
+          self.class.route_csrf_opts
         end
 
         # Perform a constant-time comparison of the two strings, returning true if they match and false otherwise.

data/lib/roda/plugins/run_append_slash.rb

@@ -31,6 +31,10 @@ class Roda
         app.opts[:run_append_slash_redirect] = !!opts[:use_redirects]
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :run_append_slash_redirect, name: :run_append_slash_redirect?)
+      end
+
       module RequestMethods
         # Calls the given rack app. If the path matches the root of the app but
         # does not contain a trailing slash, a trailing slash is appended to the
@@ -39,7 +43,7 @@ class Roda
         # the redirect approach will not be used.
         def run(*)
           if @remaining_path.empty?
-            if scope.opts[:run_append_slash_redirect] && !(path = self.path).start_with?('//')
+            if roda_class.run_append_slash_redirect? && !(path = self.path).start_with?('//')
               redirect("#{path}/")
             else
               @remaining_path += '/'

data/lib/roda/plugins/sec_fetch_site_csrf.rb

@@ -69,7 +69,7 @@ class Roda
       class CsrfFailure < RodaError; end
 
       def self.configure(app, opts=OPTS, &block)
-        options = app.opts[:sec_fetch_site_csrf] = (app.opts[:sec_fetch_site_csrf] || DEFAULTS).merge(opts)
+        options = app.opts[:sec_fetch_site_csrf] = (app.sec_fetch_site_csrf_opts || DEFAULTS).merge(opts)
 
         allowed_values = options[:allowed_values] = ["same-origin"]
         allowed_values << "same-site" if opts[:allow_same_site]
@@ -94,6 +94,10 @@ class Roda
         options.freeze
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :sec_fetch_site_csrf, name: :sec_fetch_site_csrf_opts)
+      end
+
       module InstanceMethods
         # Check that the Sec-Fetch-Site header is valid, if the request requires it.
         # If the header is valid or the request does not require the header, return nil.
@@ -101,7 +105,7 @@ class Roda
         # if a block is not given, use the plugin :csrf_failure option to determine how to
         # handle it.
         def check_sec_fetch_site!(&block)
-          plugin_opts = self.class.opts[:sec_fetch_site_csrf]
+          plugin_opts = self.class.sec_fetch_site_csrf_opts
           return unless plugin_opts[:check_request_methods].include?(request.request_method)
 
           sec_fetch_site = env["HTTP_SEC_FETCH_SITE"]

data/lib/roda/plugins/sessions.rb

@@ -10,7 +10,6 @@ rescue OpenSSL::Cipher::CipherError
   # simplecov:enable
 end
 
-require 'json'
 require 'securerandom'
 require 'zlib'
 require 'rack/utils'
@@ -175,15 +174,16 @@ class Roda
 
       def self.load_dependencies(app, opts=OPTS)
         app.plugin :_base64
+        app.plugin :_json
       end
 
       # Configure the plugin, see Sessions for details on options.
       def self.configure(app, opts=OPTS)
-        opts = (app.opts[:sessions] || DEFAULT_OPTIONS).merge(opts)
+        opts = (app.sessions_opts || DEFAULT_OPTIONS).merge(opts)
         co = opts[:cookie_options] = DEFAULT_COOKIE_OPTIONS.merge(opts[:cookie_options] || OPTS).freeze
         opts[:remove_cookie_options] = co.merge(:max_age=>'0', :expires=>Time.at(0))
-        opts[:parser] ||= app.opts[:json_parser] || JSON.method(:parse)
-        opts[:serializer] ||= app.opts[:json_serializer] || :to_json.to_proc
+        opts[:parser] ||= app.json_parser
+        opts[:serializer] ||= app.json_serializer
 
         opts[:per_cookie_cipher_secret] = true unless opts.has_key?(:per_cookie_cipher_secret)
         opts[:session_version_num] = opts[:per_cookie_cipher_secret] ? 1 : 0
@@ -216,6 +216,10 @@ class Roda
         app.opts[:sessions_convert_symbols] = true unless app.opts.has_key?(:sessions_convert_symbols)
       end
 
+      module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :sessions, name: :sessions_opts)
+      end
+
       module InstanceMethods
         # Clear data from the session, and update the request environment
         # so that the session cookie will use a new creation timestamp
@@ -233,7 +237,7 @@ class Roda
         # update the rack response headers to set the session cookie in
         # the response.
         def _roda_after_50__sessions(res)
-          if res && (session = env[self.class.opts[:sessions][:env_key]])
+          if res && (session = env[self.class.sessions_opts[:env_key]])
             @_request.persist_session(res[1], session)
           end
         end
@@ -247,7 +251,7 @@ class Roda
         # this method stores the session in 'rack.session' in the request environment,
         # but that does not happen until this method is called.
         def session
-          @env[roda_class.opts[:sessions][:env_key]] ||= _load_session
+          @env[roda_class.sessions_opts[:env_key]] ||= _load_session
         end
 
         # The time the session was originally created. nil if there is no active session.
@@ -266,7 +270,7 @@ class Roda
         # Rack::Session::Cookie, mark the related cookie for expiration so it isn't
         # sent in the future.
         def persist_session(headers, session)
-          opts = roda_class.opts[:sessions]
+          opts = roda_class.sessions_opts
 
           if session.empty?
             if env[SESSION_SERIALIZED]
@@ -317,7 +321,7 @@ class Roda
         # Load the session by looking for the appropriate cookie, or falling
         # back to the rack session cookie if configured.
         def _load_session
-          opts = roda_class.opts[:sessions]
+          opts = roda_class.sessions_opts
           cs = cookies
 
           if data = cs[opts[:key]]
@@ -340,7 +344,7 @@ class Roda
         # serialized session using the default Rack::Session::Cookie
         # hmac and coder.
         def _deserialize_rack_session(data)
-          opts = roda_class.opts[:sessions]
+          opts = roda_class.sessions_opts
           data, digest = data.split("--", 2)
           unless digest
             return _session_serialization_error("Not decoding Rack::Session::Cookie session: invalid format")
@@ -374,7 +378,7 @@ class Roda
 
         # Interpret given cookie data as a Rack::Session::Cookie
         def _deserialize_session(data)
-          opts = roda_class.opts[:sessions]
+          opts = roda_class.sessions_opts
 
           begin
             data = Base64_.urlsafe_decode64(data)
@@ -466,7 +470,7 @@ class Roda
         end
 
         def _serialize_session(session)
-          opts = roda_class.opts[:sessions]
+          opts = roda_class.sessions_opts
           env = @env
           now = Time.now.to_i
           json_data = opts[:serializer].call(session).force_encoding('BINARY')

data/lib/roda/plugins/shape_friendly.rb

@@ -74,6 +74,8 @@ class Roda
       end
 
       module ClassMethods
+        RodaPlugins.opt_attr_reader(self, :shape_friendly_scope_instance_variables)
+
         # Automatically refresh the instance variables used if the plugin
         # sets instance variables.
         def plugin(plugin, *args, &block)
@@ -107,7 +109,7 @@ class Roda
             ivs.concat(mod.const_get(const)) if mod.const_defined?(const)
           end
 
-          if const == :SCOPE_INSTANCE_VARIABLES && (scope_ivs = opts[:shape_friendly_scope_instance_variables])
+          if const == :SCOPE_INSTANCE_VARIABLES && (scope_ivs = shape_friendly_scope_instance_variables)
             ivs.concat(scope_ivs)
           end