roda 3.21.0 → 3.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34a644ccaa69bc1913eb1f54315437ce4b215bd5925e82f720d0fda007895224
-  data.tar.gz: 9a85847e46720f4fa2f7a050febd5b0f6ef7db528c8fbd09836113148944f87c
+  metadata.gz: c75151c856c93ac28e9089018a1d04f40f479782cc4d2e96099d4182d993d81a
+  data.tar.gz: 3190821d03128b656e573f8dc748fafcd753b55bfabd4d53c1c6c219ed0a340a
 SHA512:
-  metadata.gz: 739c2a26ea80aeca2bbb4b3b51c4cabf93100309956fe594b61cc66a72f6d3e2f23ab0356c81f12e4a461bf82eb1d7f9cc2d0dc5fecbef88348bd17aca17c33a
-  data.tar.gz: 65ef8401849ee398968ccfce12ccbf203914f7a76721c8cb0ef31b5ab9051fd7f8460361dd96abb495dfa25c5acb50141611448b7065a5be3340b8ca51cc70ff
+  metadata.gz: cbf0bdcd577b6766483121f654b3e5139de674b81539fda0a43d949bb73d0092d7e280b1efd772409917a0f53a6fb877897126687060b4c6a14c8c9f5d152e75
+  data.tar.gz: 33fa800abbe118922d05db9712bc35910e7d633fbe4f224083c79f4289e8a269dcca90f31b2ac07aa0bece05c3957e5afa3f08bf14bea005a1b93242bcb317c5

data/CHANGELOG

@@ -1,3 +1,7 @@
+= 3.22.0 (2019-07-12)
+
+* Improve render performance up to 4x in the default case by calling compiled template methods directly (jeremyevans)
+
 = 3.21.0 (2019-06-14)
 
 * Cache compiled templates in development mode, until the template files are modified (jeremyevans)

data/doc/release_notes/3.22.0.txt

@@ -0,0 +1,24 @@
+= 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 2.5x/4x faster by directly calling compiled template methods.
+  This works by extracting the UnboundMethod objects that Tilt
+  creates, and defining real methods for them, then calling those
+  methods using send. This avoids most of the overhead of the render
+  and view methods.  The compiled template methods are defined inside
+  a module included in the Roda app's class, so this support works
+  even if the Roda app itself is frozen.
+
+  Some plugins, such as render_locals, do not work with this
+  optimization, and disable the use of it.  The view_options plugin
+  does work with this optimization if you are using set_view_subdir or
+  append_view_subdir, but not if using set_view_options or
+  set_layout_options.
+
+  This optimization depends on Ruby 2.3+ and Tilt 1.2+, and will not
+  be used on earlier versions, or if an API change in Tilt is
+  detected.
+
+* Session deserialization is now slightly faster in the sessions
+  plugin.

data/lib/roda/plugins/render.rb

@@ -120,29 +120,27 @@ class Roda
     #
     # = Speeding Up Template Rendering
     #
-    # By default, determining the cache key to use for the template can be a lot
-    # of work.  If you specify the +:cache_key+ option, you can save Roda from
-    # having to do that work, which will make your application faster.  However,
-    # if you do this, you need to make sure you choose a correct key.
+    # The render/view method calls are optimized for usage with a single symbol/string
+    # argument specifying the template name.  So for fastest rendering, pass only a
+    # symbol/string to render/view.
     #
-    # If your application uses a unique template per path, in that the same
-    # path never uses more than one template, you can use the +view_options+ plugin
-    # and do:
-    #
-    #   set_view_options cache_key: r.path_info
-    #
-    # at the top of your route block.  You can even do this if you do have paths
-    # that use more than one template, as long as you specify +:cache_key+
-    # specifically when rendering in those paths.
-    #
-    # If you use a single layout in your application, you can also make layout
-    # rendering faster by specifying +:cache_key+ inside the +:layout_opts+
-    # plugin option.
+    # If you must pass a hash to render/view, either as a second argument or as the
+    # only argument, you can speed things up by specifying a +:cache_key+ option in
+    # the hash, making sure the +:cache_key+ is unique to the template you are
+    # rendering.
     module Render
