roda 2.16.0 → 2.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c3051f95d0665c935a0aa391b7f5b3d4ec3905ec
-  data.tar.gz: c3a81d9c6384dc8708c941fcb8171295fcaff6bc
+  metadata.gz: f728447f69ff9f50896fb6dca7a0e709f2df26e1
+  data.tar.gz: 521dd8fa68fe85421eab4d410619991da0655cb8
 SHA512:
-  metadata.gz: e6479fd6fffd9fdcefc3c09e3543142668b7cd15b3f52af8fda896d438a174b54c1a8350c5aea6a5745188f5eaec78b5fe3a11405365a1318ff38a0098acd307
-  data.tar.gz: 1a837206ad2a4a158e5c939c0a52107752f3e9c9108255e843db681c1f2a62265ee5ca54ba96071b441ca760de7ee2871cf58822ce9f12ed704fa283fcb786b2
+  metadata.gz: 150c34299dd44322d1d36523f83aa948a61740b8b0bc5374de85ce94feb67ab9ced97262b7982330aa91d1433362ace6bab7a1924689a3dd99b3576db478fdc2
+  data.tar.gz: 68d485ef5b650992d224ac98af823153d25bc7c4ff9fb71d087a44f7c792f9a2431d2d93722433ebf553ad3f387d74848125f88144ef88dad52dfdaf50dab13b

data/CHANGELOG

