roda 3.23.0 → 3.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2229b19a7b47a63c8f953c9a225f094d9b6c1120893629e30fea16fe189c8462
-  data.tar.gz: 341a5222c9bdf0cdc1aa56b654dd1accdce94257a5f9a756c8a8d37cf5bd5af8
+  metadata.gz: bc61123e82d5731f6459164ff0e6305115008d22f59607b471021f6d5586646d
+  data.tar.gz: 3bce436fb87890ef4d593ea97792044f493b3328c6c43cf7d363463f1767050c
 SHA512:
-  metadata.gz: c996fa5a43603f429fb061c84585a84dbe97719032893f3ae1fff22dcd8056fb1c71fb8fa103ea46fca1a50cbaf6156139e9b1ee03ac1151e7a33d576d08b724
-  data.tar.gz: 8eff9c58e5dc39d40e18445bb33a4dcba019034975c110382a9f143021ddaf6920b8e783cc031be07f431a295e2b973ed750cf9f71e064c0796822e51faa6145
+  metadata.gz: 11141195b070ccfda0ddafb7b54a81402cddf003b1256ae95cf1c3578f5afdf50afb65ac4449336f9925280901d9e40ac13329fb29435e12bd75d49b66f4130e
+  data.tar.gz: c561ade16056cd4a6b004b58397fd8ed0c38d7b65b3be116f40553dd8b14af04fbbec7f41dd341c63cbdf48a897075ca97557c2f46710d7c4d09ac3ce9b2e12a

data/CHANGELOG

@@ -1,3 +1,9 @@
+= 3.24.0 (2019-09-13)
+
+* Fix Proc.new warning in module_include plugin on Ruby 2.7+ (jeremyevans)
+
+* Improve render_each performance by calling compiled template methods directly (jeremyevans)
+
 = 3.23.0 (2019-08-13)
 
 * Make roda/session_middleware work if type_routing plugin is loaded into Roda itself (jeremyevans) (#169)

data/doc/release_notes/3.24.0.txt

@@ -0,0 +1,14 @@
+= Improvements
+
+* The performance of the render_each plugin has been dramatically
+  improved by calling compiled template methods directly. For a simple
+  template, render_each performance with a single object can be about
+  2x faster, and render_each performance for 100 objects can be 3x
+  (cache: false) to 9x (cache: true) faster.
+
+  This optimization can be used if no options are provided to
+  render_each, or if :local and/or :locals options are provided. Use
+  of other options will disable this optimization.
+
+* The module_include plugin no longer calls Proc.new without a
+  block, fixing a warning on Ruby 2.7.

data/lib/roda/plugins/module_include.rb

@@ -62,7 +62,7 @@ class Roda
         private
 
         # Backbone of the request_module and response_module methods.
-        def module_include(type, mod)
+        def module_include(type, mod, &block)
           if type == :response
             klass = self::RodaResponse
             iv = :@response_module
@@ -82,7 +82,7 @@ class Roda
               klass.send(:include, mod)
             end
 
-            mod.module_eval(&Proc.new) if block_given?
+            mod.module_eval(&block) if block
           end
 
           mod

data/lib/roda/plugins/render.rb

@@ -224,7 +224,8 @@ class Roda
 
       # Wrapper object for the Tilt template, that checks the modified
       # time of the template file, and rebuilds the template if the
-      # template file has been modified.
+      # template file has been modified.  This is an internal class and
+      # the API is subject to change at any time.
       class TemplateMtimeWrapper
         def initialize(template_class, path, *template_args)
           @template_class = template_class
@@ -263,17 +264,17 @@ class Roda
         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)
+          def define_compiled_method(roda_class, method_name, locals_keys=EMPTY_ARRAY)
             mod = roda_class::RodaCompiledTemplates
             internal_method_name = :"_#{method_name}"
             begin
-              mod.send(:define_method, internal_method_name, send(:compiled_method, OPTS))
+              mod.send(:define_method, internal_method_name, send(:compiled_method, locals_keys))
             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(:define_method, method_name, &compiled_method_lambda(self, roda_class, internal_method_name, locals_keys))
             mod.send(:private, method_name)
 
             method_name
@@ -282,22 +283,22 @@ class Roda
           private
 
           # Return the compiled method for the current template object.
-          def compiled_method(_)
-            @template.send(:compiled_method, OPTS)
+          def compiled_method(locals_keys=EMPTY_ARRAY)
+            @template.send(:compiled_method, locals_keys)
           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)
+          def compiled_method_lambda(template, roda_class, method_name, locals_keys=EMPTY_ARRAY)
             mod = roda_class::RodaCompiledTemplates
-            lambda do |_, &block|
+            lambda do |locals, &block|
               if template.modified?
-                mod.send(:define_method, method_name, template.send(:compiled_method, OPTS))
+                mod.send(:define_method, method_name, template.send(:compiled_method, locals_keys))
                 mod.send(:private, method_name)
               end
 
-              send(method_name, OPTS, &block)
+              send(method_name, locals, &block)
             end
           end
         end
