roda 2.29.0 → 3.0.0

data/lib/roda/plugins/placeholder_string_matchers.rb

@@ -17,7 +17,7 @@ class Roda
     #   end
     #
     # It is not recommended to use this in new applications, and it is encouraged
-    # to use separate symbol or string class matchers instead:
+    # to use separate string class or symbol matchers instead:
     #
     #   r.is "foo", String
     #   r.is "foo", :bar 

data/lib/roda/plugins/precompile_templates.rb

@@ -25,16 +25,10 @@ class Roda
     # If the templates use local variables, you need to specify which local
     # variables to precompile, which should be an array of symbols:
     #
-    #   precompile_templates 'views/users/_*.erb', :locals=>[:user]
+    #   precompile_templates 'views/users/_*.erb', locals: [:user]
     #
-    # Note that if you have multiple local variables and are not using a Tilt
-    # version greater than 2.0.1, you should specify the :locals option in the
-    # same order as the keys in the :locals hash you pass to render/view.  Since
-    # hashes are not ordered in ruby 1.8, you should not attempt to precompile
-    # templates that use :locals on ruby 1.8 unless you are using a Tilt version
-    # greater than 2.0.1.  If you are running the Tilt master branch, you can
-    # force sorting of locals using the +:sort_locals+ option when loading the
-    # plugin.
+    # Note that you should use Tilt 2.0.1+ if you are using this plugin, so
+    # that locals are handled in the same order.
     #
     # You can specify other render options when calling +precompile_templates+,
     # including +:cache_key+, +:template_class+, and +:template_opts+.  If you
@@ -44,29 +38,25 @@ class Roda
     # To compile inline templates, just pass a single hash containing an :inline
     # to +precompile_templates+:
     #
-    #   precompile_templates :inline=>some_template_string
+    #   precompile_templates inline: some_template_string
     module PrecompileTemplates
-      OPTS = {}.freeze
-      RodaPlugins.deprecate_constant(self, :OPTS)
-
       # Load the render plugin as precompile_templates depends on it.
-      # Default to sorting the locals if the Tilt version is greater than 2.0.1.
-      def self.load_dependencies(app, opts=RodaPlugins::OPTS)
+      def self.load_dependencies(app, opts=OPTS)
         app.plugin :render
-        app.opts[:precompile_templates_sort] = opts.fetch(:sort_locals, Tilt::VERSION > '2.0.1')
       end
 
       module ClassMethods
         # Precompile the templates using the given options.  See PrecompileTemplates
         # for details.
-        def precompile_templates(pattern, opts=RodaPlugins::OPTS)
+        def precompile_templates(pattern, opts=OPTS)
           if pattern.is_a?(Hash)
             opts = pattern.merge(opts)
           end
 
-          locals = opts[:locals] || []
-          if locals && self.opts[:precompile_templates_sort]
-            locals = locals.sort{|x,y| x.to_s <=> y.to_s}
+          if locals = opts[:locals]
+            locals.sort!
+          else
+            locals = EMPTY_ARRAY
           end
 
           compile_opts = if pattern.is_a?(Hash)

data/lib/roda/plugins/public.rb

@@ -10,7 +10,7 @@ class Roda
     #
     # The public plugin recognizes the application's :root option, and defaults to
     # using the +public+ subfolder of the application's +:root+ option.  If the application's
-    # :root option is not set, it defaults to the the +public+ folder in the working
+    # :root option is not set, it defaults to the +public+ folder in the working
     # directory.  Additionally, if a relative path is provided as the :root
     # option to the plugin, it will be considered relative to the application's
     # +:root+ option.
@@ -19,13 +19,10 @@ class Roda
     #
     #   opts[:root] = '/path/to/app'
     #   plugin :public
-    #   plugin :public, :root=>'static'
+    #   plugin :public, root: 'static'
     module Public
       SPLIT = Regexp.union(*[File::SEPARATOR, File::ALT_SEPARATOR].compact)
-      PARSER = RUBY_VERSION >= '1.9' ? URI::DEFAULT_PARSER : URI
-
-      NULL_BYTE = "\0".freeze
-      RodaPlugins.deprecate_constant(self, :NULL_BYTE)
+      PARSER = URI::DEFAULT_PARSER
 
       # Use options given to setup a Rack::File instance for serving files. Options:
       # :default_mime :: The default mime type to use if the mime type is not recognized.
