roda 3.24.0 → 3.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc61123e82d5731f6459164ff0e6305115008d22f59607b471021f6d5586646d
-  data.tar.gz: 3bce436fb87890ef4d593ea97792044f493b3328c6c43cf7d363463f1767050c
+  metadata.gz: 4e98660fac24a8bb7b455591674e9427e4fb07521384ae925888b95d7b38509c
+  data.tar.gz: 5ca8cec4fbff75633280c63375f9b33b5eeb26f7862d05356b5c3e85f0f1a29a
 SHA512:
-  metadata.gz: 11141195b070ccfda0ddafb7b54a81402cddf003b1256ae95cf1c3578f5afdf50afb65ac4449336f9925280901d9e40ac13329fb29435e12bd75d49b66f4130e
-  data.tar.gz: c561ade16056cd4a6b004b58397fd8ed0c38d7b65b3be116f40553dd8b14af04fbbec7f41dd341c63cbdf48a897075ca97557c2f46710d7c4d09ac3ce9b2e12a
+  metadata.gz: 1e1ac389fcaad6a03b0ea9a5b89bf895c49421f971ce3a21eacaa7a24f93e061a1318debfd5cc30f2a41c146fdfbe53bd18785e6e2cc53fed938bde8dc078efa
+  data.tar.gz: fc26dccc7384e5619754d5f2ca4fddaf691aa57b301f1e2ea9b8de9a27224a49961ee0b162117363a7805a80860f4f3bb012d6d11ac8ca81f3b25f1505d888ef

data/CHANGELOG

@@ -1,3 +1,9 @@
+= 3.25.0 (2019-10-15)
+
+* Support change in tilt 2.0.10 private API to continue to support compiled templates, with up to 33% performance improvement (jeremyevans)
+
+* Improve render performance with :locals option up to 75% by calling compiled template methods directly (jeremyevans)
+
 = 3.24.0 (2019-09-13)
 
 * Fix Proc.new warning in module_include plugin on Ruby 2.7+ (jeremyevans)

data/doc/release_notes/3.25.0.txt

@@ -0,0 +1,12 @@
+= Improvements
+
+* The new tilt 2.0.10 private API is now supported when using
+  compiled template methods, with up to a 33% performance increase.
+  The older tilt private API (back to tilt 1.2) is still supported.
+
+* The performance of the render and view methods in the render plugin
+  when called with only the :locals option are now about 75% faster
+  by calling compiled template methods directly.
+
+* Keyword argument separation issues are now handled on Ruby 2.7+
+  when defining methods with blocks that accept keyword arguments.

data/lib/roda.rb

@@ -213,7 +213,11 @@ class Roda
                   # Complexity of handling keyword arguments using define_method is too high,
                   # Fallback to instance_exec in this case.
                   b = block
-                  block = lambda{|*a| instance_exec(*a, &b)} # Keyword arguments fallback
+                  if RUBY_VERSION >= '2.7'
+                    block = eval('lambda{|*a, **kw| instance_exec(*a, **kw, &b)}', nil, __FILE__, __LINE__) # Keyword arguments fallback
+                  else
+                    block = lambda{|*a| instance_exec(*a, &b)} # Keyword arguments fallback
+                  end
                 else
                   arity_meth = meth
                   meth = :"#{meth}_arity"

data/lib/roda/plugins/precompile_templates.rb

@@ -68,7 +68,7 @@ class Roda
           instance = allocate
           compile_opts.each do |compile_opt|
             template = instance.send(:retrieve_template, compile_opt)
-            template.send(:compiled_method, locals)
+            Render.tilt_template_compiled_method(template, locals, self)
           end
 
           nil

data/lib/roda/plugins/render.rb

@@ -122,7 +122,9 @@ class Roda
     #
     # 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.
+    # symbol/string to render/view.  Next best optimized are template calls with a
+    # single :locals option.  Use of other options disables the compiled template
+    # method optimizations and can be significantly slower.
     #
     # 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
