roda 3.22.0 → 3.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c75151c856c93ac28e9089018a1d04f40f479782cc4d2e96099d4182d993d81a
-  data.tar.gz: 3190821d03128b656e573f8dc748fafcd753b55bfabd4d53c1c6c219ed0a340a
+  metadata.gz: 2229b19a7b47a63c8f953c9a225f094d9b6c1120893629e30fea16fe189c8462
+  data.tar.gz: 341a5222c9bdf0cdc1aa56b654dd1accdce94257a5f9a756c8a8d37cf5bd5af8
 SHA512:
-  metadata.gz: cbf0bdcd577b6766483121f654b3e5139de674b81539fda0a43d949bb73d0092d7e280b1efd772409917a0f53a6fb877897126687060b4c6a14c8c9f5d152e75
-  data.tar.gz: 33fa800abbe118922d05db9712bc35910e7d633fbe4f224083c79f4289e8a269dcca90f31b2ac07aa0bece05c3957e5afa3f08bf14bea005a1b93242bcb317c5
+  metadata.gz: c996fa5a43603f429fb061c84585a84dbe97719032893f3ae1fff22dcd8056fb1c71fb8fa103ea46fca1a50cbaf6156139e9b1ee03ac1151e7a33d576d08b724
+  data.tar.gz: 8eff9c58e5dc39d40e18445bb33a4dcba019034975c110382a9f143021ddaf6920b8e783cc031be07f431a295e2b973ed750cf9f71e064c0796822e51faa6145

data/CHANGELOG