@@ -97,18 +94,18 @@ class Roda
         end
 
         if ::Rack.release > '2'
-          # :nocov:
+          # Serve the given path using the given Rack::File server.
           def public_serve(server, path)
             server.serving(self, path)
           end
-          # :nocov:
         else
-          # Serve the given path using the given Rack::File server.
+          # :nocov:
           def public_serve(server, path)
             server = server.dup
             server.path = path
             server.serving(env)
           end
+          # :nocov:
         end
       end
     end

data/lib/roda/plugins/render.rb

@@ -24,7 +24,7 @@ class Roda
     # side effects (unless the templates themselves have side effects).
     # As Roda uses the routing block return value as the body of the response,
     # in most cases you will call these methods as the last expression in a
-    # routing block # to have the response body be the result of the template
+    # routing block to have the response body be the result of the template
     # rendering.
     #
     # Because +render+ and +view+ just return strings, you can call them inside
@@ -33,40 +33,34 @@ class Roda
     #
     #   route do |r|
     #     r.is 'foo-bars' do
-    #       @bars = Bar.where(:foo).map{|b| render(:bar, :locals=>{:bar=>b})}.join
+    #       @bars = Bar.where(:foo).map{|b| render(:bar, locals: {bar: b})}.join
     #       view('foo')
     #     end
     #   end
     #
     # You can provide options to the plugin method:
     #
-    #   plugin :render, :engine=>'haml', :views=>'admin_views'
+    #   plugin :render, engine: 'haml', views: 'admin_views'
     #
     # = Plugin Options
     #
     # The following plugin options are supported:
     #
-    # :allowed_paths :: Set the template paths to allow if +:check_paths+ is true.
-    #                   Defaults to the +:views+ directory.
-    # :cache :: nil/false to disallow template caching completely.
+    # :allowed_paths :: Set the template paths to allow.  Attempts to render paths outside
+    #                   of this directory will raise an error.  Defaults to the +:views+ directory.
+    # :cache :: nil/false to disable template caching by default.  By default, caching
+    #           is disabled by default if RACK_ENV is development.
     # :cache_class :: A class to use as the template cache instead of the default.
-    # :check_paths :: Check template paths start with one of the entries in +:allowed_paths+,
-    #                 and raise a RodaError if the path doesn't.
+    # :check_paths :: Can be set to false to turn off template path checking.
     # :engine :: The tilt engine to use for rendering, also the default file extension for
     #            templates, defaults to 'erb'.
-    # :escape :: Use Roda's Erubis escaping support, which makes <tt><%= %></tt> escape output,
-    #            <tt><%== %></tt> not escape output, and handles postfix conditions inside
-    #            <tt><%= %></tt> tags.  Can have a value of :erubi to use Erubi escaping support.
-    # :explicit_cache :: Only use the template cache if the :cache option is provided when rendering
-    #                    (useful for development). Defaults to true if RACK_ENV is development, allowing explicit
-    #                    caching of specific templates, but not caching by default.
-    # :inherit_cache :: Whether to create a dup of the cache in subclasses.  The default is false, which
-    #                   starts subclasses with an empty cache.
+    # :escape :: Use Erubi as the ERB template engine, and enable escaping by default,
+    #            which makes <tt><%= %></tt> escape output and  <tt><%== %></tt> not escape output.
     # :layout :: The base name of the layout file, defaults to 'layout'.  This can be provided as a hash
     #            with the :template or :inline options.
     # :layout_opts :: The options to use when rendering the layout, if different from the default options.
     # :template_opts :: The tilt options used when rendering all templates. defaults to:
-    #                   <tt>{:outvar=>'@_out_buf', :default_encoding=>Encoding.default_external}</tt>.
+    #                   <tt>{outvar: '@_out_buf', default_encoding: Encoding.default_external}</tt>.
     # :engine_opts :: The tilt options to use per template engine.  Keys are
     #                 engine strings, values are hashes of template options.
     # :views :: The directory holding the view files, defaults to the 'views' subdirectory of the
@@ -77,8 +71,8 @@ class Roda
     # Most of these options can be overridden at runtime by passing options
     # to the +view+ or +render+ methods:
     #
-    #   view('foo', :engine=>'html.erb')
-    #   render('foo', :views=>'admin_views')
+    #   view('foo', engine: 'html.erb')
+    #   render('foo', views: 'admin_views')
     #
     # There are additional options to +view+ and +render+ that are
     # available at runtime:
@@ -108,10 +102,10 @@ class Roda
     # :template_class :: Provides the template class to use, inside of using
     #                    Tilt or <tt>Tilt[:engine]</tt>.
     #
-    # Here's how those options are used:
+    # Here's an example of using these options:
     #
-    #   view(:inline=>'<%= @foo %>')
-    #   render(:path=>'/path/to/template.erb')
+    #   view(inline: '<%= @foo %>')
+    #   render(path: '/path/to/template.erb')
     #
     # If you pass a hash as the first argument to +view+ or +render+, it should
     # have either +:template+, +:inline+, +:path+, or +:content+ (for +view+) as
@@ -128,7 +122,7 @@ class Roda
     # path never uses more than one template, you can use the +view_options+ plugin
     # and do:
     #
-    #   set_view_options :cache_key=>r.path_info
+    #   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+
@@ -138,18 +132,8 @@ class Roda
     # rendering faster by specifying +:cache_key+ inside the +:layout_opts+
     # plugin option.
     module Render
-      OPTS={}.freeze
-      RodaPlugins.deprecate_constant(self, :OPTS)
-
-      # RODA3: Remove
-      def self.load_dependencies(app, opts=RodaPlugins::OPTS)
-        if opts[:escape] && opts[:escape] != :erubi
-          app.plugin :_erubis_escaping
-        end
-      end
-
       # Setup default rendering options.  See Render for details.
-      def self.configure(app, opts=RodaPlugins::OPTS)
+      def self.configure(app, opts=OPTS)
         if app.opts[:render]
           orig_cache = app.opts[:render][:cache]
           opts = app.opts[:render][:orig_opts].merge(opts)
@@ -158,49 +142,27 @@ class Roda
         app.opts[:render][:orig_opts] = opts
 
         opts = app.opts[:render]
-        if opts[:ext] && !opts[:engine]
-          RodaPlugins.warn "The :ext render plugin option is deprecated and will be removed in Roda 3.  Switch to using the :engine option."
-        end
-        opts[:engine] = (opts[:engine] || opts[:ext] || "erb").dup.freeze
+        opts[:engine] = (opts[:engine] || "erb").dup.freeze
         opts[:views] = app.expand_path(opts[:views]||"views").freeze
         opts[:allowed_paths] ||= [opts[:views]].freeze
         opts[:allowed_paths] = opts[:allowed_paths].map{|f| app.expand_path(f, nil)}.uniq.freeze
+        opts[:check_paths] = true unless opts.has_key?(:check_paths)
 
-        if opts.fetch(:cache, true)
-          if orig_cache
-            opts[:cache] = orig_cache
-          elsif cache_class = opts[:cache_class]
-            opts[:cache] = cache_class.new
+        unless opts.has_key?(:explicit_cache)
+          opts[:explicit_cache] = if opts.fetch(:cache, true)
+            ENV['RACK_ENV'] == 'development'
           else
-            opts[:cache] = app.thread_safe_cache
+            true
           end
         end
 
-        opts[:explicit_cache] = ENV['RACK_ENV'] == 'development' unless opts.has_key?(:explicit_cache)
+        opts[:cache] = orig_cache || (opts[:cache_class] || RodaCache).new
 
         opts[:layout_opts] = (opts[:layout_opts] || {}).dup
+        opts[:layout_opts][:_is_layout] = true
         if opts[:layout_opts][:views]
           opts[:layout_opts][:views] = app.expand_path(opts[:layout_opts][:views]).freeze
         end
-        # RODA3: Remove
-        opts[:layout_opts][:_is_layout] = true
-
-        if opts[:locals]
-          RodaPlugins.warn "The :locals render plugin option is deprecated and will be removed in Roda 3. Locals should now be specified on a per-call basis, or you can use the render_locals plugin."
-        end
-
-        if opts[:layout_opts][:locals]
-          RodaPlugins.warn "The :layout_opts=>:locals render plugin option is deprecated and will be removed in Roda 3. Locals should now be specified on a per-call basis, or you can use the render_locals plugin."
-        end
-
-        if opts[:layout_opts][:merge_locals]
-          RodaPlugins.warn "The :layout_opts=>:merge_locals render plugin option is deprecated and will be removed in Roda 3. You can use the render_locals plugin for merging locals."
-        end
-
-        # RODA3: Remove
-        if opts[:layout_opts][:merge_locals] && opts[:locals]
-          opts[:layout_opts][:locals] = opts[:locals].merge(opts[:layout_opts][:locals] || {})
-        end
 
         if layout = opts.fetch(:layout, true)
           opts[:layout] = true unless opts.has_key?(:layout)