@@ -131,10 +133,20 @@ class Roda
     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
+      tilt_compiled_method_support = defined?(Tilt::VERSION) && Tilt::VERSION >= '1.2' &&
+        ([1, -2].include?(((compiled_method_arity = Tilt::Template.instance_method(:compiled_method).arity) rescue false)))
+      NO_CACHE = {:cache=>false}.freeze
+      COMPILED_METHOD_SUPPORT = RUBY_VERSION >= '2.3' && tilt_compiled_method_support
+
+      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
+      else
+        def self.tilt_template_compiled_method(template, locals_keys, scope_class)
+          template.send(:compiled_method, locals_keys)
+        end
+      end
 
       # Setup default rendering options.  See Render for details.
       def self.configure(app, opts=OPTS)
@@ -268,7 +280,7 @@ class Roda
             mod = roda_class::RodaCompiledTemplates
             internal_method_name = :"_#{method_name}"
             begin
-              mod.send(:define_method, internal_method_name, send(:compiled_method, locals_keys))
+              mod.send(:define_method, internal_method_name, send(:compiled_method, locals_keys, roda_class))
             rescue ::NotImplementedError
               return false
             end
@@ -283,8 +295,8 @@ class Roda
           private
 
           # Return the compiled method for the current template object.
-          def compiled_method(locals_keys=EMPTY_ARRAY)
-            @template.send(:compiled_method, locals_keys)
+          def compiled_method(locals_keys=EMPTY_ARRAY, roda_class=nil)
+            Render.tilt_template_compiled_method(@template, locals_keys, roda_class)
           end
 
           # Return the lambda used to define the compiled template method.  This
@@ -294,7 +306,7 @@ class Roda
             mod = roda_class::RodaCompiledTemplates
             lambda do |locals, &block|
               if template.modified?
-                mod.send(:define_method, method_name, template.send(:compiled_method, locals_keys))
+                mod.send(:define_method, method_name, Render.tilt_template_compiled_method(template, locals_keys, roda_class))
                 mod.send(:private, method_name)
               end
 
@@ -326,9 +338,11 @@ class Roda
 
       module InstanceMethods
         # Render the given template. See Render for details.
-        def render(template, opts = (optimized_template = _cached_template_method(template); OPTS), &block)
+        def render(template, opts = (no_opts = true; optimized_template = _cached_template_method(template); OPTS), &block)
           if optimized_template
             send(optimized_template, OPTS, &block)
+          elsif !no_opts && opts.length == 1 && (locals = opts[:locals]) && (optimized_template = _optimized_render_method_for_locals(template, locals))
+            send(optimized_template, locals, &block)
           else
             opts = render_template_opts(template, opts)
             retrieve_template(opts).render((opts[:scope]||self), (opts[:locals]||OPTS), &block)
@@ -395,6 +409,48 @@ class Roda
           def _cached_template_method_lookup(method_cache, template)
             method_cache[template]
           end
+
+          # Use an optimized render path for templates with a hash of locals.  Returns the result
+          # of the template render if the optimized path is used, or nil if the optimized
+          # path is not used and the long method needs to be used.
+          def _optimized_render_method_for_locals(template, locals)
+            return unless method_cache = render_opts[:template_method_cache]
+
+            locals_keys = locals.keys.sort
+            key = [:_render_locals, template, locals_keys]
+
+            optimized_template = case template
+            when String, Symbol
+              _cached_template_method_lookup(method_cache, key)
+            else
+              return
+            end
+
+            case optimized_template
+            when Symbol
+              optimized_template
+            else
+              if method_cache_key = _cached_template_method_key(key)
+                template_obj = retrieve_template(render_template_opts(template, NO_CACHE))
+                method_name = :"_roda_template_locals_#{self.class.object_id}_#{method_cache_key}"
+
+                method_cache[method_cache_key] = case template_obj
+                when Render::TemplateMtimeWrapper
+                  template_obj.define_compiled_method(self.class, method_name, locals_keys)
+                else
+                  begin
+                    unbound_method = Render.tilt_template_compiled_method(template_obj, locals_keys, self.class)
+                  rescue ::NotImplementedError
+                    false
+                  else
+                    self.class::RodaCompiledTemplates.send(:define_method, method_name, unbound_method)
+                    self.class::RodaCompiledTemplates.send(:private, method_name)
+                    method_name
+                  end
+                end
+              end
+            end
+          end
         else
           # :nocov:
           def _cached_template_method(template)
