roda 3.107.0 → 3.109.0

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)
@@ -169,17 +172,17 @@ class Roda
                 # Allow calling private _method to get path
                 relative_path(request.script_name.to_s + send(_meth, *a, &blk))
               end
-              # :nocov:
+              # simplecov:disable
               ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
-              # :nocov:
+              # simplecov:enable
             elsif add_script_name
               define_method(meth) do |*a, &blk|
                 # Allow calling private _method to get path
                 request.script_name.to_s + send(_meth, *a, &blk)
               end
-              # :nocov:
+              # simplecov:disable
               ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
-              # :nocov:
+              # simplecov:enable
             else
               define_method(meth, &block)
             end
@@ -198,9 +201,9 @@ class Roda
             end
 
             define_method(url_meth, &url_block)
-            # :nocov:
+            # simplecov:disable
             ruby2_keywords(url_meth) if respond_to?(:ruby2_keywords, true)
-            # :nocov:
+            # simplecov:enable
           end
 
           nil
@@ -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
 

data/lib/roda/plugins/path_matchers.rb

@@ -29,12 +29,16 @@ class Roda
     #     # Matches '/foo.bar', yielding 'foo'
     #     # Does not match bar.foo
     #   end
+    #
+    # Note that all of these matchers treat a given string as regexp source,
+    # so if you are including regexp metacharacters but want a literal string
+    # match, use +Regexp.escape+.
     module PathMatchers
       module RequestMethods
         # Match when the current segment ends with the given extension.
         # request path end with the extension.
         def match_extension(ext)
-          match_suffix(".#{ext}")
+          match_suffix("\\.#{ext}")
         end
 
         # Match when the current path segment starts with the given prefix.

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

@@ -46,10 +46,10 @@ class Roda
       ENCODING_MAP = {:zstd=>'zstd', :brotli=>'br', :gzip=>'gzip'}.freeze
       ENCODING_EXTENSIONS = {'br'=>'.br', 'gzip'=>'.gz', 'zstd'=>'.zst'}.freeze
 
-      # :nocov:
+      # simplecov:disable
       PARSER = defined?(::URI::RFC2396_PARSER) ? ::URI::RFC2396_PARSER : ::URI::DEFAULT_PARSER
       MATCH_METHOD = RUBY_VERSION >= '2.4' ? :match? : :match
-      # :nocov:
+      # simplecov:enable
 
       # Use options given to setup a Rack::File instance for serving files. Options:
       # :brotli :: Whether to serve already brotli-compressed files with a .br extension
@@ -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
@@ -114,9 +116,9 @@ class Roda
         def public_file_readable?(path)
           ::File.file?(path) && ::File.readable?(path)
         rescue SystemCallError
-          # :nocov:
+          # simplecov:disable
           false
-          # :nocov:
+          # simplecov:enable
         end
 
         def public_serve_with(server)
@@ -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

@@ -46,8 +46,11 @@ class Roda
     #
     # The following plugin options are supported:
     #
-    # :allowed_paths :: Set the template paths to allow.  Attempts to render paths outside
-    #                   of these paths will raise an error.  Defaults to the +:views+ directory.
+    # :allowed_paths :: Set the template directories to allow.  Attempts to render paths outside
+    #                   of these directories will raise an error.  Defaults to the +:views+ option,
+    #                   if it is a directory.  For backwards compatibility, if a non-directory is
+    #                   given, it will be used as a prefix match. Roda 4 will raise if a non-directory
+    #                   is given as an allowed path and +:check_paths+ is true.
     # :assume_fixed_locals :: Set if you are sure all templates in your application use fixed locals
     #                         to allow for additional optimization. This is ignored unless both
     #                         compiled methods and fixed locals are not supported.
@@ -298,42 +301,51 @@ class Roda
         def self.tilt_template_fixed_locals?(template)
           template.fixed_locals?
         end
-      # :nocov:
+      # simplecov:disable
       else
         def self.tilt_template_fixed_locals?(template)
           false
         end
       end