@@ -524,7 +525,7 @@ class Roda
 
               if define_compiled_method && cache != false
                 begin
-                  unbound_method = template.send(:compiled_method, OPTS)
+                  unbound_method = template.send(:compiled_method, EMPTY_ARRAY)
                 rescue ::NotImplementedError
                   method_cache[method_cache_key] = false
                 else

data/lib/roda/plugins/render_each.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require_relative 'render'
+
 #
 class Roda
   module RodaPlugins
@@ -32,6 +34,10 @@ class Roda
         app.plugin :render
       end
 
+      COMPILED_METHOD_SUPPORT = Render::COMPILED_METHOD_SUPPORT
+      NO_CACHE = {:cache=>false}.freeze
+      ALLOWED_KEYS = [:locals, :local].freeze
+
       module InstanceMethods
         # For each value in enum, render the given template using the
         # given opts.  The template and options hash are passed to +render+.
@@ -39,11 +45,43 @@ class Roda
         # :local :: The local variable to use for the current enum value
         #           inside the template.  An explicit +nil+ value does not
         #           set a local variable.  If not set, uses the template name.
-        def render_each(enum, template, opts=OPTS)
-          if as = opts.has_key?(:local)
+        def render_each(enum, template, opts=(no_opts = true; optimized_template = _cached_render_each_template_method(template); OPTS))
+          if optimized_template
+            as = template.to_s.to_sym
+            return enum.map{|v| send(optimized_template, as=>v)}.join
+          elsif opts.has_key?(:local)
             as = opts[:local]
           else
             as = template.to_s.to_sym
+
+            if COMPILED_METHOD_SUPPORT &&
+               no_opts &&
+               optimized_template.nil? &&
+               (method_cache = render_opts[:template_method_cache]) &&
+               (method_cache_key = _cached_template_method_key([:_render_each, template]))
+
+              template_obj = retrieve_template(render_template_opts(template, NO_CACHE))
+              method_name = :"_roda_render_each_#{self.class.object_id}_#{method_cache_key}"
+
+              case template_obj
+              when Render::TemplateMtimeWrapper
+                optimized_template = method_cache[method_cache_key] = template_obj.define_compiled_method(self.class, method_name, [as])
+              else
+                begin
+                  unbound_method = template_obj.send(:compiled_method, [as])
+                rescue ::NotImplementedError
+                  method_cache[method_cache_key] = false
+                else
+                  self.class::RodaCompiledTemplates.send(:define_method, method_name, unbound_method)
+                  self.class::RodaCompiledTemplates.send(:private, method_name)
+                  optimized_template = method_cache[method_cache_key] = method_name
+                end
+              end
+
+              if optimized_template
+                return enum.map{|v| send(optimized_template, as=>v)}.join
+              end
+            end
           end
 
           if as
@@ -55,11 +93,90 @@ class Roda
             end
           end
 
+          if COMPILED_METHOD_SUPPORT &&
+             !no_opts &&
+             as &&
+             (opts.keys - ALLOWED_KEYS).empty? &&
+             (method_cache = render_opts[:template_method_cache])
+
+            locals_keys = (locals.keys << as).sort
+            key = [:_render_each, template, locals_keys]
+
+            optimized_template = case template
+            when String, Symbol
+              _cached_template_method_lookup(method_cache, key)
+            else
+              false
+            end
+
+            case optimized_template
+            when Symbol
+              return enum.map do |v|
+                locals[as] = v
+                send(optimized_template, locals)
+              end.join
+            when false
+              # nothing
+            else
+              if method_cache_key = _cached_template_method_key(key)
+                template_obj = retrieve_template(render_template_opts(template, NO_CACHE))
+                method_name = :"_roda_render_each_#{self.class.object_id}_#{method_cache_key}"
+
+                case template_obj
+                when Render::TemplateMtimeWrapper
+                  optimized_template = method_cache[method_cache_key] = template_obj.define_compiled_method(self.class, method_name, locals_keys)
+                else
+                  begin
+                    unbound_method = template_obj.send(:compiled_method, locals_keys)
+                  rescue ::NotImplementedError
+                    method_cache[method_cache_key] = false
+                  else
+                    self.class::RodaCompiledTemplates.send(:define_method, method_name, unbound_method)
+                    self.class::RodaCompiledTemplates.send(:private, method_name)
+                    optimized_template = method_cache[method_cache_key] = method_name
+                  end
+                end
+
+                if optimized_template
+                  return enum.map do |v|
+                    locals[as] = v
+                    send(optimized_template, locals)
+                  end.join
+                end
+              end
+            end
+          end
+
           enum.map do |v|
             locals[as] = v if as
             render_template(template, opts)
           end.join
         end
