roda 3.28.0 → 3.33.0

data/lib/roda/plugins/hash_matcher.rb

@@ -8,7 +8,7 @@ class Roda
     #
     #   class App < Roda
     #     hash_matcher(:foo) do |v|
-    #       self['foo'] == v
+    #       params['foo'] == v
     #     end
     #
     #     route do

data/lib/roda/plugins/header_matchers.rb

@@ -51,7 +51,11 @@ class Roda
 
         # Match if the given uppercase key is present inside the environment.
         def match_header(key)
-          if v = @env["HTTP_#{key.upcase.tr("-","_")}"]
+          key = key.upcase.tr("-","_")
+          unless key == "CONTENT_TYPE" || key == "CONTENT_LENGTH"
+            key = "HTTP_#{key}"
+          end
+          if v = @env[key]
             @captures << v
           end
         end

data/lib/roda/plugins/indifferent_params.rb

@@ -42,6 +42,8 @@ class Roda
       INDIFFERENT_PROC = lambda{|h,k| h[k.to_s] if k.is_a?(Symbol)}
 
       if Rack.release > '2'
+        require 'rack/query_parser'
+
         class QueryParser < Rack::QueryParser
           # Work around for invalid optimization in rack
           def parse_nested_query(qs, d=nil)
@@ -62,6 +64,8 @@ class Roda
         module RequestMethods
           QUERY_PARSER = Rack::Utils.default_query_parser = QueryParser.new(QueryParser::Params, 65536, 100)
 
+          private
+
           def query_parser
             QUERY_PARSER
           end

data/lib/roda/plugins/partials.rb

@@ -18,27 +18,54 @@ class Roda
     #   render('_test')
     #   render('dir/_test')
     #
-    # Note that this plugin automatically loads the :render plugin.
+    # To render the same template once for each object in an enumerable,
+    # you can use the +render_partials+ method:
+    #
+    #   each_partial([1,2,3], :foo) # uses _foo.erb
+    #
+    # This is basically equivalent to:
+    #
+    #   render_each([1,2,3], "_foo", local: :foo)
+    #
+    # This plugin depends on the render and render_each plugins.
     module Partials
-      # Depend on the render plugin, since this overrides
-      # some of its methods.
+      # Depend on the render plugin, passing received options to it.
+      # Also depend on the render_each plugin.
       def self.load_dependencies(app, opts=OPTS)
         app.plugin :render, opts
+        app.plugin :render_each
       end
 
       module InstanceMethods
+        # For each object in the given enumerable, render the given
+        # template (prefixing the template filename with an underscore).
+        def each_partial(enum, template, opts=OPTS)
+          unless opts.has_key?(:local)
+            opts = Hash[opts]
+            opts[:local] = render_each_default_local(template)
+          end
+          render_each(enum, partial_template_name(template.to_s), opts)
+        end
+
         # Renders the given template without a layout, but
         # prefixes the template filename to use with an 
         # underscore.
         def partial(template, opts=OPTS)
           opts = parse_template_opts(template, opts)
           if opts[:template]
-            template = opts[:template].split('/')
-            template[-1] = "_#{template[-1]}"
-            opts[:template] = template.join('/')
+            opts[:template] = partial_template_name(opts[:template])
           end
           render_template(opts)
         end
+
+        private
+
+        # Prefix the template base filename with an underscore.
+        def partial_template_name(template)
+          segments = template.split('/')
+          segments[-1] = "_#{segments[-1]}"
+          segments.join('/')
+        end
       end
     end
 

data/lib/roda/plugins/path.rb

@@ -10,7 +10,8 @@ class Roda
     #
     # Additionally, you can call the +path+ class method with a class and a block, and it will register
     # the class.  You can then call the +path+ instance method with an instance of that class, and it will
-    # execute the block in the context of the route block scope with the arguments provided to path.
+    # execute the block in the context of the route block scope with the arguments provided to path. You
+    # can call the +url+ instance method with the same arguments as the +path+ method to get the full URL.
     #
     # Example:
     #
@@ -46,21 +47,23 @@ class Roda
     #
     #     r.post 'quux' do
     #       bar = Quux[1]