+      # Support for using compiled methods directly requires Ruby 2.3 for the
+      # method binding to work, and Tilt 1.2 for Tilt::Template#compiled_method.
+      COMPILED_METHOD_SUPPORT = RUBY_VERSION >= '2.3' &&
+        defined?(Tilt::VERSION) &&
+        Tilt::VERSION >= '1.2' &&
+        (Tilt::Template.instance_method(:compiled_method).arity rescue false) == 1
+
       # 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)
         end
         app.opts[:render] = opts.dup
@@ -163,6 +161,20 @@ 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
+        end
+
         opts[:cache] = orig_cache || (opts[:cache_class] || RodaCache).new
 
         opts[:layout_opts] = (opts[:layout_opts] || {}).dup
@@ -182,6 +194,8 @@ class Roda
           else
             opts[:layout_opts][:template] = layout
           end
+
+          opts[:optimize_layout] = (opts[:layout_opts][:template] if opts[:layout_opts].keys.sort == [:_is_layout, :template])
         end
         opts[:layout_opts].freeze
 
@@ -249,6 +263,9 @@ class Roda
         def inherited(subclass)
           super
           opts = subclass.opts[:render] = subclass.opts[:render].dup
+          if COMPILED_METHOD_SUPPORT
+            opts[:template_method_cache] = (opts[:cache_class] || RodaCache).new
+          end
           opts[:cache] = opts[:cache].dup
           opts.freeze
         end
@@ -261,9 +278,13 @@ class Roda
 
       module InstanceMethods
         # Render the given template. See Render for details.
-        def render(template, opts = OPTS, &block)
-          opts = render_template_opts(template, opts)
-          retrieve_template(opts).render((opts[:scope]||self), (opts[:locals]||OPTS), &block)
+        def render(template, opts = (optimized_template = _cached_template_method(template); OPTS), &block)
+          if optimized_template
+            send(optimized_template, OPTS, &block)
+          else
+            opts = render_template_opts(template, opts)
+            retrieve_template(opts).render((opts[:scope]||self), (opts[:locals]||OPTS), &block)
+          end
         end
 
         # Return the render options for the instance's class.
@@ -274,9 +295,26 @@ class Roda
         # Render the given template.  If there is a default layout
         # for the class, take the result of the template rendering
         # and render it inside the layout.  See Render for details.
-        def view(template, opts=OPTS)
-          opts = parse_template_opts(template, opts)
-          content = opts[:content] || render_template(opts)
+        def view(template, opts = (optimized_template = _cached_template_method(template); OPTS))
+          if optimized_template
+            content = send(optimized_template, OPTS)
+
+            render_opts = self.class.opts[:render]
+            if layout_template = render_opts[:optimize_layout]
+              method_cache = render_opts[:template_method_cache]
+              unless layout_method = method_cache[:_roda_layout]
+                retrieve_template(:template=>layout_template, :cache_key=>nil, :template_method_cache_key => :_roda_layout)
+                layout_method = method_cache[:_roda_layout]
+              end
+
+              if layout_method
+                return send(layout_method, OPTS){content}
+              end
+            end
+          else
+            opts = parse_template_opts(template, opts)
+            content = opts[:content] || render_template(opts)
+          end
 
           if layout_opts  = view_layout_opts(opts)
             content = render_template(layout_opts){content}
@@ -287,6 +325,41 @@ class Roda
 
         private
 
+        if COMPILED_METHOD_SUPPORT
+          # If there is an instance method for the template, return the instance
+          # method symbol.  This optimization is only used for render/view calls
+          # with a single string or symbol argument.
+          def _cached_template_method(template)
+            case template
+            when String, Symbol
+              if (method_cache = render_opts[:template_method_cache])
+                _cached_template_method_lookup(method_cache, template)
+              end
+            end
+          end
+
+          # The key to use in the template method cache for the given template.
+          def _cached_template_method_key(template)
+            template
+          end
+
+          # Return the instance method symbol for the template in the method cache.
+          def _cached_template_method_lookup(method_cache, template)
+            method_cache[template]
+          end
+        else
+          # :nocov:
+          def _cached_template_method(template)
+            nil
+          end
+
+          def _cached_template_method_key(template)
+            nil
+          end
+          # :nocov:
+        end
+
+
         # Convert template options to single hash when rendering templates using render.
         def render_template_opts(template, opts)
           parse_template_opts(template, opts)
@@ -313,7 +386,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 = render_opts()
+          render_opts = self.class.opts[:render]
           engine_override = opts[:engine]
           engine = opts[:engine] ||= render_opts[:engine]
           if content = opts[:inline]
