roda 2.28.0 → 2.29.0

data/lib/roda/plugins/path_rewriter.rb

@@ -46,7 +46,7 @@ class Roda
     # processed before remaining_path rewrites.
     module PathRewriter
       OPTS={}.freeze
-
+      RodaPlugins.deprecate_constant(self, :OPTS)
       PATH_INFO = 'PATH_INFO'.freeze
       RodaPlugins.deprecate_constant(self, :PATH_INFO)
 
@@ -67,7 +67,7 @@ class Roda
 
         # Record a path rewrite from path +was+ to path +is+.  Options:
         # :path_info :: Modify PATH_INFO, not just remaining path.
-        def rewrite_path(was, is = nil, opts=OPTS, &block)
+        def rewrite_path(was, is = nil, opts=RodaPlugins::OPTS, &block)
           if is.is_a? Hash
             raise RodaError, "cannot provide two hashes to rewrite_path" unless opts.empty?
             opts = is

data/lib/roda/plugins/per_thread_caching.rb

@@ -3,6 +3,8 @@
 #
 class Roda
   module RodaPlugins
+    warn "The per_thread_caching plugin is deprecated and will be removed in Roda 3.  Consider maintaining the plugin as a separate gem if you would like to keep using it."
+
     # The per_thread_caching plugin changes the default cache
     # from being a shared thread safe cache to a separate cache per
     # thread.  This means getting or setting values no longer

data/lib/roda/plugins/placeholder_string_matchers.rb

@@ -0,0 +1,42 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The placeholder_string_matcher plugin exists for backwards compatibility
+    # with previous versions of Roda that allowed placeholders inside strings
+    # if they were prefixed by colons:
+    #
+    #   plugin :placeholder_string_matchers
+    #
+    #   route do |r|
+    #     r.is("foo/:bar") |v|
+    #       # matches foo/baz, yielding "baz"
+    #       # does not match foo, foo/, or foo/baz/
+    #     end
+    #   end
+    #
+    # It is not recommended to use this in new applications, and it is encouraged
+    # to use separate symbol or string class matchers instead:
+    #
+    #   r.is "foo", String
+    #   r.is "foo", :bar 
+    module PlaceholderStringMatchers
+      def self.load_dependencies(app)
+        app.plugin :_symbol_regexp_matchers
+      end
+
+      module RequestMethods
+        def _match_string(str)
+          if str.index(":")
+            consume(self.class.cached_matcher(str){Regexp.escape(str).gsub(/:(\w+)/){|m| _match_symbol_regexp($1)}})
+          else
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin(:placeholder_string_matchers, PlaceholderStringMatchers)
+  end
+end

data/lib/roda/plugins/precompile_templates.rb

@@ -47,10 +47,11 @@ class Roda
     #   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=OPTS)
+      def self.load_dependencies(app, opts=RodaPlugins::OPTS)
         app.plugin :render
         app.opts[:precompile_templates_sort] = opts.fetch(:sort_locals, Tilt::VERSION > '2.0.1')
       end
@@ -58,7 +59,7 @@ class Roda
       module ClassMethods
         # Precompile the templates using the given options.  See PrecompileTemplates
         # for details.
-        def precompile_templates(pattern, opts=OPTS)
+        def precompile_templates(pattern, opts=RodaPlugins::OPTS)
           if pattern.is_a?(Hash)
             opts = pattern.merge(opts)
           end

data/lib/roda/plugins/render.rb

@@ -57,11 +57,6 @@ class Roda
     # :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.
-    # :escape_safe_classes :: String subclasses that should not be HTML escaped when used in
-    #                         <tt><%= %></tt> tags, when :escape=>true is used. Can be an array for multiple classes.
-    # :escaper :: Object used for escaping output of <tt><%= %></tt>, when :escape=>true is used,
-    #             overriding the default.  If given, object should respond to +escape_xml+ with
-    #             a single argument and return an output string.
     # :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.