@@ -404,6 +460,10 @@ class Roda
           def _cached_template_method_key(template)
             nil
           end
+
+          def _optimized_render_method_for_locals(_, _)
+            nil
+          end
           # :nocov:
         end
 
@@ -525,7 +585,7 @@ class Roda
 
               if define_compiled_method && cache != false
                 begin
-                  unbound_method = template.send(:compiled_method, EMPTY_ARRAY)
+                  unbound_method = Render.tilt_template_compiled_method(template, EMPTY_ARRAY, self.class)
                 rescue ::NotImplementedError
                   method_cache[method_cache_key] = false
                 else

data/lib/roda/plugins/render_each.rb

@@ -34,8 +34,6 @@ 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
@@ -47,40 +45,13 @@ class Roda
         #           set a local variable.  If not set, uses the template name.
         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
+            return _optimized_render_each(enum, optimized_template, template.to_s.to_sym, {})
           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
+            if no_opts && optimized_template.nil? && (optimized_template = _optimized_render_method_for_locals(template, (locals = {as=>nil})))
+              return _optimized_render_each(enum, optimized_template, as, locals)
             end
           end
 
@@ -91,59 +62,10 @@ class Roda
             else
               locals = opts[:locals] = {}
             end
-          end
-
-          if COMPILED_METHOD_SUPPORT &&
-             !no_opts &&
-             as &&
-             (opts.keys - ALLOWED_KEYS).empty? &&
-             (method_cache = render_opts[:template_method_cache])
+            locals[as] = nil
 
-            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
+            if (opts.keys - ALLOWED_KEYS).empty? && (optimized_template = _optimized_render_method_for_locals(template, locals))
+              return _optimized_render_each(enum, optimized_template, as, locals)
             end
           end
 
@@ -155,7 +77,7 @@ class Roda
         
         private
 
-        if COMPILED_METHOD_SUPPORT
+        if Render::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
@@ -164,12 +86,20 @@ class Roda
             case template
             when String, Symbol
               if (method_cache = render_opts[:template_method_cache])
-                _cached_template_method_lookup(method_cache, [:_render_each, template])
+                _cached_template_method_lookup(method_cache, [:_render_locals, template, [template.to_sym]])
               end
             else
               false
             end
           end
+
+          # Use an optimized render for each value in the enum.
+          def _optimized_render_each(enum, optimized_template, as, locals)
+            enum.map do |v|
+              locals[as] = v
+              send(optimized_template, locals)
+            end.join
+          end
         else
           # :nocov:
           def _cached_render_each_template_method(template)

data/lib/roda/plugins/sessions.rb

@@ -71,9 +71,9 @@ class Roda
     # :max_seconds :: The maximum number of seconds to allow for total session lifetime, starting with when
     #                 the session was originally created.  Default is <tt>86400*30</tt> (30 days). Can be set to
     #                 +nil+ to disable session lifetime checks.
-    # :max_idle_sessions :: The maximum number of seconds to allow since the session was last updated.
-    #                       Default is <tt>86400*7</tt> (7 days).  Can be set to nil to disable session idleness
-    #                       checks.
+    # :max_idle_seconds :: The maximum number of seconds to allow since the session was last updated.
+    #                      Default is <tt>86400*7</tt> (7 days).  Can be set to nil to disable session idleness
+    #                      checks.
     # :old_secret :: The previous secret to use, allowing for secret rotation.  Must be a string of at least 64
     #                bytes if given.
     # :pad_size :: Pad session data (after possible compression, before encryption), to a multiple of this

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

