roda 3.30.0 → 3.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40d384d8a60174df9dcfdb645c5bf607232c44012827659d06691561666d2a74
-  data.tar.gz: 7f8cfedfb18a5125be0cbc7bb77cd60b45f2f869717ae163c9779be3bc054264
+  metadata.gz: 370e18bb1d1cfb9fb8b0c10fda1a4f57161a39c6d733b628ddd60058d231f896
+  data.tar.gz: fe0c8ddb499cdbafb0f047d9445fca726f742e38674f90731f3421132c373365
 SHA512:
-  metadata.gz: d5619d3e9ac99a426662057ba932ae8477d251e8252710f9fce7b33ffb5ccaec45673c3b933906d71e45ec1b4be6444467d5d7ad3be04df6123b66e19432ea4f
-  data.tar.gz: 0da11db1409e19bf6a11b5c2f9e88da573b9e00175de4bf753da1fab2d4877a1ef84013a5194d349237fbc362205efccbc03fd0b56ba800fc6e903583baf9cf1
+  metadata.gz: 60db0b47d97ae40437e0396bc795ac360194bd88067e6611cf277888d054e3c41786eb062f4ab31d6683cb4755a3a27d148a576236c77a4d46db67fc2accc7e1
+  data.tar.gz: 44745afaa29ccee2d51a132f7b7be4da6818191814a9ff8a2afd52f34636789cb0e4d22eb63ade49ea0411470a73b05a1996c7bb70cc7edf04264fb2fddadb83

data/CHANGELOG