-      # :nocov:
+      # simplecov:enable
 
       if compiled_method_arity == -2
         def self.tilt_template_compiled_method(template, locals_keys, scope_class)
           template.send(:compiled_method, locals_keys, scope_class)
         end
-      # :nocov:
+      # simplecov:disable
       else
         def self.tilt_template_compiled_method(template, locals_keys, scope_class)
           template.send(:compiled_method, locals_keys)
         end
-      # :nocov:
+      # simplecov:enable
       end
 
       # 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[:allowed_paths] ||= [opts[:views]].freeze
-        opts[:allowed_paths] = opts[:allowed_paths].map{|f| app.expand_path(f, nil)}.uniq.freeze
         opts[:check_paths] = true unless opts.has_key?(:check_paths)
+        opts[:allowed_paths] ||= [opts[:views]]
+        opts[:allowed_paths] = opts[:allowed_paths].map do |f|
+          path = app.expand_path(f, nil)
+          if File.directory?(path) || f == opts[:views]
+            path << "/"
+          elsif opts[:check_paths]
+            # RODA4: raise
+            RodaPlugins.warn("allowed path #{f.inspect} is not a directory in the file system. For backwards compatibility, will allow prefix matches, but this could result in security issues. Roda 4 will raise if an allowed path is not a directory.")
+          end
+          path.freeze
+        end.uniq.freeze
         opts[:assume_fixed_locals] &&= FIXED_LOCALS_COMPILED_METHOD_SUPPORT
 
         unless opts.has_key?(:check_template_mtime)
@@ -568,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
@@ -576,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
 
@@ -591,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
@@ -638,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}
@@ -683,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
@@ -754,40 +763,28 @@ 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
-          # :nocov:
-          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
+            end
+          # simplecov:disable
+          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
-          # :nocov:
+          # simplecov:enable
         else
           def _cached_template_method(_)
             nil
@@ -832,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]
@@ -896,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)
@@ -981,14 +978,14 @@ class Roda
       end
 
       module AssumeFixedLocalsInstanceMethods
-        # :nocov:
+        private
+
+        # simplecov:disable
         if RUBY_VERSION >= '3.0'
-        # :nocov:
-          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            def _call_optimized_template_method((meth,_), locals, &block)
-              send(meth, **locals, &block)
-            end
-          RUBY
+        # simplecov:enable
+          def _call_optimized_template_method((meth,_), locals, &block)
+            send(meth, **locals, &block)
+          end
         end
       end
     end

data/lib/roda/plugins/render_coverage.rb

@@ -1,9 +1,9 @@
 # frozen-string-literal: true
 
 require 'tilt'
-# :nocov:
+# simplecov:disable
 raise 'Tilt version does not support coverable templates' unless Tilt::Template.method_defined?(:compiled_path=)
-# :nocov:
+# simplecov:enable
 
 #
 class Roda
@@ -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,9 +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|
-            if path.start_with?(dir + '/')
-              compiled_path = File.join(self.opts[:render_coverage_dir], path[dir.length+1, 10000000].tr('/', '-'))
+          (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(render_coverage_dir, path[dir.length, 10000000].tr('/', '-'))
               break
             end
           end
@@ -76,9 +80,9 @@ class Roda
           template = super
 
           # Set compiled path for template when using older tilt versions.
-          # :nocov:
+          # simplecov:disable
           template.compiled_path = compiled_path if compiled_path
-          # :nocov:
+          # simplecov:enable
 
           template
         end

data/lib/roda/plugins/render_each.rb

@@ -171,12 +171,12 @@ class Roda
 
             File.basename(template).sub(/\..+\z/, '').to_sym
           end
-        # :nocov:
+        # simplecov:disable
         else
           def render_each_default_local(template)
             File.basename(template.to_s).sub(/\..+\z/, '').to_sym
           end
-        # :nocov:
+        # simplecov:enable
         end
 
         if Render::COMPILED_METHOD_SUPPORT