@@ -332,13 +405,15 @@ class Roda
           end
 
           if cache
-            template_block = opts[:template_block] unless content
-            template_opts = opts[:template_opts]
-
-            opts[:cache_key] ||= if template_class || engine_override || template_opts || template_block
-              [path, template_class, engine_override, template_opts, template_block]
-            else
-              path
+            unless opts.has_key?(:cache_key)
+              template_block = opts[:template_block] unless content
+              template_opts = opts[:template_opts]
+
+              opts[:cache_key] = if template_class || engine_override || template_opts || template_block
+                [path, template_class, engine_override, template_opts, template_block]
+              else
+                path
+              end
             end
           else
             opts.delete(:cache_key)
@@ -353,6 +428,9 @@ class Roda
           if template.is_a?(Hash)
             opts.merge!(template)
           else
+            if opts.empty? && (key = _cached_template_method_key(template))
+              opts[:template_method_cache_key] = key
+            end
             opts[:template] = template
             opts
           end
@@ -372,6 +450,7 @@ class Roda
           end
           cached_template(opts) do
             opts = found_template_opts || find_template(opts)
+            render_opts = self.class.opts[:render]
             template_opts = render_opts[:template_opts]
             if engine_opts = render_opts[:engine_opts][opts[:engine]]
               template_opts = template_opts.merge(engine_opts)
@@ -383,7 +462,28 @@ class Roda
             if render_opts[:check_template_mtime] && !opts[:template_block] && !cache
               TemplateMtimeWrapper.new(opts[:template_class], opts[:path], 1, template_opts)
             else
-              opts[:template_class].new(opts[:path], 1, template_opts, &opts[:template_block])
+              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
+
+                begin
+                  unbound_method = template.send(:compiled_method, OPTS)
+                rescue ::NotImplementedError
+                  method_cache[method_cache_key] = false
+                else
+                  method_name = :"_roda_template_#{self.class.object_id}_#{method_cache_key}"
+                  self.class::RodaCompiledTemplates.send(:define_method, method_name, unbound_method)
+                  self.class::RodaCompiledTemplates.send(:private, method_name)
+                  method_cache[method_cache_key] = method_name
+                end
+              end
+
+              template
             end
           end
         end

data/lib/roda/plugins/render_locals.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require_relative 'render'
+
 #
 class Roda
   module RodaPlugins
@@ -41,6 +43,14 @@ class Roda
       module InstanceMethods
         private
 
+        if Render::COMPILED_METHOD_SUPPORT
+          # Disable use of cached templates, since it assumes a render/view call with no
+          # options will have no locals.
+          def _cached_template_method(template)
+            nil
+          end
+        end
+
         def render_locals
           opts[:render_locals]
         end

data/lib/roda/plugins/sessions.rb

@@ -394,10 +394,11 @@ class Roda
 
           bitmap, created_at, updated_at = data.unpack('vVV')
           padding_bytes = bitmap & PADDING_MASK
-          if (max = opts[:max_seconds]) && Time.now.to_i > created_at + max
+          now = Time.now.to_i
+          if (max = opts[:max_seconds]) && now > created_at + max
             return _session_serialization_error("Not returning session: maximum session time expired")
           end
-          if (max = opts[:max_idle_seconds]) && Time.now.to_i > updated_at + max
+          if (max = opts[:max_idle_seconds]) && now > updated_at + max
             return _session_serialization_error("Not returning session: maximum session idle time expired")
           end
 

data/lib/roda/plugins/view_options.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+require_relative 'render'
+
 #
 class Roda
   module RodaPlugins
@@ -124,6 +126,32 @@ class Roda
 
         private
 
+        if Render::COMPILED_METHOD_SUPPORT
+          # Return nil if using custom view or layout options.
+          # If using a view subdir, prefix the template key with the subdir.
+          def _cached_template_method_key(template)
+            return if @_view_options || @_layout_options
+
+            if subdir = @_view_subdir
+              template = [subdir, template]
+            end
+
+            super
+          end
+
+          # Return nil if using custom view or layout options.
+          # If using a view subdir, prefix the template key with the subdir.
+          def _cached_template_method_lookup(method_cache, template)
+            return if @_view_options || @_layout_options
+
+            if subdir = @_view_subdir
+              template = [subdir, template]
+            end
+
+            super
+          end
+        end
+
         # If view options or locals have been set and this
         # template isn't a layout template, merge the options
         # and locals into the returned hash.

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