data/spec/define_roda_method_spec.rb

@@ -206,6 +206,20 @@ describe "Roda.define_roda_method" do
     end
 
     it "should handle expected_arity :any with keyword arguments" do
+      if RUBY_VERSION >= '2.7' && RUBY_VERSION < '3'
+        suppress = proc do |&b|
+          begin
+            stderr = $stderr
+            $stderr = StringIO.new
+            b.call
+          ensure
+            $stderr = stderr
+          end
+        end
+      else
+        suppress = proc{|&b| b.call}
+      end
+
       m = eval('app.define_roda_method("x", :any){|b:2| b}', binding)
       @scope.send(m).must_equal 2
       @scope.send(m, 4).must_equal 2
@@ -225,26 +239,26 @@ describe "Roda.define_roda_method" do
       @scope.send(m, 4, b: 3).must_equal(b: 3)
 
       m = eval('app.define_roda_method("x", :any){|x, b:9| [x, b, 1]}', binding)
-      @scope.send(m).must_equal [nil, 9, 1]
+      suppress.call{@scope.send(m)[1..-1]}.must_equal [9, 1]
       @scope.send(m, 2).must_equal [2, 9, 1]
       @scope.send(m, 2, 3).must_equal [2, 9, 1]
-      @scope.send(m, b: 4).must_equal [{b: 4}, 9, 1]
+      eval("@scope.send(m, {b: 4}#{', **{}' if RUBY_VERSION > '2'})").must_equal [{b: 4}, 9, 1]
       @scope.send(m, 2, b: 4).must_equal [2, 4, 1]
       @scope.send(m, 2, 3, b: 4).must_equal [2, 4, 1]
 
       m = eval('app.define_roda_method("x", :any){|x, b:| [x, b, 1]}', binding)
-      proc{@scope.send(m)}.must_raise ArgumentError
+      proc{suppress.call{@scope.send(m)}}.must_raise ArgumentError
       proc{@scope.send(m, 2)}.must_raise ArgumentError
       proc{@scope.send(m, 2, 3)}.must_raise ArgumentError
-      proc{@scope.send(m, b: 4)}.must_raise ArgumentError
+      proc{eval("@scope.send(m, {b: 4}#{', **{}' if RUBY_VERSION > '2'})")}.must_raise ArgumentError
       @scope.send(m, 2, b: 4).must_equal [2, 4, 1]
       @scope.send(m, 2, 3, b: 4).must_equal [2, 4, 1]
 
       m = eval('app.define_roda_method("x", :any){|x, **b| [x, b, 1]}', binding)
-      @scope.send(m).must_equal [nil, {}, 1]
+      suppress.call{@scope.send(m)[1..-1]}.must_equal [{}, 1]
       @scope.send(m, 2).must_equal [2, {}, 1]
       @scope.send(m, 2, 3).must_equal [2, {}, 1]
-      @scope.send(m, b: 4).must_equal [{b: 4}, {}, 1]
+      eval("@scope.send(m, {b: 4}#{', **{}' if RUBY_VERSION > '2'})").must_equal [{b: 4}, {}, 1]
       @scope.send(m, 2, b: 4).must_equal [2, {b: 4}, 1]
       @scope.send(m, 2, 3, b: 4).must_equal [2, {b: 4}, 1]
 

data/spec/plugin/precompile_templates_spec.rb

@@ -19,8 +19,9 @@ describe "precompile_templates plugin" do
     app.render_opts[:cache][File.expand_path('spec/views/iv.erb')].must_be_nil
     app.precompile_templates 'spec/views/iv.erb'
     app.render_opts[:cache][File.expand_path('spec/views/iv.erb')].wont_equal nil