-    #       r.redirect path(quux, '/bar') # /quux/1/bar
+    #       r.redirect url(quux, '/bar') # http://example.com/quux/1/bar
     #     end
     #   end
     #
-    # The path method accepts the following options when not called with a class:
+    # The path class method accepts the following options when not called with a class:
     #
     # :add_script_name :: Prefix the path generated with SCRIPT_NAME. This defaults to the app's
     #                     :add_script_name option.
     # :name :: Provide a different name for the method, instead of using <tt>*_path</tt>.
+    # :relative :: Generate paths relative to the current request instead of absolute paths by prepending
+    #              an appropriate prefix.  This implies :add_script_name.
     # :url :: Create a url method in addition to the path method, which will prefix the string generated
     #         with the appropriate scheme, host, and port.  If true, creates a <tt>*_url</tt>
     #         method.  If a Symbol or String, uses the value as the url method name.
     # :url_only :: Do not create a path method, just a url method.
     #
-    # Note that if :add_script_name, :url, or :url_only is used, the path method will also create a
+    # Note that if :add_script_name, :relative, :url, or :url_only is used, the path method will also create a
     # <tt>_*_path</tt> private method.
     module Path
       DEFAULT_PORTS = {'http' => 80, 'https' => 443}.freeze
@@ -121,16 +124,31 @@ class Roda
 
           meth = opts[:name] || "#{name}_path"
           url = opts[:url]
+          url_only = opts[:url_only]
+          relative = opts[:relative]
           add_script_name = opts.fetch(:add_script_name, self.opts[:add_script_name])
 
-          if add_script_name || url || opts[:url_only]
+          if relative
+            if (url || url_only)
+              raise RodaError,  "cannot provide :url or :url_only option if using :relative option"
+            end
+            add_script_name = true
+            plugin :relative_path
+          end
+
+          if add_script_name || url || url_only || relative
             _meth = "_#{meth}"
             define_method(_meth, &block)
             private _meth
           end
 
-          unless opts[:url_only]
-            if add_script_name
+          unless url_only
+            if relative
+              define_method(meth) do |*a, &blk|
+                # Allow calling private _method to get path
+                relative_path(request.script_name.to_s + send(_meth, *a, &blk))
+              end
+            elsif add_script_name
               define_method(meth) do |*a, &blk|
                 # Allow calling private _method to get path
                 request.script_name.to_s + send(_meth, *a, &blk)
@@ -140,7 +158,7 @@ class Roda
             end
           end
 
-          if url || opts[:url_only]
+          if url || url_only
             url_meth = if url.is_a?(String) || url.is_a?(Symbol)
               url
             else
@@ -148,14 +166,8 @@ class Roda
             end
 
             url_block = lambda do |*a, &blk|