@@ -1,3 +1,13 @@
+= 3.23.0 (2019-08-13)
+
+* Make roda/session_middleware work if type_routing plugin is loaded into Roda itself (jeremyevans) (#169)
+
+* Handle requests with nothing before extension in the path in the type_routing plugin (jeremyevans) (#168)
+
+* Always show line number in exception_page output in exception_page plugin (jeremyevans)
+
+* Improve render/view performance up to 2x in development mode in the default case by calling compiled template methods directly (jeremyevans)
+
 = 3.22.0 (2019-07-12)
 
 * Improve render performance up to 4x in the default case by calling compiled template methods directly (jeremyevans)

data/doc/release_notes/3.23.0.txt

@@ -0,0 +1,28 @@
+= Improvements
+
+* The render/view methods in the render plugin, when called with
+  a single string/symbol argument (the most common case), are now
+  up to 2x faster in cache: false mode by directly calling compiled
+  template methods.  This takes the performance increase in 3.22.0
+  and applies it to cache: false mode in addition to cache: true
+  mode.  If the template file has changed, the compiled method is
+  removed, and a new compiled method replaces it.
+
+* Template modification detection in the render plugin now uses a
+  faster check for modification, which also avoids a race condition.
+
+* The type_routing plugin now handles requests with nothing but the
+  extension in the request path.  This fixes cases when you have
+  one app partially route a request, and send the request to another
+  app, and that app uses the type_routing plugin and has an r.is
+  call at the root level.
+
+* The roda/session_middleware middleware now works correctly if the
+  type_routing plugin is loaded into Roda itself (as opposed to a
+  Roda subclass).
+
+* The exception_page plugin now always shows the line number for
+  each line.  Previously, it only showed the line number if it was
+  showing the content of the line, which complicated debugging in
+  cases where the content of the line was no longer retrievable
+  due to file system permissions or restrictions (e.g. chroot).

data/lib/roda.rb

@@ -340,9 +340,12 @@ class Roda
         end
 
         # Load a new plugin into the current class.  A plugin can be a module
-        # which is used directly, or a symbol represented a registered plugin
+        # which is used directly, or a symbol representing a registered plugin
         # which will be required and then used. Returns nil.
         #
+        # Note that you should not load plugins into a Roda class after the
+        # class has been subclassed, as doing so can break the subclasses.
+        #
         #   Roda.plugin PluginModule
         #   Roda.plugin :csrf
         def plugin(plugin, *args, &block)

data/lib/roda/plugins/exception_page.rb

@@ -330,7 +330,7 @@ END
   <ul class="traceback">
 #{frames.map{|frame| id = frame[:id]; (<<END1)}.join
       <li class="frame">
-        <code>#{h frame[:filename]}</code>: in <code>#{h frame[:function]}</code>
+        <code>#{h frame[:filename]}:#{frame[:lineno]}</code> in <code>#{h frame[:function]}</code>
 
           #{frame[:context_line] ? (<<END2) : '</li>'
           <div class="context" id="c#{id}">

data/lib/roda/plugins/render.rb

@@ -161,20 +161,14 @@ class Roda
           end
         end
 
-        if opts[:check_template_mtime]
-          opts.delete(:template_method_cache)
-        elsif COMPILED_METHOD_SUPPORT
-          opts[:template_method_cache] = orig_method_cache || (opts[:cache_class] || RodaCache).new
-          begin
-            app.const_get(:RodaCompiledTemplates, false)
-          rescue NameError
-            compiled_templates_module = Module.new
-            app.send(:include, compiled_templates_module)
-            app.const_set(:RodaCompiledTemplates, compiled_templates_module)
-          end
-          opts[:template_method_cache] = orig_method_cache || (opts[:cache_class] || RodaCache).new
+        begin
+          app.const_get(:RodaCompiledTemplates, false)
+        rescue NameError
+          compiled_templates_module = Module.new
+          app.send(:include, compiled_templates_module)
+          app.const_set(:RodaCompiledTemplates, compiled_templates_module)
         end
-
+        opts[:template_method_cache] = orig_method_cache || (opts[:cache_class] || RodaCache).new
         opts[:cache] = orig_cache || (opts[:cache_class] || RodaCache).new
 
         opts[:layout_opts] = (opts[:layout_opts] || {}).dup
@@ -244,15 +238,68 @@ class Roda
         # If the template file exists and the modification time has
         # changed, rebuild the template file, then call render on it.
         def render(*args, &block)
-          if File.file?(path = @path)
-            mtime = File.mtime(path)
+          modified?
+          @template.render(*args, &block)
+        end
+
+        # If the template file has been updated, return true and update
+        # the template object and the modification time. Other return false.
+        def modified?
+          begin
+            mtime = File.mtime(path = @path)
+          rescue
+            # ignore errors
+          else
             if mtime != @mtime
               @mtime = mtime
               @template = @template_class.new(path, *@template_args)
+              return true
             end
           end
 
-          @template.render(*args, &block)
+          false
+        end
+
+        if COMPILED_METHOD_SUPPORT
+          # Compile a method in the given module with the given name that will
+          # call the compiled template method, updating the compiled template method
+          def define_compiled_method(roda_class, method_name)
+            mod = roda_class::RodaCompiledTemplates
+            internal_method_name = :"_#{method_name}"
+            begin
+              mod.send(:define_method, internal_method_name, send(:compiled_method, OPTS))
+            rescue ::NotImplementedError
+              return false
+            end
+
+            mod.send(:private, internal_method_name)
+            mod.send(:define_method, method_name, &compiled_method_lambda(self, roda_class, internal_method_name))
+            mod.send(:private, method_name)
+
+            method_name
+          end
+
+          private
+
+          # Return the compiled method for the current template object.
+          def compiled_method(_)
+            @template.send(:compiled_method, OPTS)
+          end
+
+          # Return the lambda used to define the compiled template method.  This
+          # is separated into its own method so the lambda does not capture any
+          # unnecessary local variables
+          def compiled_method_lambda(template, roda_class, method_name)
+            mod = roda_class::RodaCompiledTemplates
+            lambda do |_, &block|
+              if template.modified?
+                mod.send(:define_method, method_name, template.send(:compiled_method, OPTS))
+                mod.send(:private, method_name)
+              end
+
+              send(method_name, OPTS, &block)
+            end
+          end
         end
       end
 
@@ -459,18 +506,23 @@ class Roda
               template_opts = template_opts.merge(current_template_opts)
             end
 
+            define_compiled_method = COMPILED_METHOD_SUPPORT &&
+               (method_cache_key = opts[:template_method_cache_key]) &&
+               (method_cache = render_opts[:template_method_cache]) &&
+               (method_cache[method_cache_key] != false) &&
+               !opts[:inline]
+
             if render_opts[:check_template_mtime] && !opts[:template_block] && !cache
-              TemplateMtimeWrapper.new(opts[:template_class], opts[:path], 1, template_opts)
+              template = TemplateMtimeWrapper.new(opts[:template_class], opts[:path], 1, template_opts)
+
+              if define_compiled_method
+                method_name = :"_roda_template_#{self.class.object_id}_#{method_cache_key}"
+                method_cache[method_cache_key] = template.define_compiled_method(self.class, method_name)
+              end
             else
               template = opts[:template_class].new(opts[:path], 1, template_opts, &opts[:template_block])
 
-              if COMPILED_METHOD_SUPPORT &&
-                 (method_cache_key = opts[:template_method_cache_key]) &&
-                 (method_cache = render_opts[:template_method_cache]) &&
-                 (method_cache[method_cache_key] != false) &&
-                 !opts[:inline] &&
-                 cache != false
-
+              if define_compiled_method && cache != false
                 begin
                   unbound_method = template.send(:compiled_method, OPTS)
                 rescue ::NotImplementedError
@@ -482,9 +534,9 @@ class Roda
                   method_cache[method_cache_key] = method_name
                 end
               end
-
-              template
             end
+
+            template
           end
         end
 

data/lib/roda/plugins/type_routing.rb

@@ -131,7 +131,7 @@ class Roda
         mimes.freeze
 
         type_keys = config[:types].keys
-        config[:extension_regexp] = /(.+?)\.(#{Regexp.union(type_keys.map(&:to_s))})\z/
+        config[:extension_regexp] = /(.*?)\.(#{Regexp.union(type_keys.map(&:to_s))})\z/
 
         type_keys.each do |type|
           app::RodaRequest.send(:define_method, type) do |&block|

data/lib/roda/session_middleware.rb

@@ -150,11 +150,18 @@ class RodaSessionMiddleware
     end
   end
 
+  module RequestMethods
+    # Work around for if type_routing plugin is loaded into Roda class itself.
+    def _remaining_path(_)
+    end
+  end
+
   # Setup the middleware, passing +opts+ as the Roda sessions plugin options.
   def initialize(app, opts)
     mid = Class.new(Roda)
     mid.plugin :sessions, opts
     @req_class = mid::RodaRequest
+    @req_class.send(:include, RequestMethods)
     @app = app
   end
 

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 = 22
+  RodaMinorVersion = 23
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

data/spec/plugin/exception_page_spec.rb

@@ -139,6 +139,17 @@ describe "exception_page plugin" do
     body.wont_include 'id="c0"'
   end
 
+  it "should still show line numbers if the line content cannot be displayed" do
+    app(:exception_page) do |r|
+      instance_eval('raise "foo"', 'foo-bar.rb', 4200+42) rescue exception_page($!)
+    end
+    body = body('HTTP_ACCEPT'=>'text/html')
+    body.must_include "RuntimeError: foo"
+    body.must_include "foo-bar.rb:#{4200+42}"
+    body.must_include __FILE__
+    body.wont_include 'id="c0"'
+  end
+
   it "should serve exception page assets" do
     app(:exception_page) do |r|
       r.exception_page_assets

data/spec/plugin/render_spec.rb

@@ -261,157 +261,160 @@ describe "render plugin" do
   end
 
   if Roda::RodaPlugins::Render::COMPILED_METHOD_SUPPORT
-    it "does not cache template renders when using a template library that doesn't support it" do
-      begin
-        require 'tilt/rdoc'
-      rescue
-        next
-      end
-
-      app(:bare) do
-        plugin :render, :views=>'spec/views', :engine=>'rdoc'
-        route do
-          render('a')
+    [true, false].each do |cache_plugin_option|
+      multiplier = cache_plugin_option ? 1 : 2
+      it "does not cache template renders when using a template library that doesn't support it with plugin option :cache=>#{cache_plugin_option}" do
+        begin
+          require 'tilt/rdoc'
+        rescue
+          next
         end
-      end
 
-      app.render_opts[:template_method_cache]['a'].must_be_nil
-      body.strip.must_equal "<p># a # * b</p>"
-      app.render_opts[:template_method_cache]['a'].must_equal false
-      body.strip.must_equal "<p># a # * b</p>"
-      app.render_opts[:template_method_cache]['a'].must_equal false
-      body.strip.must_equal "<p># a # * b</p>"
-      app.render_opts[:template_method_cache]['a'].must_equal false
-      app::RodaCompiledTemplates.private_instance_methods.length.must_equal 0
-    end
-
-    ['comp_test', :comp_test].each do |template|
-      it "does not cache template renders when given a hash" do
         app(:bare) do
-          plugin :render, :views=>'spec/views'
+          plugin :render, :views=>'spec/views', :engine=>'rdoc', :cache=>cache_plugin_option
           route do
-            render(:template=>template)
+            render('a')
           end
         end
 
-        app.render_opts[:template_method_cache][template].must_be_nil
-        body.strip.must_equal "ct"
-        app.render_opts[:template_method_cache][template].must_be_nil
-        body.strip.must_equal "ct"
-        app.render_opts[:template_method_cache][template].must_be_nil
-        body.strip.must_equal "ct"
-        app.render_opts[:template_method_cache][template].must_be_nil
+        app.render_opts[:template_method_cache]['a'].must_be_nil
+        body.strip.must_equal "<p># a # * b</p>"
+        app.render_opts[:template_method_cache]['a'].must_equal false
+        body.strip.must_equal "<p># a # * b</p>"
+        app.render_opts[:template_method_cache]['a'].must_equal false
+        body.strip.must_equal "<p># a # * b</p>"
+        app.render_opts[:template_method_cache]['a'].must_equal false
         app::RodaCompiledTemplates.private_instance_methods.length.must_equal 0
       end
 
-      it "caches template renders when given a #{template.class}" do
-        app(:bare) do
-          plugin :render, :views=>'spec/views'
-          route do
-            render(template)
+      ['comp_test', :comp_test].each do |template|
+        it "does not cache template renders when given a hash with #{template.class} value with plugin option :cache=>#{cache_plugin_option}" do
+          app(:bare) do
+            plugin :render, :views=>'spec/views', :cache=>cache_plugin_option
+            route do
+              render(:template=>template)
+            end
           end
-        end
 
-        app.render_opts[:template_method_cache][template].must_be_nil
-        body.strip.must_equal "ct"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        body.strip.must_equal "ct"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        body.strip.must_equal "ct"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        app::RodaCompiledTemplates.private_instance_methods.length.must_equal 1
-      end
+          app.render_opts[:template_method_cache][template].must_be_nil
+          body.strip.must_equal "ct"
+          app.render_opts[:template_method_cache][template].must_be_nil
+          body.strip.must_equal "ct"
+          app.render_opts[:template_method_cache][template].must_be_nil
+          body.strip.must_equal "ct"
+          app.render_opts[:template_method_cache][template].must_be_nil
+          app::RodaCompiledTemplates.private_instance_methods.length.must_equal 0
+        end
 
-      it "does not cache template views or layout when given a hash" do
-        app(:bare) do
-          layout = template.to_s.sub('test', 'layout')
-          layout = layout.to_sym if template.is_a?(Symbol)
-          plugin :render, :views=>'spec/views', :layout=>layout
-          route do
-            view(:template=>template)
+        it "caches template renders when given a #{template.class} with plugin option :cache=>#{cache_plugin_option}" do
+          app(:bare) do
+            plugin :render, :views=>'spec/views', :cache=>cache_plugin_option
+            route do
+              render(template)
+            end
           end
-        end
 
-        app.render_opts[:template_method_cache][template].must_be_nil
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        body.strip.must_equal "act\nb"
-        app.render_opts[:template_method_cache][template].must_be_nil
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        body.strip.must_equal "act\nb"
-        app.render_opts[:template_method_cache][template].must_be_nil
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        body.strip.must_equal "act\nb"
-        app.render_opts[:template_method_cache][template].must_be_nil
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        app::RodaCompiledTemplates.private_instance_methods.length.must_equal 0
-      end
+          app.render_opts[:template_method_cache][template].must_be_nil
+          body.strip.must_equal "ct"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          body.strip.must_equal "ct"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          body.strip.must_equal "ct"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          app::RodaCompiledTemplates.private_instance_methods.length.must_equal multiplier
+        end
 
-      it "caches template views with layout when given a #{template.class}" do
-        app(:bare) do
-          layout = template.to_s.sub('test', 'layout')
-          layout = layout.to_sym if template.is_a?(Symbol)
-          plugin :render, :views=>'spec/views', :layout=>layout
-          route do
-            view(template)
+        it "does not cache template views or layout when given a hash with #{template.class} value with plugin option :cache=>#{cache_plugin_option}" do
+          app(:bare) do
+            layout = template.to_s.sub('test', 'layout')
+            layout = layout.to_sym if template.is_a?(Symbol)
+            plugin :render, :views=>'spec/views', :layout=>layout, :cache=>cache_plugin_option
+            route do
+              view(:template=>template)
+            end
           end
+
+          app.render_opts[:template_method_cache][template].must_be_nil
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          body.strip.must_equal "act\nb"
+          app.render_opts[:template_method_cache][template].must_be_nil
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          body.strip.must_equal "act\nb"
+          app.render_opts[:template_method_cache][template].must_be_nil
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          body.strip.must_equal "act\nb"
+          app.render_opts[:template_method_cache][template].must_be_nil
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          app::RodaCompiledTemplates.private_instance_methods.length.must_equal 0
         end
 
-        app.render_opts[:template_method_cache][template].must_be_nil
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        body.strip.must_equal "act\nb"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        body.strip.must_equal "act\nb"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_kind_of(Symbol)
-        body.strip.must_equal "act\nb"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_kind_of(Symbol)
-        app::RodaCompiledTemplates.private_instance_methods.length.must_equal 2
-      end
-
-      it "caches template views without layout when additional layout options given when given a #{template.class}" do
-        app(:bare) do
-          plugin :render, :views=>'spec/views', :layout=>nil
-          route do
-            view(template)
+        it "caches template views with layout when given a #{template.class} with plugin option :cache=>#{cache_plugin_option}" do
+          app(:bare) do
+            layout = template.to_s.sub('test', 'layout')
+            layout = layout.to_sym if template.is_a?(Symbol)
+            plugin :render, :views=>'spec/views', :layout=>layout, :cache=>cache_plugin_option
+            route do
+              view(template)
+            end
           end
+
+          app.render_opts[:template_method_cache][template].must_be_nil
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          body.strip.must_equal "act\nb"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          body.strip.must_equal "act\nb"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_kind_of(Symbol)
+          body.strip.must_equal "act\nb"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_kind_of(Symbol)
+          app::RodaCompiledTemplates.private_instance_methods.length.must_equal(2*multiplier)
         end
 
-        app.render_opts[:template_method_cache][template].must_be_nil
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        body.strip.must_equal "ct"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        body.strip.must_equal "ct"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        body.strip.must_equal "ct"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        app::RodaCompiledTemplates.private_instance_methods.length.must_equal 1
-      end
-
-      it "caches template views without layout when additional layout options given when given a #{template.class}" do
-        app(:bare) do
-          plugin :render, :views=>'spec/views', :layout_opts=>{:locals=>{:title=>"Home"}}
-          route do
-            view(template)
+        it "caches template views without layout when additional layout options given when given a #{template.class} with plugin option :cache=>#{cache_plugin_option}" do
+          app(:bare) do
+            plugin :render, :views=>'spec/views', :layout=>nil, :cache=>cache_plugin_option
+            route do
+              view(template)
+            end
           end
+
+          app.render_opts[:template_method_cache][template].must_be_nil
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          body.strip.must_equal "ct"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          body.strip.must_equal "ct"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          body.strip.must_equal "ct"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          app::RodaCompiledTemplates.private_instance_methods.length.must_equal multiplier
         end
 
-        app.render_opts[:template_method_cache][template].must_be_nil
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        body.strip.must_equal "<title>Roda: Home</title>\nct"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        body.strip.must_equal "<title>Roda: Home</title>\nct"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        body.strip.must_equal "<title>Roda: Home</title>\nct"
-        app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
-        app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
-        app::RodaCompiledTemplates.private_instance_methods.length.must_equal 1
+        it "caches template views without layout when additional layout options given when given a #{template.class} with plugin option :cache=>#{cache_plugin_option}" do
+          app(:bare) do
+            plugin :render, :views=>'spec/views', :layout_opts=>{:locals=>{:title=>"Home"}}, :cache=>cache_plugin_option
+            route do
+              view(template)
+            end
+          end
+
+          app.render_opts[:template_method_cache][template].must_be_nil
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          body.strip.must_equal "<title>Roda: Home</title>\nct"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          body.strip.must_equal "<title>Roda: Home</title>\nct"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          body.strip.must_equal "<title>Roda: Home</title>\nct"
+          app.render_opts[:template_method_cache][template].must_be_kind_of(Symbol)
+          app.render_opts[:template_method_cache][:_roda_layout].must_be_nil
+          app::RodaCompiledTemplates.private_instance_methods.length.must_equal multiplier
+        end
       end
     end
   end

data/spec/plugin/type_routing_spec.rb

@@ -63,6 +63,38 @@ describe "type_routing plugin" do
     body('/a.html', 'HTTP_ACCEPT' => 'application/xml').must_equal 'HTML: html'
   end
 
+  it "works correctly in sub apps when sub app also handles extensions on empty paths" do
+    sup_app = app
+    @app = Class.new(sup_app)
+    sup_app.route do |r|
+      r.is do
+        r.get do
+          r.html { 'a' }
+          r.json { '{b:1}' }
+        end
+      end
+
+      r.on 'test' do
+        r.get do
+          r.html { 'c' }
+          r.json { '{d:2}' }
+        end
+      end
+    end
+    app.route do |r|
+      r.on "subpath" do
+        r.run(sup_app)
+      end
+    end
+
+    body('/subpath').must_equal 'a'
+    body('/subpath.html').must_equal 'a'
+    body('/subpath.json').must_equal '{b:1}'
+    body('/subpath/test').must_equal 'c'
+    body('/subpath/test.html').must_equal 'c'
+    body('/subpath/test.json').must_equal '{d:2}'
+  end
+
   it "uses the default if neither file extension nor Accept header are given" do
     body('/a').must_equal 'HTML: html'
     header('Content-Type', '/a').must_equal 'text/html'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.22.0
+  version: 3.23.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-12 00:00:00.000000000 Z
+date: 2019-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -219,6 +219,7 @@ extra_rdoc_files:
 - doc/release_notes/3.20.0.txt
 - doc/release_notes/3.21.0.txt
 - doc/release_notes/3.22.0.txt
+- doc/release_notes/3.23.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -277,6 +278,7 @@ files:
 - doc/release_notes/3.20.0.txt
 - doc/release_notes/3.21.0.txt
 - doc/release_notes/3.22.0.txt
+- doc/release_notes/3.23.0.txt
 - doc/release_notes/3.3.0.txt
 - doc/release_notes/3.4.0.txt
 - doc/release_notes/3.5.0.txt