@@ -218,21 +180,13 @@ class Roda
 
         template_opts = opts[:template_opts] = (opts[:template_opts] || {}).dup
         template_opts[:outvar] ||= '@_out_buf'
-        if RUBY_VERSION >= "1.9" && !template_opts.has_key?(:default_encoding)
+        unless template_opts.has_key?(:default_encoding)
           template_opts[:default_encoding] = Encoding.default_external
         end
-        # RODA3: Make :escape assume erubi, remove erubis support
-        if opts[:escape] == :erubi
+
+        if opts[:escape]
           require 'tilt/erubi'
           template_opts[:escape] = true
-        elsif opts[:escape]
-          template_opts[:engine_class] = ErubisEscaping::Eruby
-
-          opts[:escaper] ||= if opts[:escape_safe_classes]
-            ErubisEscaping::UnsafeClassEscaper.new(opts[:escape_safe_classes])
-          else
-            ::Erubis::XmlHelper
-          end
         end
         template_opts.freeze
 
@@ -252,17 +206,7 @@ class Roda
         def inherited(subclass)
           super
           opts = subclass.opts[:render] = subclass.opts[:render].dup
-
-          if opts[:cache]
-            opts[:cache] = if opts[:inherit_cache]
-              opts[:cache] = opts[:cache].dup
-            elsif cache_class = opts[:cache_class]
-              opts[:cache] = cache_class.new
-            else
-              opts[:cache] = thread_safe_cache
-            end
-          end
-
+          opts[:cache] = opts[:cache].dup
           opts.freeze
         end
 
@@ -274,14 +218,12 @@ class Roda
 
       module InstanceMethods
         # Render the given template. See Render for details.
-        def render(template, opts = RodaPlugins::OPTS, &block)
+        def render(template, opts = OPTS, &block)
           opts = render_template_opts(template, opts)
-          retrieve_template(opts).render((opts[:scope]||self), (opts[:locals]||RodaPlugins::OPTS), &block)
+          retrieve_template(opts).render((opts[:scope]||self), (opts[:locals]||OPTS), &block)
         end
 
-        # Return the render options for the instance's class. While this
-        # is not currently frozen, it may be frozen in a future version,
-        # so you should not attempt to modify it.
+        # Return the render options for the instance's class.
         def render_opts
           self.class.render_opts
         end
@@ -289,7 +231,7 @@ 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=RodaPlugins::OPTS)
+        def view(template, opts=OPTS)
           opts = parse_template_opts(template, opts)
           content = opts[:content] || render_template(opts)
 
@@ -304,12 +246,7 @@ class Roda
 
         # Convert template options to single hash when rendering templates using render.
         def render_template_opts(template, opts)
-          opts = parse_template_opts(template, opts)
-
-          # RODA3: Remove
-          merge_render_locals(opts) if render_plugin_handle_locals?
-
-          opts
+          parse_template_opts(template, opts)
         end
 
         # Private alias for render.  Should be used by other plugins when they want to render a template
@@ -319,7 +256,8 @@ class Roda
         # If caching templates, attempt to retrieve the template from the cache.  Otherwise, just yield
         # to get the template.
         def cached_template(opts, &block)
-          if (!render_opts[:explicit_cache] || opts[:cache]) && (cache = render_opts[:cache]) && (key = opts[:cache_key])
+          if (!render_opts[:explicit_cache] || opts[:cache]) && (key = opts[:cache_key])
+            cache = render_opts[:cache]
             unless template = cache[key]
               template = cache[key] = yield
             end
@@ -333,10 +271,7 @@ class Roda
         # template block, and locals to use for the render in the passed options.
         def find_template(opts)
           render_opts = render_opts()
-          if opts[:ext] && !opts[:engine]
-            RodaPlugins.warn "The :ext render plugin option is deprecated and will be removed in Roda 3.  Switch to using the :engine option."
-          end
-          engine_override = opts[:engine] ||= opts[:ext]
+          engine_override = opts[:engine]
           engine = opts[:engine] ||= render_opts[:engine]
           if content = opts[:inline]
             path = opts[:path] = content
@@ -349,41 +284,26 @@ class Roda
             opts[:template_class] ||= ::Tilt
           end
 