@@ -69,10 +64,7 @@ class Roda
     #                   starts subclasses with an empty cache.
     # :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.  To pass local variables to the layout, include a :locals
-    #                 option inside :layout_opts.  To automatically merge the view template locals into
-    #                 the layout template locals, include a :merge_locals option inside :layout_opts.
+    # :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>.
     # :engine_opts :: The tilt options to use per template engine.  Keys are
@@ -147,15 +139,17 @@ class Roda
     # plugin option.
     module Render
       OPTS={}.freeze
+      RodaPlugins.deprecate_constant(self, :OPTS)
 
-      def self.load_dependencies(app, opts=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=OPTS)
+      def self.configure(app, opts=RodaPlugins::OPTS)
         if app.opts[:render]
           orig_cache = app.opts[:render][:cache]
           opts = app.opts[:render][:orig_opts].merge(opts)
@@ -164,6 +158,9 @@ 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[:views] = app.expand_path(opts[:views]||"views").freeze
         opts[:allowed_paths] ||= [opts[:views]].freeze
@@ -182,8 +179,25 @@ class Roda
         opts[:explicit_cache] = ENV['RACK_ENV'] == 'development' unless opts.has_key?(:explicit_cache)
 
         opts[:layout_opts] = (opts[:layout_opts] || {}).dup
+        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
@@ -207,6 +221,7 @@ class Roda
         if RUBY_VERSION >= "1.9" && !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
           require 'tilt/erubi'
           template_opts[:escape] = true
@@ -259,10 +274,9 @@ class Roda
 
       module InstanceMethods
         # Render the given template. See Render for details.
-        def render(template, opts = OPTS, &block)
-          opts = parse_template_opts(template, opts)
-          merge_render_locals(opts)
-          retrieve_template(opts).render((opts[:scope]||self), (opts[:locals]||OPTS), &block)
+        def render(template, opts = RodaPlugins::OPTS, &block)
+          opts = render_template_opts(template, opts)
+          retrieve_template(opts).render((opts[:scope]||self), (opts[:locals]||RodaPlugins::OPTS), &block)
         end
 
         # Return the render options for the instance's class. While this
@@ -275,7 +289,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=OPTS)
+        def view(template, opts=RodaPlugins::OPTS)
           opts = parse_template_opts(template, opts)
           content = opts[:content] || render_template(opts)
 
@@ -288,6 +302,16 @@ class Roda
 
         private
 
+        # 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
+        end
+
         # Private alias for render.  Should be used by other plugins when they want to render a template
         # without a layout, as plugins can override render to use a layout.
         alias render_template render
@@ -309,6 +333,9 @@ 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 = opts[:engine] ||= render_opts[:engine]
           if content = opts[:inline]
@@ -339,12 +366,14 @@ class Roda
             else
               opts.delete(:cache_key)
             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."
           end
 
           opts
         end
 
-        # Merge any :locals specified in the render_opts into the :locals option given.
+        # RODA3: Remove
         def merge_render_locals(opts)
           if !opts[:_is_layout] && (r_locals = render_opts[:locals])
             opts[:locals] = if locals = opts[:locals]
@@ -398,45 +427,65 @@ 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: #{path} (allowed: #{render_opts[:allowed_paths].join(', ')})"
+              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.
         def view_layout_opts(opts)
           if layout = opts.fetch(:layout, render_opts[:layout])
-
             layout_opts = render_layout_opts
+
+            # RODA3: Remove
             merge_locals = layout_opts[:merge_locals]
 
-            if method_layout_opts = opts[:layout_opts]
-              method_layout_locals = method_layout_opts[:locals]
-              merge_locals = method_layout_opts[:merge_locals] if method_layout_opts.has_key?(:merge_locals)
-            end
+            method_layout_opts = opts[:layout_opts]
 
-            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)
+            # 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
-            layout_opts[:locals] = locals unless locals.empty?
+
+            # RODA3: Remove
+            layout_opts[:locals] = locals if render_plugin_handle_locals? && !locals.empty?
 
             case layout
             when Hash