data/spec/plugin/render_spec.rb

@@ -1,8 +1,10 @@
 require_relative "../spec_helper"
 
 begin
+  require 'tilt'
   require 'tilt/erb'
   require 'tilt/string'
+  require_relative '../../lib/roda/plugins/render'
 rescue LoadError
   warn "tilt not installed, skipping render plugin test"  
 else
@@ -258,6 +260,162 @@ describe "render plugin" do
     app.render_opts[:views].must_equal File.join(Dir.pwd, 'bar')
   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')
+        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'
+          route do
+            render(:template=>template)
+          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::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)
+          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
+
+      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)
+          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
+
+      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)
+          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
+      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)
+          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 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)
+          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 1
+      end
+    end
+  end
+
   it "inline layouts and inline views" do
     app(:render) do
       view({:inline=>'bar'}, :layout=>{:inline=>'Foo: <%= yield %>'})

data/spec/plugin/view_options_spec.rb

@@ -21,12 +21,23 @@ describe "view_options plugin view subdirs" do
 
         r.on "about" do
           append_view_subdir 'views'
+          r.on 'test' do
+            append_view_subdir 'about'
+            r.is('view'){view("comp_test")}
+            r.is{render("comp_test")}
+          end
           render("about", :locals=>{:title => "About Roda"})
         end
 
         r.on "path" do
           render('spec/views/about', :locals=>{:title => "Path"}, :layout_opts=>{:locals=>{:title=>"Home"}})
         end
+
+        r.on 'test' do
+          set_view_subdir 'spec/views'
+          r.is('view'){view("comp_test")}
+          r.is{render("comp_test")}
+        end
       end
     end
   end
@@ -42,6 +53,22 @@ describe "view_options plugin view subdirs" do
   it "should not change behavior when subdir is not set" do
     body("/path").strip.must_equal "<h1>Path</h1>"
   end
+
+  it "should handle template compilation correctly" do
+    @app.plugin :render, :layout=>'./spec/views/comp_layout'
+    3.times do
+      body("/test").strip.must_equal "ct"
+      body("/about/test").strip.must_equal "about-ct"
+      body("/test/view").strip.must_equal "act\nb"
+      body("/about/test/view").strip.must_equal "aabout-ct\nb"
+    end
+    if Roda::RodaPlugins::Render::COMPILED_METHOD_SUPPORT
+      method_cache = @app.opts[:render][:template_method_cache]
+      method_cache[['spec/views', 'comp_test']].must_be_kind_of(Symbol)
+      method_cache[['spec/views/about', 'comp_test']].must_be_kind_of(Symbol)
+      method_cache[:_roda_layout].must_be_kind_of(Symbol)
+    end
+  end
 end
 
 describe "view_options plugin" do

data/spec/views/a.rdoc

@@ -0,0 +1,2 @@
+# a
+# * b

data/spec/views/about/comp_test.erb

@@ -0,0 +1 @@
+about-ct

data/spec/views/comp_layout.erb

@@ -0,0 +1 @@
+a<%= yield %>b

data/spec/views/comp_test.erb

@@ -0,0 +1 @@
+ct

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.21.0
+  version: 3.22.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-14 00:00:00.000000000 Z
+date: 2019-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -218,6 +218,7 @@ extra_rdoc_files:
 - doc/release_notes/3.19.0.txt
 - doc/release_notes/3.20.0.txt
 - doc/release_notes/3.21.0.txt
+- doc/release_notes/3.22.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -275,6 +276,7 @@ files:
 - doc/release_notes/3.2.0.txt
 - 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.3.0.txt
 - doc/release_notes/3.4.0.txt
 - doc/release_notes/3.5.0.txt
@@ -500,13 +502,17 @@ files:
 - spec/version_spec.rb
 - spec/views/_test.erb
 - spec/views/a.erb
+- spec/views/a.rdoc
 - spec/views/about.erb
 - spec/views/about.str
 - spec/views/about/_test.css.gz
 - spec/views/about/_test.erb
 - spec/views/about/_test.erb.gz
+- spec/views/about/comp_test.erb
 - spec/views/b.erb
 - spec/views/c.erb
+- spec/views/comp_layout.erb
+- spec/views/comp_test.erb
 - spec/views/content-yield.erb
 - spec/views/home.erb
 - spec/views/home.str