-    app.render_opts[:cache][File.expand_path('spec/views/iv.erb')].instance_variable_get(:@compiled_method)[[]].wont_equal nil
+    app.render_opts[:cache][File.expand_path('spec/views/iv.erb')].instance_variable_get(:@compiled_method).length.must_equal 1
     body.strip.must_equal '1'
+    app.render_opts[:cache][File.expand_path('spec/views/iv.erb')].instance_variable_get(:@compiled_method).length.must_equal 1
   end
 
   it "adds support for template precompilation with :locals" do
@@ -35,8 +36,9 @@ describe "precompile_templates plugin" do
     app.render_opts[:cache][File.expand_path('spec/views/about.erb')].must_be_nil
     app.precompile_templates 'spec/views/about.erb', :locals=>[:title]
     app.render_opts[:cache][File.expand_path('spec/views/about.erb')].wont_equal nil
-    app.render_opts[:cache][File.expand_path('spec/views/about.erb')].instance_variable_get(:@compiled_method)[[:title]].wont_equal nil
+    app.render_opts[:cache][File.expand_path('spec/views/about.erb')].instance_variable_get(:@compiled_method).length.must_equal 1
     body.strip.must_equal '<h1>1</h1>'
+    app.render_opts[:cache][File.expand_path('spec/views/about.erb')].instance_variable_get(:@compiled_method).length.must_equal 1
   end
 
   it "adds support for template precompilation with :inline" do
@@ -51,8 +53,9 @@ describe "precompile_templates plugin" do
     app.render_opts[:cache]['a'].must_be_nil
     app.precompile_templates :inline=>'a', :cache_key=>'a'
     app.render_opts[:cache]['a'].wont_equal nil
-    app.render_opts[:cache]['a'].instance_variable_get(:@compiled_method)[[]].wont_equal nil
+    app.render_opts[:cache]['a'].instance_variable_get(:@compiled_method).length.must_equal 1
     body.strip.must_equal "a"
+    app.render_opts[:cache]['a'].instance_variable_get(:@compiled_method).length.must_equal 1
   end
 end
 end

data/spec/plugin/render_spec.rb

@@ -763,22 +763,26 @@ describe "render plugin" do
     req("/a")
     req("/c")
 
+    @app = Class.new(app)
     app.plugin :render, :allowed_paths=>[]
     proc{req}.must_raise Roda::RodaError
     proc{req("/a")}.must_raise Roda::RodaError
     proc{req("/c")}.must_raise Roda::RodaError
 
+    @app = Class.new(app)
     app.plugin :render, :allowed_paths=>['spec/views/about']
     proc{req}.must_raise Roda::RodaError
     proc{req("/a")}.must_raise Roda::RodaError
     req("/c")
 
+    @app = Class.new(app)
     app.plugin :render, :allowed_paths=>%w'spec/views/about spec/views/b'
     body.strip.must_equal "b"
     proc{req("/a")}.must_raise Roda::RodaError
     req("/c")
 
     render_opts[:check_paths] = true
+    @app = Class.new(app)
     app.plugin :render, :check_paths=>false
     body.strip.must_equal "b"
     proc{req("/a")}.must_raise Roda::RodaError

data/spec/spec_helper.rb

@@ -27,7 +27,7 @@ require "stringio"
 
 ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
 gem 'minitest'
-require "minitest/autorun"
+require "minitest/global_expectations/autorun"
 
 $RODA_WARN = true
 def (Roda::RodaPlugins).warn(s)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.24.0
+  version: 3.25.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-13 00:00:00.000000000 Z
+date: 2019-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.7.0
+- !ruby/object:Gem::Dependency
+  name: minitest-global_expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: tilt
   requirement: !ruby/object:Gem::Requirement
@@ -221,6 +235,7 @@ extra_rdoc_files:
 - 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.25.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -281,6 +296,7 @@ files:
 - 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.25.0.txt
 - doc/release_notes/3.3.0.txt
 - doc/release_notes/3.4.0.txt
 - doc/release_notes/3.5.0.txt