-              r = request
-              scheme = r.scheme
-              port = r.port
-              uri = ["#{scheme}://#{r.host}#{":#{port}" unless DEFAULT_PORTS[scheme] == port}"]
-              uri << request.script_name.to_s if add_script_name
               # Allow calling private _method to get path
-              uri << send(_meth, *a, &blk)
-              File.join(uri)
+              "#{_base_url}#{request.script_name if add_script_name}#{send(_meth, *a, &blk)}"
             end
 
             define_method(url_meth, &url_block)
@@ -190,6 +202,21 @@ class Roda
           path = request.script_name.to_s + path if opts[:add_script_name]
           path
         end
+
+        # Similar to #path, but returns a complete URL.
+        def url(*args, &block)
+          "#{_base_url}#{path(*args, &block)}"
+        end
+
+        private
+
+        # The string to prepend to the path to make the path a URL.
+        def _base_url
+          r = @_request
+          scheme = r.scheme
+          port = r.port
+          "#{scheme}://#{r.host}#{":#{port}" unless DEFAULT_PORTS[scheme] == port}"
+        end
       end
     end
 

data/lib/roda/plugins/placeholder_string_matchers.rb

@@ -27,6 +27,8 @@ class Roda
       end
 
       module RequestMethods
+        private
+
         def _match_string(str)
           if str.index(":")
             consume(self.class.cached_matcher(str){Regexp.escape(str).gsub(/:(\w+)/){|m| _match_symbol_regexp($1)}})

data/lib/roda/plugins/public.rb

@@ -42,6 +42,8 @@ class Roda
       # :default_mime :: The default mime type to use if the mime type is not recognized.
       # :gzip :: Whether to serve already gzipped files with a .gz extension for clients
       #          supporting gzipped transfer encoding.
+      # :brotli :: Whether to serve already brotli-compressed files with a .br extension
+      #            for clients supporting brotli transfer encoding.
       # :headers :: A hash of headers to use for statically served files
       # :root :: Use this option for the root of the public directory (default: "public")
       def self.configure(app, opts={})
@@ -52,6 +54,7 @@ class Roda
         end
         app.opts[:public_server] = ::Rack::File.new(app.opts[:public_root], opts[:headers]||{}, opts[:default_mime] || 'text/plain')
         app.opts[:public_gzip] = opts[:gzip]
+        app.opts[:public_brotli] = opts[:brotli]
       end
 
       module RequestMethods
@@ -65,23 +68,8 @@ class Roda
             server = roda_opts[:public_server]
             path = ::File.join(server.root, *public_path_segments(path))
 
-            if roda_opts[:public_gzip] && env['HTTP_ACCEPT_ENCODING'] =~ /\bgzip\b/
-              gzip_path = path + '.gz'
-
-              if public_file_readable?(gzip_path)
-                res = public_serve(server, gzip_path)
-                headers = res[1]
-
-                unless res[0] == 304
-                  if mime_type = ::Rack::Mime.mime_type(::File.extname(path), 'text/plain')
-                    headers['Content-Type'] = mime_type
-                  end
-                  headers['Content-Encoding'] = 'gzip'
-                end
-
-                halt res
-              end
-            end
+            public_serve_compressed(server, path, '.br', 'br') if roda_opts[:public_brotli]
+            public_serve_compressed(server, path, '.gz', 'gzip') if roda_opts[:public_gzip]
 
             if public_file_readable?(path)
               halt public_serve(server, path)
@@ -113,6 +101,26 @@ class Roda
           # :nocov:
         end
 
+        def public_serve_compressed(server, path, suffix, encoding)
+          if env['HTTP_ACCEPT_ENCODING'] =~ /\b#{encoding}\b/
+            compressed_path = path + suffix
+
+            if public_file_readable?(compressed_path)
+              res = public_serve(server, compressed_path)
+              headers = res[1]
+
+              unless res[0] == 304
+                if mime_type = ::Rack::Mime.mime_type(::File.extname(path), 'text/plain')
+                  headers['Content-Type'] = mime_type
+                end
+                headers['Content-Encoding'] = encoding
+              end
+
+              halt res
+            end
+          end
+        end
+
         if ::Rack.release > '2'
           # Serve the given path using the given Rack::File server.
           def public_serve(server, path)

data/lib/roda/plugins/relative_path.rb

@@ -0,0 +1,73 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The relative_path plugin adds a relative_path method that accepts
+    # an absolute path and returns a path relative to the current request
+    # by adding an appropriate prefix:
+    #
+    #   plugin :relative_path
+    #   route do |r|
+    #     relative_path("/foo")
+    #   end
+    #
+    #   # GET /
+    #   "./foo"
+    #
+    #   # GET /bar
+    #   "./foo"
+    #
+    #   # GET /bar/
+    #   "../foo"
+    #
+    #   # GET /bar/baz/quux
+    #   "../../foo"
+    #
+    # It also offers a relative_prefix method that returns a string that can
+    # be prepended to an absolute path.  This can be more efficient if you
+    # need to convert multiple paths.
+    #
+    # This plugin is mostly designed for applications using Roda as a static
+    # site generator, where the generated site can be hosted at any subpath.
+    module RelativePath
+      module InstanceMethods
+        # Return a relative path for the absolute path based on the current path
+        # of the request by adding the appropriate prefix.
+        def relative_path(absolute_path)
+          relative_prefix + absolute_path
+        end
+
+        # Return a relative prefix to append to an absolute path to a relative path
+        # based on the current path of the request.
+        def relative_prefix
+          env = @_request.env
+          script_name = env["SCRIPT_NAME"]
+          path_info = env["PATH_INFO"]
+
+          # Check path begins with slash.  All valid paths should, but in case this
+          # request is bad, just skip using a relative prefix.
+          case script_name.getbyte(0)
+          when nil # SCRIPT_NAME empty
+            unless path_info.getbyte(0) == 47 # PATH_INFO starts with /
+              return ''
+            end
+          when 47 # SCRIPT_NAME starts with /
+            # nothing
+          else
+            return ''
+          end
+
+          slash_count = script_name.count('/') + path_info.count('/')
+          if slash_count > 1
+            ("../" * (slash_count - 2)) << ".."
+          else
+            "."
+          end
+        end
+      end
+    end
+
+    register_plugin(:relative_path, RelativePath)
+  end
+end

data/lib/roda/plugins/render.rb

@@ -241,12 +241,13 @@ class Roda
       # template file has been modified.  This is an internal class and
       # the API is subject to change at any time.
       class TemplateMtimeWrapper
-        def initialize(template_class, path, *template_args)
+        def initialize(template_class, path, dependencies, *template_args)
           @template_class = template_class
           @path = path
           @template_args = template_args
+          @dependencies = ([path] + Array(dependencies)) if dependencies
 
-          @mtime = (File.mtime(path) if File.file?(path))
+          @mtime = template_last_modified if File.file?(path)
           @template = template_class.new(path, *template_args)
         end
 
@@ -257,17 +258,28 @@ class Roda
           @template.render(*args, &block)
         end
 
+        # Return when the template was last modified.  If the template depends on any
+        # other files, check the modification times of all dependencies and
+        # return the maximum.
+        def template_last_modified
+          if deps = @dependencies
+            deps.map{|f| File.mtime(f)}.max
+          else
+            File.mtime(@path)
+          end
+        end
+
         # If the template file has been updated, return true and update
         # the template object and the modification time. Other return false.
         def modified?
           begin
-            mtime = File.mtime(path = @path)
+            mtime = template_last_modified
           rescue
             # ignore errors
           else
             if mtime != @mtime
               @mtime = mtime
-              @template = @template_class.new(path, *@template_args)
+              @template = @template_class.new(@path, *@template_args)
               return true
             end
           end
@@ -576,7 +588,7 @@ class Roda
                !opts[:inline]
 
             if render_opts[:check_template_mtime] && !opts[:template_block] && !cache
-              template = TemplateMtimeWrapper.new(opts[:template_class], opts[:path], 1, template_opts)
+              template = TemplateMtimeWrapper.new(opts[:template_class], opts[:path], opts[:dependencies], 1, template_opts)
 
               if define_compiled_method
                 method_name = :"_roda_template_#{self.class.object_id}_#{method_cache_key}"

data/lib/roda/plugins/render_each.rb

@@ -26,7 +26,9 @@ class Roda
     #
     # Will render the +foo+ template, but the local variable used inside
     # the template will be +bar+.  You can use <tt>local: nil</tt> to
-    # not set a local variable inside the template.
+    # not set a local variable inside the template. By default, the
+    # local variable name is based on the template name, with any
+    # directories and file extensions removed.
     module RenderEach
       # Load the render plugin before this plugin, since this plugin
       # calls the render method.
@@ -45,11 +47,11 @@ 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
-            return _optimized_render_each(enum, optimized_template, template.to_s.to_sym, {})
+            return _optimized_render_each(enum, optimized_template, render_each_default_local(template), {})
           elsif opts.has_key?(:local)
             as = opts[:local]
           else
-            as = template.to_s.to_sym
+            as = render_each_default_local(template)
             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
@@ -77,6 +79,12 @@ class Roda
         
         private
 
+        # The default local variable name to use for the template, if the :local option
+        # is not used when calling render_each.
+        def render_each_default_local(template)
+          File.basename(template.to_s).sub(/\..+\z/, '').to_sym
+        end
+
         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