@@ -1,3 +1,17 @@
+= 2.17.0 (2016-08-13)
+
+* Add :postprocessor option to assets plugin, for postprocessing assets (e.g. autoprefixing CSS) (celsworth) (#86)
+
+* Fix path passed to rack apps when using r.run and the type_routing plugin (jeremyevans) (#82)
+
+* Support :classes option to error_handler plugin for overriding which exception classes to rescue (jeremyevans)
+
+* Support :layout_opts=>:merge_locals option in render plugin for merging view template locals into layout template locals (jeremyevans) (#80)
+
+* Support :sri option to assets plugin to enable subresource integrity (jeremyevans)
+
+* Add run_append_slash plugin, so r.run uses "/" instead of "" for app's PATH_INFO (kenaniah) (#77)
+
 = 2.16.0 (2016-07-13)
 
 * Add type_routing plugin, for routing based on path extensions and Accept headers (Papierkorb, jeremyevans) (#75)

data/README.rdoc

@@ -46,7 +46,7 @@ to get the default behavior.
 
 Roda has low per-request overhead, and the use of a routing tree
 and intelligent caching of internal datastructures makes it 
-significantly faster than popular ruby web frameworks.
+significantly faster than other popular ruby web frameworks.
 
 == Usage
 
@@ -443,6 +443,15 @@ via the +status+ attribute for the response.
     end
   end
 
+When redirecting, the response will use a 302 status code by default.
+You can change this by passing a second argument to +r.redirect+:
+
+  route do |r|
+    r.get "hello" do
+      r.redirect "/other", 301 # use 301 Moved Permanently
+    end
+  end
+
 == Verb Methods
 
 As displayed above, Roda has +r.get+ and +r.post+ methods
@@ -601,8 +610,8 @@ and still have access to them inside the +api+ +route+ block.
 
 It is very easy to test Roda with {Rack::Test}[https://github.com/brynary/rack-test]
 or {Capybara}[https://github.com/jnicklas/capybara].
-Roda's own tests use {RSpec}[http://rspec.info].
-The default Rake task will run the specs for Roda, if RSpec is installed.
+Roda's own tests use {minitest/spec}[https://github.com/seattlerb/minitest].
+The default Rake task will run the specs for Roda.
 
 == Settings
 
@@ -743,7 +752,7 @@ to escape by default, so that in your templates:
   <%= '<>' %>  # outputs &lt;&gt; 
   <%== '<>' %> # outputs <>
 
-When using the +:escape_option, you will need to ensure that your layouts
+When using the +:escape+ option, you will need to ensure that your layouts
 are not escaping the output of the content template:
 
   <%== yield %> # not <%= yield %>
@@ -809,15 +818,50 @@ Roda 3.  Note that when specifying the +:path+ option when rendering a template,
 not check paths, as it assumes that users and libraries that use this option will be checking
 such paths manually.
 
-== Reloading
-
-Most rack-based reloaders will work with Roda, including:
-
-* {rack-unreloader}[https://github.com/jeremyevans/rack-unreloader]
-* {rerun}[https://github.com/alexch/rerun]
-* {shotgun}[https://github.com/rtomayko/shotgun]
-* {Rack::Reloader}[https://github.com/rack/rack/blob/master/lib/rack/reloader.rb]
-* {pistol}[https://github.com/monk/pistol]
+== Code Reloading
+
+Roda does not ship with integrated support for code reloading, as it is a toolkit and not a
+framework, but there are rack-based reloaders that will work with Roda apps.
+
+For most applications, {rack-unreloader}[https://github.com/jeremyevans/rack-unreloader]
+is probably the fastest approach to reloading while still being fairly safe, as it
+reloads just files that have been modified, and unloads constants defined in the files
+before reloading them.  However, it requires modifying your application code to use
+rack-unreloader specific APIs.
+
+A similar solution that reloads files and unloads constants is ActiveSupport::Dependencies.
+ActiveSupport::Dependencies doesn't require modifying your application code, but it modifies
+some core methods, including +require+ and +const_missing+. It requires less configuration,
+but depends that you follow Rails' file and class naming conventions. It also provides
+autoloading (on the fly) of files when a missing constant is accessed. If your application
+does not rely on autoloading then +require_dependency+ must be used to require the dependencies
+or they won't be reloaded.
+
+{AutoReloader}[https://github.com/rosenfeld/auto_reloader] provides transparent reloading for
+all files reached from one of the +reloadable_paths+ option entries, by detecting new top-level
+constants and removing them when any of the reloadable loaded files changes. It overrides
++require+ and +require_relative+ when activated (usually in the development environment). No
+configurations other than +reloadable_paths+ are required.
+
+Both {rerun}[https://github.com/alexch/rerun] and
+{shotgun}[https://github.com/rtomayko/shotgun] use a fork/exec approach for loading new
+versions of your app.  rerun is faster as it only reloads the app on changes, whereas
+shotgun reloads the app on every request.  Both work without any changes to application
+code, but may be slower as they have to reload the entire application on every change.
+However, for small apps that load quickly, either may be a good approach.
+
+{Rack::Reloader}[https://github.com/rack/rack/blob/master/lib/rack/reloader.rb] ships
+with rack and just reloads monitored files when they change, without unloading constants.
+It's fast but may cause issues in cases where you remove classes, constants, or methods,
+or when you are not clearing out cached data manually when files are reloaded.
+
+There is no one reloading solution that is the best for all applications and development
+approaches.  Consider your needs and the the tradeoffs of each of the reloading approaches,
+and pick the one you think will work best.
+
+If you are unsure where to start, it may be best to start with rerun or shotgun
+(unless you're running on JRuby or Windows), and only consider other options if rerun or
+shotgun are not fast enough.
 
 == Plugins
 

data/doc/release_notes/2.17.0.txt

@@ -0,0 +1,62 @@
+= New Plugins 
+
+* A run_append_slash plugin has been added, which automatically uses
+  "/" as the path instead of an empty path when calling rack
+  applications with r.run:
+
+    route do |r|
+      r.on "a" do
+        r.run App
+      end
+    end
+    
+    # without run_append_slash:
+    # GET /a => App gets "" as PATH_INFO
+    # GET /a/ => App gets "/" as PATH_INFO
+
+    # with run_append_slash:
+    # GET /a => App gets "/" as PATH_INFO
+    # GET /a/ => App gets "/" as PATH_INFO
+
+  By default, the path is modified directly, but if you want to
+  redirect instead, you can pass a :use_redirects option when loading
+  the plugin.
+
+= New Features
+
+* The assets plugin now supports an :sri option to enable subresource
+  integrity on the link/script tags generated by the assets helper.
+  This option takes either :sha256, :sha384, or :sha512 values,
+  specifying the hash algorithm to use.  Roda 3 will default to using
+  :sri => :sha256.
+
+* The assets plugin now supports a :postprocessor option, which should
+  be a callable object.  If the option is given, it will be called with
+  the filename, type, and rendered asset output of the file (CSS/JS),
+  and should return the postprocessed content to use.  This allows any
+  type of custom postprocessing to be done, such as CSS autoprefixing.
+
+* The render plugin now supports a :layout_opts=>:merge_locals option,
+  which will automatically merge view template locals into layout
+  template locals.  This is useful if you want to use the same local
+  variable for both templates.
+
+* The error_handler plugin now supports a :classes option, allowing
+  you to override which exception classes to handle.  This allows it
+  to be used with libraries which use exception classes that
+  subclass from Exception instead of StandardError.
+
+= Other Improvements
+
+* The type_routing plugin now works correctly when using r.run.
+  Previously, if the type routing plugin recognized and removed
+  the file extension used in the requested path, it would not
+  add the file extension back to the path when passing the request
+  to another rack app.
+
+= Backwards Compatibility
+
+* In the assets plugin, Roda::RodaRequest.assets_matchers now uses
+  symbols instead of strings as the first argument in each entry.
+  This should not affect you unless you were accessing the values
+  directly.

data/lib/roda/plugins/assets.rb

@@ -182,6 +182,26 @@ class Roda
     # and it will run in compiled mode, assuming that the compiled asset files
     # already exist.
     #
+    # ==== Postprocessing
+    #
+    # If you pass a callable object to the :postprocessor option, it will be called
+    # before an asset is served.
+    # If the assets are to be compiled, the object will be called at compilation time.
+    #
+    # It is passed three arguments; the name of the asset file, the type of the
+    # asset file (which is a symbol, either :css or :js), and the asset contents.
+    #
+    # It should return the new content for the asset.
+    #
+    # You can use this to call Autoprefixer on your CSS:
+    #
+    #   plugin :assets, {
+    #     :css => [ 'style.scss' ],
+    #     :postprocessor => lambda do |file, type, content|
+    #       type == :css ? AutoprefixerRails.process(content).css : content
+    #     end
+    #   }
+    #
     # ==== On Heroku
     #
     # Heroku supports precompiling the assets when using Roda.  You just need to
@@ -245,12 +265,19 @@ class Roda
     # :js_route :: Route under :prefix for javascript assets (default: :js_dir)
     # :path :: Path to your asset source directory (default: 'assets').   Relative
     #          paths will be considered relative to the application's :root option.
+    # :postprocessor :: A block which should accept three arguments (asset name, asset type,
+    #                   content). This block can be used to hook into the asset system and
+    #                   make your own modifications before the asset is served. If the asset
+    #                   is to be compiled, the block is called at compile time.
     # :prefix :: Prefix for assets path in your URL/routes (default: 'assets')
     # :precompiled :: Path to the compiled asset metadata file.  If the file exists, will use compiled
     #                 mode using the metadata in the file.  If the file does not exist, will use
     #                 non-compiled mode, but will write the metadata to the file if compile_assets is called.
     # :public :: Path to your public folder, in which compiled files are placed (default: 'public').  Relative
     #            paths will be considered relative to the application's :root option.
+    # :sri :: Enables subresource integrity when setting up references to compiled assets. The value should be
+    #         :sha256, :sha384, or :sha512 depending on which hash algorithm you want to use.  This changes the
+    #         hash algorithm that Roda will use when naming compiled asset files.
     module Assets
       DEFAULTS = {
         :compiled_name    => 'app'.freeze,
@@ -546,8 +573,15 @@ class Roda
         # a different digest type or to return a static string if you don't
         # want to use a unique value.
         def asset_digest(content)
-          require 'digest/sha1'
-          ::Digest::SHA1.hexdigest(content)
+          klass = if algo = assets_opts[:sri]
+            require 'digest/sha2'
+            ::Digest.const_get(algo.to_s.upcase)
+          else
+            require 'digest/sha1'
+            ::Digest::SHA1
+          end
+
+          klass.hexdigest(content)
         end
       end
 
@@ -566,9 +600,9 @@ class Roda
           o = self.class.assets_opts
           type, *dirs = type if type.is_a?(Array)
           stype = type.to_s
+          ru = Rack::Utils
 
           attrs = if attrs
-            ru = Rack::Utils
             attrs.map{|k,v| "#{k}=\"#{ru.escape_html(v.to_s)}\""}.join(SPACE)
           else
             EMPTY_STRING
@@ -590,15 +624,19 @@ class Roda
             if dirs && !dirs.empty?
               key = dirs.join(DOT)
               ckey = "#{stype}.#{key}"
-              if ukey = compiled[ckey]
+              if hash = ukey = compiled[ckey]
                 ukey = "#{key}.#{ukey}"
               end
             else
-              ukey = compiled[stype]
+              hash = ukey = compiled[stype]
             end
 
             if ukey
-              "#{tag_start}#{asset_host}#{url_prefix}/#{o[:"compiled_#{stype}_prefix"]}.#{ukey}.#{stype}#{tag_end}"
+              if algo = o[:sri]
+                integrity = "\" integrity=\"#{algo}-#{ru.escape_html([[hash].pack('H*')].pack('m').tr("\n", EMPTY_STRING))}"
+              end
+
+              "#{tag_start}#{asset_host}#{url_prefix}/#{o[:"compiled_#{stype}_prefix"]}.#{ukey}.#{stype}#{integrity}#{tag_end}"
             end
           else
             asset_dir = o[type]
@@ -640,11 +678,15 @@ class Roda
         # Otherwise, render the file using the render plugin.  +file+ should be
         # the relative path to the file from the current directory.
         def read_asset_file(file, type)
-          if file.end_with?(".#{type}")
+          o = self.class.assets_opts
+
+          content = if file.end_with?(".#{type}")
             ::File.read(file)
           else
-            render_asset_file(file, :template_opts=>self.class.assets_opts[:"#{type}_opts"])
+            render_asset_file(file, :template_opts=>o[:"#{type}_opts"])
           end
+
+          o[:postprocessor] ? o[:postprocessor].call(file, type, content) : content
         end
 
         private
@@ -680,7 +722,7 @@ class Roda
         # handled.
         def assets_matchers
           @assets_matchers ||= [:css, :js].map do |t|
-            [t.to_s.freeze, assets_regexp(t)].freeze if roda_class.assets_opts[t]
+            [t, assets_regexp(t)].freeze if roda_class.assets_opts[t]
           end.compact.freeze
         end
 

data/lib/roda/plugins/error_handler.rb

@@ -29,10 +29,21 @@ class Roda
     # The error handler can change the response status if necessary,
     # as well set headers and/or write to the body, just like a regular
     # request.
+    #
+    #
+    # By default, this plugin handles StandardError and ScriptError.
+    # To override the exception classes it will handle, pass a :classes
+    # option to the plugin:
+    #
+    #   plugin :error_handler, :classes=>[StandardError, ScriptError, NoMemoryError]
     module ErrorHandler
+      DEFAULT_ERROR_HANDLER_CLASSES = [StandardError, ScriptError].freeze
+
       # If a block is given, automatically call the +error+ method on
       # the Roda class with it.
-      def self.configure(app, &block)
+      def self.configure(app, opts={}, &block)
+        app.opts[:error_handler_classes] = (opts[:classes] || app.opts[:error_handler_classes] || DEFAULT_ERROR_HANDLER_CLASSES).dup.freeze
+
         if block
           app.error(&block)
         end
@@ -53,7 +64,7 @@ class Roda
         # the error handler.
         def call
           super
-        rescue StandardError, ScriptError => e
+        rescue *opts[:error_handler_classes] => e
           res = @_response = self.class::RodaResponse.new
           res.status = 500
           super{handle_error(e)}

data/lib/roda/plugins/match_affix.rb

@@ -15,15 +15,16 @@ class Roda
     #
     #   plugin :match_affix, ""
     #
-    # will load the plugin and use an empty prefix.
+    # will load the plugin and use an empty prefix (instead of a slash).
     #
     #   plugin :match_affix, "", /(\/|\z)/
     #
     # will use an empty prefix and change the suffix to consume a trailing slash.
     #
-    #  plugin :match_affix, nil, /(\/|\z)/
+    #  plugin :match_affix, nil, /(?:\/\z|(?=\/|\z))/
     #
-    # will not modify the prefix and will change the suffix to consume a trailing slash.
+    # will not modify the prefix and will change the suffix so that it consumes a trailing slash
+    # at the end of the path only.
     module MatchAffix
       PREFIX = "/".freeze
       SUFFIX = "(?=\/|\z)".freeze

data/lib/roda/plugins/path_rewriter.rb

@@ -36,9 +36,9 @@ class Roda
     # Patterns can be rewritten dynamically by providing a block accepting a MatchData
     # object and evaluating to the replacement.
     #
-    #   rewrite_path(/\A\/a/(\w+)/){|match| match[1].capitalize}
+    #   rewrite_path(/\A\/a/(\w+)/){|match| "/a/#{match[1].capitalize}"}
     #   # PATH_INFO '/a/moo' => remaining_path '/a/Moo'
-    #   rewrite_path(/\A\/a/(\w+)/, :path_info => true){|match| match[1].capitalize}
+    #   rewrite_path(/\A\/a/(\w+)/, :path_info => true){|match| "/a/#{match[1].capitalize}"}
     #   # PATH_INFO '/a/moo' => PATH_INFO '/a/Moo'
     #
     # All path rewrites are applied in order, so if a path is rewritten by one rewrite,

data/lib/roda/plugins/render.rb

@@ -20,6 +20,24 @@ class Roda
     #     end
     #   end
     #
+    # The +render+ and +view+ methods just return strings, they do not have
+    # 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
+    # rendering.
+    #
+    # Because +render+ and +view+ just return strings, you can call them inside
+    # templates (i.e. for subtemplates/partials), or multiple times in the
+    # same route and combine the results together:
+    #
+    #   route do |r|
+    #     r.is 'foo-bars' do
+    #       @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'
@@ -46,9 +64,12 @@ class Roda
     # :escaper :: Object used for escaping output of <tt><%= %></tt>, when :escape is used,
     #             overriding the default.  If given, object should respond to +escape_xml+ with
     #             a single argument and return an output string.
-    # :layout :: The base name of the layout file, defaults to 'layout'.
+    # :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.
+    #                 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.
     # :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
@@ -154,6 +175,11 @@ class Roda
 
         opts[:layout_opts] = (opts[:layout_opts] || {}).dup
         opts[:layout_opts][:_is_layout] = true
+
+        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)
 
@@ -373,16 +399,31 @@ class Roda
         # used, return nil.
         def view_layout_opts(opts)
           if layout = opts.fetch(:layout, render_opts[:layout])
+
             layout_opts = render_layout_opts
-            if l_opts = opts[:layout_opts]
-              if (l_locals = l_opts[:locals]) && (layout_locals = layout_opts[:locals])
-                set_locals = Hash[layout_locals].merge!(l_locals)
-              end
-              layout_opts.merge!(l_opts)
-              if set_locals
-                layout_opts[:locals] = set_locals
-              end
+            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
+
+            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
+
+            layout_opts.merge!(method_layout_opts) if method_layout_opts
+            layout_opts[:locals] = locals unless locals.empty?
 
             case layout
             when Hash

data/lib/roda/plugins/run_append_slash.rb

@@ -0,0 +1,52 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The run_append_slash plugin makes +r.run+ use +/+ as the +PATH_INFO+
+    # when calling the rack application if +PATH_INFO+ would be empty.
+    # Example:
+    #
+    #   route do |r|
+    #     r.on "a" do
+    #       r.run App
+    #     end
+    #   end
+    #
+    #   # without run_append_slash: 
+    #   # GET /a => App gets "" as PATH_INFO
+    #   # GET /a/ => App gets "/" as PATH_INFO
+    #
+    #   # with run_append_slash: 
+    #   # GET /a => App gets "/" as PATH_INFO
+    #   # GET /a/ => App gets "/" as PATH_INFO
+    module RunAppendSlash
+      OPTS = {}.freeze
+      # Set plugin specific options.  Options:
+      # :use_redirects :: Whether to issue 302 redirects when appending the
+      #                   trailing slash.
+      def self.configure(app, opts=OPTS)
+        app.opts[:run_append_slash_redirect] = !!opts[:use_redirects]
+      end
+
+      module RequestMethods
+        # Calls the given rack app. If the path matches the root of the app but
+        # does not contain a trailing slash, a trailing slash is appended to the
+        # path internally, or a redirect is issued when configured with
+        # <tt>use_redirects: true</tt>.
+        def run(app)
+          if remaining_path.empty?
+            if scope.opts[:run_append_slash_redirect]
+              redirect("#{path}/")
+            else
+              @remaining_path += '/'
+            end
+          end
+          super
+        end
+      end
+    end
+
+    register_plugin(:run_append_slash, RunAppendSlash)
+  end
+end

data/lib/roda/plugins/type_routing.rb

@@ -159,6 +159,16 @@ class Roda
           @requested_type ||= opts[:default_type]
         end
 
+        # Add the type routing extension back to the remaining path
+        # if it was removed from the path when the application was
+        # initialized.
+        def run(_)
+          if defined?(@type_routing_extension)
+            @remaining_path += ".#{@type_routing_extension}"
+          end
+          super
+        end
+
         private
 
         # Removes a trailing file extension from the path, and sets
@@ -169,7 +179,7 @@ class Roda
 
           if opts[:use_extension]
             if m = path.match(opts[:extension_regexp])
-              @requested_type = m[2].to_sym
+              @type_routing_extension =  @requested_type = m[2].to_sym
               path = m[1]
             end
           end

data/lib/roda/version.rb

@@ -4,7 +4,7 @@ class Roda
   RodaMajorVersion = 2
 
   # The minor version of Roda, updated for new feature releases of Roda.
-  RodaMinorVersion = 16
+  RodaMinorVersion = 17
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

data/spec/plugin/assets_spec.rb

@@ -54,6 +54,7 @@ if run_tests
     after(:all) do
       FileUtils.rm_r('spec/assets/tmp') if File.directory?('spec/assets/tmp')
       FileUtils.rm_r('spec/public') if File.directory?('spec/public')
+      FileUtils.rm(Dir['spec/assets/app.*.{js,css}*'])
     end
 
     def gunzip(body)
@@ -266,6 +267,31 @@ if run_tests
       js.must_include('console.log')
     end
 
+    [[:sha256, 64, 44], [:sha384, 96, 64], [:sha512, 128, 88]].each do |algo, hex_length, base64_length|
+      it 'should handle :sri option for subresource integrity when compiling assets' do
+        app.plugin :assets, :sri=>algo
+        app.compile_assets
+        html = body('/test')
+        html.scan(/<link/).length.must_equal 1
+        html =~ %r|integrity="#{algo}-([^"]+)" />|
+        css_hash = $1.gsub('&#x2F;', '/')
+        css_hash.length.must_equal base64_length
+        html =~ %r|href="(/assets/app\.[a-f0-9]{#{hex_length}}\.css)"|
+        css = body($1)
+        [Digest.const_get(algo.to_s.upcase).digest(css)].pack('m').tr("\n", "").must_equal css_hash
+        html.scan(/<script/).length.must_equal 1
+        html =~ %r|integrity="#{algo}-([^"]+)"></script>|
+        js_hash = $1.gsub('&#x2F;', '/')
+        js_hash.length.must_equal base64_length
+        html =~ %r|src="(/assets/app\.head\.[a-f0-9]{#{hex_length}}\.js)"|
+        js = body($1)
+        [Digest.const_get(algo.to_s.upcase).digest(js)].pack('m').tr("\n", "").must_equal js_hash
+        css.must_match(/color: ?red/)
+        css.must_match(/color: ?blue/)
+        js.must_include('console.log')
+      end
+    end
+
     it 'should handle linking to compiled assets when a compiled asset host is used' do
       app.plugin :assets, :compiled_asset_host=>'https://cdn.example.com'
       app.compile_assets
@@ -519,7 +545,7 @@ if run_tests
       a = app::RodaRequest.assets_matchers
       a.length.must_equal 1
       a.first.length.must_equal 2
-      a.first.first.must_equal 'js'
+      a.first.first.must_equal :js
       'assets/js/head/app.js'.must_match a.first.last
       'assets/js/head/app2.js'.wont_match a.first.last
     end
@@ -529,6 +555,30 @@ if run_tests
       app::RodaRequest.assets_matchers.must_equal []
     end
 
+    it 'should support :postprocessor option' do
+      postprocessor = lambda do |file, type, content|
+        "file=#{file} type=#{type} tc=#{type.class} #{content.sub('color', 'font')}"
+      end
+
+      app.plugin :assets, :path=>'spec', :js_dir=>nil, :css_dir=>nil, :prefix=>nil,
+        :postprocessor=>postprocessor,
+        :css=>{:assets=>{:css=>%w'app.scss'}}
+      app.route do |r|
+        r.assets
+        r.is 'test' do
+          "#{assets([:css, :assets, :css])}"
+        end
+      end
+      html = body('/test')
+      html.scan(/<link/).length.must_equal 1
+      html =~ %r{href="(/assets/css/app\.scss)"}
+      css = body($1)
+      css.must_match(/app\.scss/)
+      css.must_match(/type=css/)
+      css.must_match(/tc=Symbol/)
+      css.must_match(/font: red;/)
+    end
+
     it 'should support :precompiled option' do
       app.plugin :assets, :precompiled=>metadata_file
       File.exist?(metadata_file).must_equal false

data/spec/plugin/error_handler_spec.rb

@@ -47,6 +47,31 @@ describe "error_handler plugin" do
     status.must_equal 500
   end
 
+  it "executes on custom exception classes" do
+    app(:bare) do
+      plugin :error_handler, :classes=>[StandardError]
+
+      error do |e|
+        e.message
+      end
+
+      route do |r|
+        r.on "a" do
+          raise 'foo'
+        end
+
+        raise SyntaxError, 'bad idea'
+      end
+    end
+
+    proc{body}.must_raise SyntaxError
+    body("/a").must_equal 'foo'
+
+    @app = Class.new(@app)
+    proc{body}.must_raise SyntaxError
+    body("/a").must_equal 'foo'
+  end
+
   it "can override status inside error block" do
     app(:bare) do
       plugin :error_handler do |e|

data/spec/plugin/match_affix_spec.rb

@@ -19,4 +19,25 @@ describe "match_affix plugin" do
     body("/albums/a/1").must_equal 'albums-/'
     body("/albums/b/1").must_equal 'b-/-1-""'
   end
+
+  it "handles extra trailing slash only" do
+    app(:bare) do
+      plugin :match_affix, nil, /(?:\/\z|(?=\/|\z))/
+
+      route do |r|
+        r.on "albums" do
+          r.on "b" do
+            "albums/b:#{r.remaining_path}"
+          end
+
+          "albums:#{r.remaining_path}"
+        end
+      end
+    end
+
+    body("/albums/a").must_equal 'albums:/a'
+    body("/albums/a/").must_equal 'albums:/a/'
+    body("/albums/b").must_equal 'albums/b:'
+    body("/albums/b/").must_equal 'albums/b:'
+  end
 end

data/spec/plugin/render_spec.rb

@@ -68,6 +68,34 @@ describe "render plugin" do
   end
 end
 
+describe "render plugin with :layout_opts=>{:merge_locals=>true}" do
+  h = {:a=>1, :b=>2, :c=>3, :d=>4}
+
+  before do
+    app(:bare) do
+      plugin :render, :views=>"./spec/views", :check_paths=>true, :locals=>{:a=>1, :b=>2, :c=>3, :d=>4, :e=>5}, :layout_opts=>{:inline=>'<%= a %>|<%= b %>|<%= c %>|<%= d %>|<%= e %>|<%= f %>|<%= yield %>', :merge_locals=>true, :locals=>{:a=>-1, :f=>6}}
+
+      route do |r|
+        r.on "base" do
+          view(:inline=>'(<%= a %>|<%= b %>|<%= c %>|<%= d %>|<%= e %>)')
+        end
+        r.on "override" do
+          view(:inline=>'(<%= a %>|<%= b %>|<%= c %>|<%= d %>|<%= e %>)', :locals=>{:b=>-2, :d=>-4, :f=>-6}, :layout_opts=>{:locals=>{:d=>0, :c=>-3, :e=>-5}})
+        end
+        r.on "no_merge" do
+          view(:inline=>'(<%= a %>|<%= b %>|<%= c %>|<%= d %>|<%= e %>)', :locals=>{:b=>-2, :d=>-4, :f=>-6}, :layout_opts=>{:merge_locals=>false, :locals=>{:d=>0, :c=>-3, :e=>-5}})
+        end
+      end
+    end
+  end
+
+  it "should choose method opts before plugin opts, and layout specific before locals" do
+    body("/base").must_equal '-1|2|3|4|5|6|(1|2|3|4|5)'
+    body("/override").must_equal '-1|-2|-3|0|-5|-6|(1|-2|3|-4|5)'
+    body("/no_merge").must_equal '-1|2|-3|0|-5|6|(1|-2|3|-4|5)'
+  end
+end
+
 describe "render plugin" do
   it "simple layout support" do
     app(:bare) do

data/spec/plugin/run_append_slash_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "run_append_slash plugin" do
+  before do
+    sub2 = app do |r|
+      r.root do
+        'sub-bar-root'
+      end
+
+      r.get 'baz' do
+        'sub-bar-baz'
+      end
+    end
+
+    sub1 = app(:run_append_slash) do |r|
+      r.root do
+        'sub-root'
+      end
+
+      r.get 'foo' do
+        'sub-foo'
+      end
+
+      r.on 'bar' do
+        r.run sub2
+      end
+    end
+
+    app(:bare) do
+      route do |r|
+        r.root do
+          'root'
+        end
+
+        r.on 'sub' do
+          r.run sub1
+        end
+      end
+    end
+  end
+
+  it "internally appends a missing trailing slash to #run sub apps" do
+    # Without append slash
+    body.must_equal 'root'
+    status('/sub').must_equal 404
+    body('/sub/').must_equal 'sub-root'
+    body('/sub/foo').must_equal 'sub-foo'
+    status('/sub/foo/').must_equal 404
+    body('/sub/bar/').must_equal 'sub-bar-root'
+    body('/sub/bar/baz').must_equal 'sub-bar-baz'
+    status('/sub/bar/baz/').must_equal 404
+
+    # With append slash
+    app.plugin :run_append_slash
+    body('/sub').must_equal 'sub-root'
+    body('/sub/').must_equal 'sub-root'
+    body('/sub/foo').must_equal 'sub-foo'
+    status('/sub/foo/').must_equal 404
+    body('/sub/bar').must_equal 'sub-bar-root'
+    body('/sub/bar/').must_equal 'sub-bar-root'
+    body('/sub/bar/baz').must_equal 'sub-bar-baz'
+    status('/sub/bar/baz/').must_equal 404
+  end
+
+  it "redirects #run sub apps when trailing slash is missing" do
+    app.plugin :run_append_slash, :use_redirects => true
+    status('/sub').must_equal 302
+    header('Location', '/sub').must_equal '/sub/'
+    body('/sub/').must_equal 'sub-root'
+    body('/sub/foo').must_equal 'sub-foo'
+    status('/sub/foo/').must_equal 404
+    body('/sub/bar').must_equal 'sub-bar-root'
+    body('/sub/bar/').must_equal 'sub-bar-root'
+    body('/sub/bar/baz').must_equal 'sub-bar-baz'
+    status('/sub/bar/baz/').must_equal 404
+  end
+end

data/spec/plugin/type_routing_spec.rb

@@ -50,6 +50,18 @@ describe "type_routing plugin" do
     body('/a.html', 'HTTP_ACCEPT' => 'application/xml').must_equal 'HTML: html'
   end
 
+  it "works correctly in sub apps" do
+    sup_app = app
+    b = sup_app.route_block
+    @app = Class.new(sup_app)
+    app.route do |r|
+      r.run(sup_app)
+    end
+    
+    body('/a.json', 'HTTP_ACCEPT' => 'text/html').must_equal 'JSON: json'
+    body('/a.xml', 'HTTP_ACCEPT' => 'application/json').must_equal 'XML: xml'
+    body('/a.html', 'HTTP_ACCEPT' => 'application/xml').must_equal 'HTML: html'
+  end
 
   it "uses the default if neither file extension nor Accept header are given" do
     body('/a').must_equal 'HTML: html'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 2.16.0
+  version: 2.17.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-13 00:00:00.000000000 Z
+date: 2016-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -182,6 +182,7 @@ extra_rdoc_files:
 - doc/release_notes/2.14.0.txt
 - doc/release_notes/2.15.0.txt
 - doc/release_notes/2.16.0.txt
+- doc/release_notes/2.17.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -201,6 +202,7 @@ files:
 - doc/release_notes/2.14.0.txt
 - doc/release_notes/2.15.0.txt
 - doc/release_notes/2.16.0.txt
+- doc/release_notes/2.17.0.txt
 - doc/release_notes/2.2.0.txt
 - doc/release_notes/2.3.0.txt
 - doc/release_notes/2.4.0.txt
@@ -268,6 +270,7 @@ files:
 - lib/roda/plugins/render_each.rb
 - lib/roda/plugins/request_headers.rb
 - lib/roda/plugins/response_request.rb
+- lib/roda/plugins/run_append_slash.rb
 - lib/roda/plugins/run_handler.rb
 - lib/roda/plugins/shared_vars.rb
 - lib/roda/plugins/sinatra_helpers.rb
@@ -353,6 +356,7 @@ files:
 - spec/plugin/render_spec.rb
 - spec/plugin/request_headers_spec.rb
 - spec/plugin/response_request_spec.rb
+- spec/plugin/run_append_slash_spec.rb
 - spec/plugin/run_handler_spec.rb
 - spec/plugin/shared_vars_spec.rb
 - spec/plugin/sinatra_helpers_spec.rb