-          if render_opts[:cache]
-            if (cache = opts[:cache]).nil?
-              cache = content || !opts[:template_block]
-            end
+          if (cache = opts[:cache]).nil?
+            cache = content || !opts[:template_block]
+          end
 
-            if cache
-              template_block = opts[:template_block] unless content
-              template_opts = opts[:template_opts]
+          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
-              end
+            opts[:cache_key] ||= if template_class || engine_override || template_opts || template_block
+              [path, template_class, engine_override, template_opts, template_block]
             else
-              opts.delete(:cache_key)
+              path
             end
-          elsif opts[:cache]
-            RodaPlugins.warn ":cache render/view method option used when caching explicitly disabled via :cache=>nil/false plugin option.  Caching this template will be skipped for backwards compatibility.  Starting in Roda 3, the :cache render/view method option will force caching even if the plugin defaults to not caching."
+          else
+            opts.delete(:cache_key)
           end
 
           opts
         end
 
-        # RODA3: Remove
-        def merge_render_locals(opts)
-          if !opts[:_is_layout] && (r_locals = render_opts[:locals])
-            opts[:locals] = if locals = opts[:locals]
-              Hash[r_locals].merge!(locals)
-            else
-              r_locals
-            end
-          end
-        end
-
         # Return a single hash combining the template and opts arguments.
         def parse_template_opts(template, opts)
           opts = Hash[opts]
@@ -427,24 +347,15 @@ class Roda
         # The template path for the given options.
         def template_path(opts)
           path = "#{opts[:views]}/#{template_name(opts)}.#{opts[:engine]}"
-          full_path = self.class.expand_path(path)
           if opts.fetch(:check_paths){render_opts[:check_paths]}
+            full_path = self.class.expand_path(path)
             unless render_opts[:allowed_paths].any?{|f| full_path.start_with?(f)}
               raise RodaError, "attempt to render path not in allowed_paths: #{full_path} (allowed: #{render_opts[:allowed_paths].join(', ')})"
             end
-          elsif !opts.has_key?(:check_paths) && !render_opts.has_key?(:check_paths)
-            unless render_opts[:allowed_paths].any?{|f| full_path.start_with?(f)}
-              RodaPlugins.warn "The :check_paths render/view method option and :check_paths render plugin option were not specified, and the path used for the template (#{full_path.inspect}) is not in the allowed paths (#{render_opts[:allowed_paths].inspect}).  Allowing the template render anyway for backwards compatibility, but an error will be raised starting in Roda 3.  Specify the :allowed_paths render plugin option to include the path, or use the :check_paths=>false render plugin option to explicitly disable path checking."
-            end
           end
           path
         end
 
-        # RODA3: Remove
-        def render_plugin_handle_locals?
-          true
-        end
-
         # If a layout should be used, return a hash of options for
         # rendering the layout template.  If a layout should not be
         # used, return nil.
@@ -452,41 +363,9 @@ class Roda
           if layout = opts.fetch(:layout, render_opts[:layout])
             layout_opts = render_layout_opts
 
-            # RODA3: Remove
-            merge_locals = layout_opts[:merge_locals]
-
             method_layout_opts = opts[:layout_opts]
-
-            # RODA3: Remove
-            if render_plugin_handle_locals?
-              if method_layout_opts
-                method_layout_locals = method_layout_opts[:locals]
-                if method_layout_opts.has_key?(:merge_locals)
-                  RodaPlugins.warn "The :layout_opts=>:merge_locals view option is deprecated and will be removed in Roda 3. You can use the render_locals plugin for merging locals."
-                  merge_locals = method_layout_opts[:merge_locals]
-                end
-              end
-
-              locals = {}
-              if merge_locals && (plugin_locals = render_opts[:locals])
-                locals.merge!(plugin_locals)
-              end
-              if layout_locals = layout_opts[:locals]
-                locals.merge!(layout_locals)
-              end
-              if merge_locals && (method_locals = opts[:locals])
-                locals.merge!(method_locals)
-              end
-              if method_layout_locals
-                locals.merge!(method_layout_locals)
-              end
-            end
-
             layout_opts.merge!(method_layout_opts) if method_layout_opts
 
-            # RODA3: Remove
-            layout_opts[:locals] = locals if render_plugin_handle_locals? && !locals.empty?
-
             case layout
             when Hash
               layout_opts.merge!(layout)