@@ -1,3 +1,39 @@
+= 3.35.0 (2020-08-14)
+
+* Add r plugin for r method for accessing request, useful when r local variable is not in scope (jeremyevans)
+
+* Warn when loading a plugin with arguments or a block if the plugin does not accept arguments or block (jeremyevans)
+
+= 3.34.0 (2020-07-14)
+
+* Remove unnecessary conditionals (jeremyevans)
+
+* Allow loading the match_affix plugin with a single argument (jeremyevans)
+
+* Do not include pre/post context sections if empty in the exception_page plugin (jeremyevans)
+
+= 3.33.0 (2020-06-16)
+
+* Add :brotli option to public plugin to supplement it to serve brotli-compressed files like :gzip does for gzipped files (hmdne) (#194)
+
+* Add url method to path plugin, similar to path but returning the entire URL (jeremyevans)
+
+= 3.32.0 (2020-05-15)
+
+* Make :dependencies option in assets plugin work correctly with render plugin template caching (jeremyevans) (#191)
+
+* Support render method :dependencies option for specifying which files to check for modification (jgarth, jeremyevans) (#192)
+
+* Add each_partial to the partials plugin for rendering a partial for each element in an enumerable (jeremyevans)
+
+* Make render_each in render_each plugin handle template names with directories and extensions (jeremyevans)
+
+= 3.31.0 (2020-04-15)
+
+* Add :relative option to path method in path plugin, for generating a method returning relative paths (jeremyevans)
+
+* Add relative_path plugin, for turning absolute paths to paths relative to the current request (jeremyevans)
+
 = 3.30.0 (2020-03-13)
 
 * Support :relative_paths assets plugin option to use relative paths for the assets (jeremyevans)

data/README.rdoc

@@ -418,6 +418,10 @@ You can provide an array to specify multiple request methods and match on any of
   {method: :post}             # matches POST
   {method: ['post', 'patch']} # matches POST and PATCH
 
+=== true
+
+If +true+ is given directly as a matcher, it always matches.
+
 === false, nil
 
 If +false+ or +nil+ is given directly as a matcher, it doesn't match anything.

data/doc/conventions.rdoc

@@ -15,6 +15,8 @@ For a small application, the following directory layout is recommended:
   Rakefile
   app_name.rb
   assets/
+  config.ru
+  db.rb
   migrate/
   models.rb
   models/
@@ -25,6 +27,8 @@ For a small application, the following directory layout is recommended:
 +app_name.rb+ should contain the Roda application, and should reflect the name of your application.
 So, if your application is named +FooBar+, you should use +foo_bar.rb+.
 
++config.ru+ should contain the code the webserver uses to determine which application to run.
+
 +views/+ should contain your template files.  This assumes you are using the +render+ plugin
 and server-side rendering.  If you are creating a single page application and just serving
 JSON, then you won't need a +views+ directory.  For small applications, all view files should be
@@ -36,7 +40,11 @@ Again, for pure JSON applications, you won't need a +public+ directory.
 +assets/+ should contain the source files for your CSS and javascript assets.  If you are
 not using the +assets+ plugin, you won't need an +assets+ directory.
 
-+models.rb+ should contain all code related to your database/ORM.  This file should be required
++db.rb+ should contain the minimum code to setup a database connection, without loading any of
+the applications models.  This can be required in cases where you don't want the models loaded,
+such as when running migrations. This file should be required by +models.rb+.
+
++models.rb+ should contain all code related to your ORM.  This file should be required
 by +app_name.rb+.  This keeps your model code separate from your web code, making it easier
 to use outside of your web code. It allows you to get an IRB shell for accessing your models
 via <tt>irb -r ./models</tt>, without loading the Roda application.
@@ -46,7 +54,7 @@ via <tt>irb -r ./models</tt>, without loading the Roda application.
 +migrate/+ should create your database migration files, if you are using an ORM that uses
 migrations.
 
-+spec/+ should contain your specifications/tests.  For a small application, it's recommended
++spec/+ (or +test/+ should contain your specifications/tests.  For a small application, it's recommended
 to a have a single file for your model tests, and a single file for your web/integration tests.
 
 +Rakefile+ should contain the rake tasks for the application.  The convention is that the
@@ -83,7 +91,8 @@ The routes used by the +hash_routes+ or +multi_run+ should be stored in routing
 directory, with one file per prefix.
 
 For specs/tests, you should have +spec/models/+ and +spec/web/+, with one file per model in +spec/models/+
-and one file per prefix in +spec/web/+.
+and one file per prefix in +spec/web/+. Substitute +spec+ with +test+ if that is what you are using as the
+name of the directory.
 
 You should have a separate view subdirectory per prefix. If you are using +hash_routes+ and +view_options+ plugins,
 use +set_view_subdir+ in your routing files to specify the subdirectory to use, so it doesn't need to be
@@ -105,7 +114,7 @@ subdirectories in the +routes/+ directory, and nested subdirectories in the +vie
 For a small application, the convention in Roda is to layout your Roda application file (+app_name.rb+) like this:
 
   require 'roda'
-  require './models'
+  require_relative 'models'
 
   class AppName < Roda
     SOME_CONSTANT = 1
@@ -138,24 +147,24 @@ used in your route block or views.
 For larger applications, there are some slight changes to the Roda application file layout:
 
   require 'roda'
-  require './models'
+  require_relative 'models'
 
   class AppName < Roda
     SOME_CONSTANT = 1
 
     use SomeMiddleware
 
-    plugin :render, escape: true
+    plugin :render, escape: true, layout: './layout'
     plugin :assets
     plugin :view_options
     plugin :hash_routes
-    Dir['./routes/*.rb'].each{|f| require f}
+    Dir['routes/*.rb'].each{|f| require_relative f}
 
     route do |r|
       r.hash_routes
     end
 
-    Dir['./helpers/*.rb'].each{|f| require f}
+    Dir['helpers/*.rb'].each{|f| require_relative f}
   end
 
 After loading the +view_options+ and +hash_routes+ plugin, you require all of your

data/doc/release_notes/3.31.0.txt

@@ -0,0 +1,11 @@
+= New Features
+
+* A relative_path plugin has been added, adding a relative_path
+  method that will take an absolute path and make it relative to the
+  current request by prepending an appropriate prefix.  This is
+  helpful when using Roda as a static site generator to generate a
+  site that can be hosted at any subpath or directly from the
+  filesystem.
+
+* In the path plugin, the path method now accepts a :relative
+  option for generating relative paths instead of absolute paths.

data/doc/release_notes/3.32.0.txt

@@ -0,0 +1,42 @@
+= New Features
+
+* render_each in the render_each plugin now automatically handles
+  template names with subdirectories and extensions.  Previously, these
+  caused issues unless the :local option was provided.  So now you
+  can use:
+
+    render_each(foos, "items/foo")
+
+  instead of:
+
+    render_each(foos, "items/foo", :local=>:foo)
+
+* each_partial has been added to the partials plugin.  It operates
+  similarly to render_each, but uses the convention for partial
+  template naming.  So this:
+
+    each_partial(foos, "items/foo")
+
+  is the same as:
+
+    render_each(foos, "items/_foo", :local=>:foo)
+
+= Other Improvements
+
+* The :dependencies option in the assets plugin now works correctly
+  with compiled templates in the render plugin in uncached mode
+  (the default in development).  Previously, modifying a dependency
+  file would not result in recompiling the asset template when
+  requesting the main file.
+
+* Method visibility issues in the following plugins have been fixed:
+
+  * content_security_policy
+  * default_headers
+  * indifferent_params
+  * placeholder_string_matchers
+  * symbol_matchers
+
+  Previously, these plugins made private methods public by mistake
+  when overriding them.  Additionally, Roda.freeze no longer changes
+  the visibility of the set_default_headers private method.

data/doc/release_notes/3.33.0.txt

@@ -0,0 +1,8 @@
+= New Features
+
+* The path plugin now supports a url method, allowing for returning
+  the entire URL instead of just the path for class-based paths.
+
+* The public plugin now supports a :brotli option that will directly
+  serve brotli-compressed files (with .br extension) similar to how the
+  :gzip option directly serves gzipped files (with the .gz extension).

data/doc/release_notes/3.34.0.txt

@@ -0,0 +1,17 @@
+= Improvements
+
+* Multiple unneeded conditionals have been removed.
+
+* pre_content and post_context sections in backtraces are no longer
+  included in the exception_page plugin output if they would be
+  empty.
+
+* The match_affix plugin can be loaded again with a single argument.
+  It was originally designed to accept a single argument, but a bug
+  introduced in 2.29.0 made it require two arguments.
+
+* Core Roda and all plugins that ship with Roda now have 100% branch
+  coverage.
+
+* The sinatra_helpers plugin no longer emits statement not reached
+  warnings in verbose mode.

data/doc/release_notes/3.35.0.txt

@@ -0,0 +1,12 @@
+= New Features
+
+* An r plugin has been added.  This plugin adds an r method for the
+  request, useful for allowing the use of r.halt and r.redirect even
+  in methods where the r local variable is not in scope.
+
+= Other Improvements
+
+* Attempting to load a plugin with an argument or block when the plugin
+  does not accept arguments or a block now warns.  This is because a
+  future update to support a block or an optional argument could break
+  the call.

data/lib/roda.rb

@@ -197,6 +197,8 @@ class Roda
               if instance_method(:set_default_headers).owner == ResponseMethods &&
                  instance_method(:default_headers).owner == ResponseMethods
 
+                private
+
                 def set_default_headers
                   @headers['Content-Type'] ||= 'text/html'
                 end
@@ -270,6 +272,12 @@ class Roda
           raise RodaError, "Cannot add a plugin to a frozen Roda class" if frozen?
           plugin = RodaPlugins.load_plugin(plugin) if plugin.is_a?(Symbol)
           raise RodaError, "Invalid plugin type: #{plugin.class.inspect}" unless plugin.is_a?(Module)
+
+          if !plugin.respond_to?(:load_dependencies) && !plugin.respond_to?(:configure) && (!args.empty? || block)
+            # RODA4: switch from warning to error
+            RodaPlugins.warn("Plugin #{plugin} does not accept arguments or a block, but arguments or a block was passed when loading this. This will raise an error in Roda 4.")
+          end
+
           plugin.load_dependencies(self, *args, &block) if plugin.respond_to?(:load_dependencies)
           include(plugin::InstanceMethods) if defined?(plugin::InstanceMethods)
           extend(plugin::ClassMethods) if defined?(plugin::ClassMethods)

data/lib/roda/plugins/_symbol_regexp_matchers.rb

@@ -8,6 +8,8 @@ class Roda
     # using a regexp.
     module SymbolRegexpMatchers
       module RequestMethods
+        private
+
         # The regular expression to use for matching symbols.  By default, any non-empty
         # segment matches.
         def _match_symbol_regexp(s)

data/lib/roda/plugins/all_verbs.rb

@@ -34,7 +34,9 @@ class Roda
     module AllVerbs
       module RequestMethods
         %w'delete head options link patch put trace unlink'.each do |verb|
+          # :nocov:
           if ::Rack::Request.method_defined?("#{verb}?")
+          # :nocov:
             class_eval(<<-END, __FILE__, __LINE__+1)
               def #{verb}(*args, &block)
                 _verb(args, &block) if #{verb}?

data/lib/roda/plugins/assets.rb

@@ -325,10 +325,14 @@ class Roda
 
       # Load the render, caching, and h plugins, since the assets plugin
       # depends on them.
-      def self.load_dependencies(app, _opts = nil)
+      def self.load_dependencies(app, opts = OPTS)
         app.plugin :render
         app.plugin :caching
         app.plugin :h
+
+        if opts[:relative_paths]
+          app.plugin :relative_path
+        end
       end
 
       # Setup the options for the plugin.  See the Assets module RDoc
@@ -401,6 +405,11 @@ class Roda
           opts[s] ||= {} 
         end
 
+        expanded_deps = opts[:expanded_dependencies] = {}
+        opts[:dependencies].each do |file, deps|
+          expanded_deps[File.expand_path(file)] = Array(deps)
+        end
+
         if headers = opts[:headers]
           opts[:css_headers] = headers.merge(opts[:css_headers])
           opts[:js_headers]  = headers.merge(opts[:js_headers])
@@ -408,7 +417,7 @@ class Roda
         opts[:css_headers]['Content-Type'] ||= "text/css; charset=UTF-8".freeze
         opts[:js_headers]['Content-Type']  ||= "application/javascript; charset=UTF-8".freeze
 
-        [:css_headers, :js_headers, :css_opts, :js_opts, :dependencies].each do |s|
+        [:css_headers, :js_headers, :css_opts, :js_opts, :dependencies, :expanded_dependencies].each do |s|
           opts[s].freeze
         end
         [:headers, :css, :js].each do |s|
@@ -647,10 +656,9 @@ class Roda
             end
           end
 
-          if relative_paths && (slash_count = request.path.count('/')) >= 1
-            relative_prefix = "../" * (slash_count - 1)
+          if relative_paths
             paths.map! do |path|
-              "#{relative_prefix}#{path.slice(1,100000000)}"
+              "#{relative_prefix}#{path}"
             end
           end
 
@@ -729,7 +737,7 @@ class Roda
           content = if file.end_with?(".#{type}")
             ::File.read(file)
           else
-            render_asset_file(file, :template_opts=>o[:"#{type}_opts"])
+            render_asset_file(file, :template_opts=>o[:"#{type}_opts"], :dependencies=>o[:expanded_dependencies][file])
           end
 
           o[:postprocessor] ? o[:postprocessor].call(file, type, content) : content
@@ -759,7 +767,7 @@ class Roda
         # other files, check the modification times of all dependencies and
         # return the maximum.
         def asset_last_modified(file)
-          if deps = self.class.assets_opts[:dependencies][file]
+          if deps = self.class.assets_opts[:expanded_dependencies][file]
             ([file] + Array(deps)).map{|f| ::File.stat(f).mtime}.max
           else
             ::File.stat(file).mtime

data/lib/roda/plugins/backtracking_array.rb

@@ -33,9 +33,7 @@ class Roda
         # elements.  If the remaining elements could not be
         # matched, reset the state and continue to the next
         # entry in the array.
-        def _match_array(arg, rest=nil)
-          return super unless rest
-
+        def _match_array(arg, rest)
           path = @remaining_path
           captures = @captures
           caps = captures.dup

data/lib/roda/plugins/class_level_routing.rb

@@ -56,7 +56,6 @@ class Roda
       # currently have a routing block, setup an empty routing block so that things will still work if
       # a routing block isn't added.
       def self.configure(app)
-        app.route{} unless app.route_block
         app.opts[:class_level_routes] ||= []
       end
 

data/lib/roda/plugins/content_security_policy.rb

@@ -304,6 +304,8 @@ class Roda
           @content_security_policy ||= roda_class.opts[:content_security_policy].dup
         end
 
+        private
+
         # Set the appropriate content security policy header.
         def set_default_headers
           super

data/lib/roda/plugins/default_headers.rb

@@ -31,6 +31,8 @@ class Roda
           if owner == Base::ResponseMethods || (owner == response_class && app.opts[:set_default_headers_overridder] == response_class)
             app.opts[:set_default_headers_overridder] = response_class
             response_class.class_eval(<<-END, __FILE__, __LINE__+1)
+              private
+
               def set_default_headers
                 h = @headers
                 #{headers.map{|k,v| "h[#{k.inspect}] ||= #{v.inspect}"}.join('; ')}

data/lib/roda/plugins/disallow_file_uploads.rb

@@ -1,6 +1,8 @@
 # frozen-string-literal: true
 
+# :nocov:
 raise LoadError, "disallow_file_uploads plugin not supported on Rack <1.6" if Rack.release < '1.6'
+# :nocov:
 
 #
 class Roda

data/lib/roda/plugins/exception_page.rb

@@ -252,11 +252,21 @@ END
                 begin
                   lineno -= 1
                   lines = ::File.readlines(filename)
-                  pre_lineno = frame[:pre_context_lineno] = [lineno-context, 0].max
-                  frame[:pre_context] = lines[pre_lineno...lineno]
-                  frame[:context_line] = lines[lineno].chomp
-                  post_lineno = frame[:post_context_lineno] = [lineno+context, lines.size].min
-                  frame[:post_context] = lines[lineno+1..post_lineno]
+                  if line = lines[lineno]
+                    pre_lineno = [lineno-context, 0].max
+                    if (pre_context = lines[pre_lineno...lineno]) && !pre_context.empty?
+                      frame[:pre_context_lineno] = pre_lineno
+                      frame[:pre_context] = pre_context
+                    end
+
+                    post_lineno = [lineno+context, lines.size].min
+                    if (post_context = lines[lineno+1..post_lineno]) && !post_context.empty?
+                      frame[:post_context_lineno] = post_lineno
+                      frame[:post_context] = post_context
+                    end
+
+                    frame[:context_line] = line.chomp
+                  end
                 rescue
                 end
 

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/indifferent_params.rb

@@ -64,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/match_affix.rb

@@ -28,7 +28,7 @@ class Roda
     #
     # This plugin automatically loads the placeholder_string_matchers plugin.
     module MatchAffix
-      def self.load_dependencies(app, _prefix, _suffix)
+      def self.load_dependencies(app, _prefix, _suffix=nil)
         app.plugin :placeholder_string_matchers
       end
 

data/lib/roda/plugins/not_allowed.rb

@@ -104,7 +104,9 @@ class Roda
         # arguments, record the verb used.  If given an argument, add an is
         # check with the arguments.
         %w'get post delete head options link patch put trace unlink'.each do |verb|
+          # :nocov:
           if ::Rack::Request.method_defined?("#{verb}?")
+          # :nocov:
             class_eval(<<-END, __FILE__, __LINE__+1)
               def #{verb}(*args, &block)
                 if (empty = args.empty?) && @_is_verbs

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,24 @@ 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
+                headers['Content-Type'] = ::Rack::Mime.mime_type(::File.extname(path), 'text/plain')
+                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/r.rb

@@ -0,0 +1,35 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The r plugin adds an +r+ instance method that will return the request.
+    # This allows you to use common Roda idioms such as +r.halt+ and
+    # +r.redirect+ even when +r+ isn't a local variable in scope. Example:
+    # 
+    #   plugin :r
+    #
+    #   def foo
+    #     r.redirect "/bar"
+    #   end
+    #
+    #   route do |r|
+    #     r.get "foo" do
+    #       foo
+    #     end
+    #     r.get "bar" do
+    #       "bar"
+    #     end
+    #   end
+    module R
+      module InstanceMethods
+        # The request object.
+        def r
+          @_request
+        end
+      end
+    end
+
+    register_plugin(:r, R)
+  end
+end

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
@@ -275,7 +287,9 @@ class Roda
           false
         end
 
+        # :nocov:
         if COMPILED_METHOD_SUPPORT
+        # :nocov:
           # Compile a method in the given module with the given name that will
           # call the compiled template method, updating the compiled template method
           def define_compiled_method(roda_class, method_name, locals_keys=EMPTY_ARRAY)
@@ -325,7 +339,9 @@ class Roda
         def inherited(subclass)
           super
           opts = subclass.opts[:render] = subclass.opts[:render].dup
+          # :nocov:
           if COMPILED_METHOD_SUPPORT
+          # :nocov:
             opts[:template_method_cache] = (opts[:cache_class] || RodaCache).new
           end
           opts[:cache] = opts[:cache].dup
@@ -576,7 +592,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

data/lib/roda/plugins/render_locals.rb

@@ -43,7 +43,9 @@ class Roda
       module InstanceMethods
         private
 
+        # :nocov:
         if Render::COMPILED_METHOD_SUPPORT
+        # :nocov:
           # Disable use of cached templates, since it assumes a render/view call with no
           # options will have no locals.
           def _cached_template_method(template)

data/lib/roda/plugins/sinatra_helpers.rb

@@ -374,7 +374,7 @@ class Roda
 
       module ResponseMethods
         # Set or retrieve the response status code.
-        def status(value = (return @status; nil))
+        def status(value = nil || (return @status))
           @status = value
         end
 
@@ -401,7 +401,7 @@ class Roda
 
         # Set multiple response headers with Hash, or return the headers if no
         # argument is given.
-        def headers(hash = (return @headers; nil))
+        def headers(hash = nil || (return @headers))
           @headers.merge!(hash)
         end
 
@@ -412,7 +412,7 @@ class Roda
 
         # Set the Content-Type of the response body given a media type or file
         # extension.  See plugin documentation for options.
-        def content_type(type = (return @headers["Content-Type"]; nil), opts = OPTS)
+        def content_type(type = nil || (return @headers["Content-Type"]), opts = OPTS)
           unless (mime_type = mime_type(type) || opts[:default])
             raise RodaError, "Unknown media type: #{type}"
           end
@@ -478,7 +478,7 @@ class Roda
         # If a type and value are given, set the value in Rack's MIME registry.
         # If only a type is given, lookup the type in Rack's MIME registry and
         # return it.
-        def mime_type(type=(return; nil), value = nil)
+        def mime_type(type=nil || (return), value = nil)
           return type.to_s if type.to_s.include?('/')
           type = ".#{type}" unless type.to_s[0] == ?.
           if value

data/lib/roda/plugins/symbol_matchers.rb

@@ -6,7 +6,7 @@ class Roda
     # The symbol_matchers plugin allows you do define custom regexps to use
     # for specific symbols.  For example, if you have a route such as:
     #
-    #   r.on :username do
+    #   r.on :username do |username|
     #     # ...
     #   end
     #
@@ -28,7 +28,7 @@ class Roda
     # If the placeholder_string_matchers plugin is loaded, this feature also applies to
     # placeholders in strings, so the following:
     #
-    #   r.on "users/:username" do
+    #   r.on "users/:username" do |username|
     #     # ...
     #   end
     #

data/lib/roda/plugins/typecast_params.rb

@@ -742,9 +742,7 @@ class Roda
             return
           end
 
-          if v = self[key]
-            v.subkey(keys, do_raise)
-          end
+          self[key].subkey(keys, do_raise)
         rescue => e
           handle_error(key, reason, e)
         end
@@ -808,10 +806,10 @@ class Roda
           @nested_params = nil
 
           if capturing_started
-            # Unset capturing if capturing was not already started.
+            # Unset capturing if capturing was already started.
             @capture = nil
           else
-            # If capturing was already started, update cached nested params
+            # If capturing was not already started, update cached nested params
             # before resetting symbolize setting. 
             @nested_params = nested_params
           end
@@ -878,7 +876,7 @@ class Roda
         def handle_error(key, reason, e, do_raise=false)
           case e
           when String
-            handle_error(key, reason, Error.new(e), do_raise=false)
+            handle_error(key, reason, Error.new(e), do_raise)
           when Error, ArgumentError
             if @capture && (le = @capture.last) && le == e
               raise e if do_raise

data/lib/roda/plugins/view_options.rb

@@ -126,7 +126,9 @@ class Roda
 
         private
 
+        # :nocov:
         if Render::COMPILED_METHOD_SUPPORT
+        # :nocov:
           # 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)

data/lib/roda/request.rb

@@ -466,10 +466,8 @@ class Roda
           rp = @remaining_path
           if rp.getbyte(0) == 47
             if last = rp.index('/', 1)
-              if last > 1
-                @captures << rp[1, last-1]
-                @remaining_path = rp[last, rp.length]
-              end
+              @captures << rp[1, last-1]
+              @remaining_path = rp[last, rp.length]
             elsif rp.length > 1
               @captures << rp[1,rp.length]
               @remaining_path = ""

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 3.30.0
+  version: 3.35.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-13 00:00:00.000000000 Z
+date: 2020-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -206,6 +206,11 @@ extra_rdoc_files:
 - doc/release_notes/3.28.0.txt
 - doc/release_notes/3.29.0.txt
 - doc/release_notes/3.30.0.txt
+- doc/release_notes/3.31.0.txt
+- doc/release_notes/3.32.0.txt
+- doc/release_notes/3.33.0.txt
+- doc/release_notes/3.34.0.txt
+- doc/release_notes/3.35.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -237,6 +242,11 @@ files:
 - doc/release_notes/3.29.0.txt
 - doc/release_notes/3.3.0.txt
 - doc/release_notes/3.30.0.txt
+- doc/release_notes/3.31.0.txt
+- doc/release_notes/3.32.0.txt
+- doc/release_notes/3.33.0.txt
+- doc/release_notes/3.34.0.txt
+- doc/release_notes/3.35.0.txt
 - doc/release_notes/3.4.0.txt
 - doc/release_notes/3.5.0.txt
 - doc/release_notes/3.6.0.txt
@@ -316,6 +326,8 @@ files:
 - lib/roda/plugins/placeholder_string_matchers.rb
 - lib/roda/plugins/precompile_templates.rb
 - lib/roda/plugins/public.rb
+- lib/roda/plugins/r.rb
+- lib/roda/plugins/relative_path.rb
 - lib/roda/plugins/render.rb
 - lib/roda/plugins/render_each.rb
 - lib/roda/plugins/render_locals.rb