data/lib/roda/plugins/render_each.rb

@@ -27,6 +27,7 @@ class Roda
     # not set a local variable inside the template.
     module RenderEach
       OPTS = {}.freeze
+      RodaPlugins.deprecate_constant(self, :OPTS)
 
       # Load the render plugin before this plugin, since this plugin
       # calls the render method.
@@ -41,7 +42,7 @@ 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)
+        def render_each(enum, template, opts=RodaPlugins::OPTS)
           if as = opts.has_key?(:local)
             as = opts[:local]
           else

data/lib/roda/plugins/render_locals.rb

@@ -0,0 +1,102 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The render_locals plugin allows setting default locals for rendering templates.
+    #
+    #   plugin :render_locals, :render=>{:heading=>'Hello'}
+    #
+    #   route do |r|
+    #     r.get "foo" do
+    #       view 'foo', :locals=>{:name=>'Foo'} # locals: {:heading=>'Hello', :name=>'Foo'}
+    #     end
+    #
+    #     r.get "bar" do
+    #       view 'foo', :locals=>{:heading=>'Bar'} # locals: {:heading=>'Bar'}
+    #     end
+    #
+    #     view "default" # locals: {:heading=>'Hello'}
+    #   end
+    #
+    # The render_locals plugin accepts the following options:
+    #
+    # render :: The default locals to use for template rendering
+    # layout :: The default locals to use for layout rendering
+    # merge :: Whether to merge template locals into layout locals
+    module RenderLocals
+      OPTS = {}.freeze
+      RodaPlugins.deprecate_constant(self, :OPTS)
+
+      def self.load_dependencies(app, opts=RodaPlugins::OPTS)
+        app.plugin :render
+      end
+
+      def self.configure(app, opts=RodaPlugins::OPTS)
+        app.opts[:render_locals] = (app.opts[:render_locals] || {}).merge(opts[:render]||{}).freeze
+        app.opts[:layout_locals] = (app.opts[:layout_locals] || {}).merge(opts[:layout]||{}).freeze
+        if opts.has_key?(:merge)
+          app.opts[:merge_locals] = opts[:merge]
+          app.opts[:layout_locals] = app.opts[:render_locals].merge(app.opts[:layout_locals]).freeze
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        def render_locals
+          opts[:render_locals]
+        end
+
+        def layout_locals
+          opts[:layout_locals]
+        end
+
+        # RODA3: Remove
+        def render_plugin_handle_locals?
+          false
+        end
+
+        # If this isn't the layout template, then use the plugin's render locals as the default locals.
+        def render_template_opts(template, opts)
+          opts = super
+          return opts if opts[:_is_layout]
+
+          plugin_locals = render_locals
+          if locals = opts[:locals]
+            plugin_locals = Hash[plugin_locals].merge!(locals)
+          end
+          opts[:locals] = plugin_locals
+          opts
+        end
+
+        # If using a layout, then use the plugin's layout locals as the default locals.
+        def view_layout_opts(opts)
+          if layout_opts = super
+            merge_locals = layout_opts.has_key?(:merge_locals) ? layout_opts[:merge_locals] : self.opts[:merge_locals] 
+
+            locals = {}
+            if merge_locals && (plugin_locals = render_locals)
+              locals.merge!(plugin_locals)
+            end
+            if layout_locals = layout_locals()
+              locals.merge!(layout_locals)
+            end
+            if merge_locals && (method_locals = opts[:locals])
+              locals.merge!(method_locals)
+            end
+            if method_layout_locals = layout_opts[:locals]
+              locals.merge!(method_layout_locals)
+            end
+
+            layout_opts[:locals] = locals
+            layout_opts[:_is_layout] = true
+            layout_opts
+          end
+        end
+      end
+    end
+
+    register_plugin(:render_locals, RenderLocals)
+  end
+end