+        
+        private
+
+        if COMPILED_METHOD_SUPPORT
+          # If compiled method support is enabled in the render plugin, return the
+          # method name to call to render the template.  Return false if not given
+          # a string or symbol, or if compiled method support for this template has
+          # been explicitly disabled.  Otherwise return nil.
+          def _cached_render_each_template_method(template)
+            case template
+            when String, Symbol
+              if (method_cache = render_opts[:template_method_cache])
+                _cached_template_method_lookup(method_cache, [:_render_each, template])
+              end
+            else
+              false
+            end
+          end
+        else
+          # :nocov:
+          def _cached_render_each_template_method(template)
+            nil
+          end
+          # :nocov:
+        end
       end
     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 = 23
+  RodaMinorVersion = 24
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

data/spec/plugin/render_each_spec.rb

@@ -1,41 +1,82 @@
 require_relative "../spec_helper"
 
 begin
-  require 'tilt/erb'
+  require 'tilt'
+  require 'tilt/string'
+  require 'tilt/rdoc'
+  require_relative '../../lib/roda/plugins/render'
 rescue LoadError
   warn "tilt not installed, skipping render_each plugin test"  
 else
 describe "render_each plugin" do 
-  it "calls render with each argument, returning joined string with all results" do
-    app(:bare) do
-      plugin :render_each
-      def render_template(t, opts)
-        "r#{t}#{opts[:locals][:foo] if opts[:locals]}#{opts[:bar]}#{opts[:locals][:bar] if opts[:locals]} "
-      end 
-
-      route do |r|
-        r.root do
-          render_each([1,2,3], :foo)
-        end
+  [true, false].each do |cache|
+    it "calls render with each argument, returning joined string with all results in cache: #{cache} mode" do
+      app(:bare) do
+        plugin :render, :views=>'spec/views', :engine=>'str', :cache=>cache
+        plugin :render_each
+
+        o = Object.new
+        def o.to_s; 'each' end
+
+        route do |r|
+          r.root do
+            render_each([1,2,3], :each)
+          end
+
+          r.is 'a' do
+            render_each([1,2,3], :each, :local=>:foo, :bar=>4)
+          end
+
+          r.is 'b' do
+            render_each([1,2,3], :each, :local=>nil)
+          end
+
+          r.is 'c' do
+            render_each([1,2,3], :each, :locals=>{:foo=>4})
+          end
+
+          r.is 'd' do
+            render_each([1,2,3], {:template=>:each}, :local=>:each)
+          end
 
-        r.is 'a' do
-          render_each([1,2,3], :bar, :local=>:foo, :bar=>4)
+          r.is 'e' do
+            render_each([1,2,3], o)
+          end
         end
+      end
+
+      3.times do
+        body.must_equal "r-1-\nr-2-\nr-3-\n"
+        body("/a").must_equal "r--1\nr--2\nr--3\n"
+        body("/b").must_equal "r--\nr--\nr--\n"
+        body("/c").must_equal "r-1-4\nr-2-4\nr-3-4\n"
+        body("/d").must_equal "r-1-\nr-2-\nr-3-\n"
+        body("/e").must_equal "r-1-\nr-2-\nr-3-\n"
+      end
+    end
+
+    if Roda::RodaPlugins::Render::COMPILED_METHOD_SUPPORT
+      it "calls render with each argument, handling template engines that don't support compilation in cache: #{cache} mode" do
+        app(:bare) do
+          plugin :render, :views=>'spec/views', :engine=>'rdoc', :cache=>cache
+          plugin :render_each
 
-        r.is 'b' do
-          render_each([1,2,3], :bar, :local=>nil)
+          route do |r|
+            r.root do
+              render_each([1], :a)
+            end
+            r.is 'a' do
+              render_each([1], :a, :local=>:b)
+            end
+          end
         end
 
-        r.is 'c' do
-          render_each([1,2,3], :bar, :locals=>{:foo=>4})
+        3.times do
+          body.strip.must_equal "<p># a # * b</p>"
+          body('/a').strip.must_equal "<p># a # * b</p>"
         end
       end
     end
-
-    body.must_equal 'rfoo1 rfoo2 rfoo3 '
-    body("/a").must_equal 'rbar14 rbar24 rbar34 '
-    body("/b").must_equal 'rbar rbar rbar '
-    body("/c").must_equal 'rbar41 rbar42 rbar43 '
   end
 end
 end

data/spec/views/each.str

@@ -0,0 +1 @@
+r-#{each if local_variables.include?(:each)}-#{foo if local_variables.include?(:foo)}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.23.0
+  version: 3.24.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-13 00:00:00.000000000 Z
+date: 2019-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -220,6 +220,7 @@ extra_rdoc_files:
 - 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.24.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -279,6 +280,7 @@ files:
 - 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.24.0.txt
 - doc/release_notes/3.3.0.txt
 - doc/release_notes/3.4.0.txt
 - doc/release_notes/3.5.0.txt
@@ -516,6 +518,7 @@ files:
 - spec/views/comp_layout.erb
 - spec/views/comp_test.erb
 - spec/views/content-yield.erb
+- spec/views/each.str
 - spec/views/home.erb
 - spec/views/home.str
 - spec/views/iv.erb