roda 2.17.0 → 2.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f728447f69ff9f50896fb6dca7a0e709f2df26e1
-  data.tar.gz: 521dd8fa68fe85421eab4d410619991da0655cb8
+  metadata.gz: b5e850d352a98dff085d020e04fa52c55894edaf
+  data.tar.gz: 0fb277bfbfd64699d15d6e56325464e5ba3cb5cb
 SHA512:
-  metadata.gz: 150c34299dd44322d1d36523f83aa948a61740b8b0bc5374de85ce94feb67ab9ced97262b7982330aa91d1433362ace6bab7a1924689a3dd99b3576db478fdc2
-  data.tar.gz: 68d485ef5b650992d224ac98af823153d25bc7c4ff9fb71d087a44f7c792f9a2431d2d93722433ebf553ad3f387d74848125f88144ef88dad52dfdaf50dab13b
+  metadata.gz: a779f1e2cb695dab260f457798582014dd7bee889304de79cea0c05c43f3252b350cddb33e9d17d601f6844eaedc241290b48a2daf7ede4a89133113a2c2f353
+  data.tar.gz: 8594f7058bd36a6cfba5cd47831b0e5267927f09e740c4c2e3b14f237a98432aaa5dde2c15b5a9d9ecb4944de9d35125adc548382383e366795ca8d4678dff1c

data/CHANGELOG

@@ -1,3 +1,15 @@
+= 2.18.0 (2016-09-13)
+
+* Add assets_preloading plugin, for creating link tags or Link header for preloading assets (celsworth, jeremyevans) (#98)
+
+* Add assets_paths method to assets plugin, for just the paths to the assets, instead of the full tags (celsworth) (#96)
+
+* Make type_routing plugin work correctly with public plugin (celsworth, jeremyevans) (#95)
+
+* Add static_routing plugin for 3-4x increase in performance for large numbers of static routes (jeremyevans)
+
+* Make head plugin work with not_allowed plugin if loaded after (jeremyevans) (#92)
+
 = 2.17.0 (2016-08-13)
 
 * Add :postprocessor option to assets plugin, for postprocessing assets (e.g. autoprefixing CSS) (celsworth) (#86)

data/doc/release_notes/2.18.0.txt

@@ -0,0 +1,69 @@
+= New Plugins 
+
+* A static_routing plugin has been added, which can give a 3-4x
+  increase in performance for large number of static routes, and
+	makes routing O(1) for static routes.  Static routes are routes
+	that match full paths, with no placeholders, and are checked before
+	using the normal routing tree.
+
+	Static routes are defined via class-level static_* routing methods.
+	There is a static_* routing method for each HTTP verb (e.g.
+	static_get), as well as a static_route method, which will work
+	for any HTTP verb, with the verb-specific method taking priority.
+	By using static_route, you can get significantly faster performance
+	while retaining some of the benefits of Roda's routing tree design
+  (simple shared logic with verb specific behavior). Example:
+
+    plugin :static_routing
+
+    static_route '/foo' do |r|
+      @var = :foo
+
+      r.get do
+        'Not actually reached'
+      end
+
+      r.post{'static POST /#{@var}'}
+    end
+
+    static_get '/foo' do |r|
+      'static GET /foo'
+    end
+
+    route do |r|
+      'Not a static route'
+    end
+
+  Because static routing routes on the full path instead of by
+	path segment, the methods takes the full path as a string,
+	including the leading slash.
+
+* An assets_preloading plugin has been added, which makes it simple
+  to generate HTML link tags or a Link header value to tell the
+	browser to preload assets for performance reasons.
+
+	  # In routes, using the Link header:
+		response.headers['Link'] = preload_assets_link_header(:css)
+
+		# In templates, using a link tag:
+		<%= preload_assets_link_tags(:css) %>
+
+= New Features
+
+* RodaRequest#real_remaining_path has been added.  This is designed
+  to be overridden by plugins that modify remaining_path for internal
+	routing purposes.  RodaRequest#run now uses real_remaining_path
+	when passing requests to other rack applications.
+
+* An assets_paths method has been added to the assets plugin.  This
+  is similar to the assets method, but it returns an array of paths
+  to the assets, instead of a HTML link/script tag.
+
+= Other Improvements
+
+* The public plugin now works correctly when used with the
+  type_routing plugin, for paths ending in extensions that
+	type_routing is configured to handle.
+
+* The head plugin now works with the not_allowed plugin if it is
+  loaded after the not_allowed plugin.

data/lib/roda.rb

@@ -509,6 +509,12 @@ class Roda
         # The current path to match requests against.
         attr_reader :remaining_path
 
+        # An alias of remaining_path. If a plugin changes remaining_path then
+        # it should override this method to return the untouched original.
+        def real_remaining_path
+          remaining_path
+        end
+
         # Match POST requests.  If no arguments are provided, matches all POST
         # requests, otherwise, matches only POST requests where the arguments
         # given fully consume the path.
@@ -625,7 +631,7 @@ class Roda
         # a URL mapper.
         def run(app)
           e = @env
-          path = @remaining_path
+          path = real_remaining_path
           sn = SCRIPT_NAME
           pi = PATH_INFO
           script_name = e[sn]

data/lib/roda/plugins/assets.rb

@@ -63,6 +63,21 @@ class Roda
     # if it set it will automatically prefix the path with the SCRIPT_NAME for
     # the request.
     #
+    # == Asset Paths
+    #
+    # If you just want the paths rather than the full tags, you can use
+    # assets_paths instead. This will return an array of the sources that
+    # the assets function would have put into tags:
+    #
+    #   assets_paths(:css)
+    #   # => ["/assets/css/foo.css", "/assets/css/app.css"]
+    #
+    # If compilation is turned on, it will return the path to the compiled
+    # asset:
+    #
+    #   assets_paths(:css)
+    #   # => ["/assets/app.5e7b06baa1a514d8473b0eca514b806c201073b9.css"]
+    #
     # == Asset Groups
     #
     # The asset plugin supports groups for the cases where you have different
@@ -182,7 +197,20 @@ class Roda
     # and it will run in compiled mode, assuming that the compiled asset files
     # already exist.
     #
-    # ==== Postprocessing
+    # ==== On Heroku
+    #
+    # Heroku supports precompiling the assets when using Roda.  You just need to
+    # add an assets:precompile task, similar to this:
+    #
+    #   namespace :assets do
+    #     desc "Precompile the assets"
+    #     task :precompile do
+    #       require './app'
+    #       App.compile_assets
+    #     end
+    #   end
+    #
+    # == Postprocessing
     #
     # If you pass a callable object to the :postprocessor option, it will be called
     # before an asset is served.
@@ -202,19 +230,6 @@ class Roda
     #     end
     #   }
     #
-    # ==== On Heroku
-    #
-    # Heroku supports precompiling the assets when using Roda.  You just need to
-    # add an assets:precompile task, similar to this:
-    #
-    #   namespace :assets do
-    #     desc "Precompile the assets"
-    #     task :precompile do
-    #       require './app'
-    #       App.compile_assets
-    #     end
-    #   end
-    #
     # == External Assets/Assets from Gems
     #
     # The assets plugin only supports loading assets files underneath the assets
@@ -586,39 +601,16 @@ class Roda
       end
 
       module InstanceMethods
-        # Return a string containing html tags for the given asset type.
-        # This will use a script tag for the :js type and a link tag for
-        # the :css type.
-        #
-        # To return the tags for a specific asset group, use an array for
-        # the type, such as [:css, :frontend].
-        #
-        # When the assets are not compiled, this will result in a separate
-        # tag for each asset file.  When the assets are compiled, this will
-        # result in a single tag to the compiled asset file.
-        def assets(type, attrs = nil)
+        # Return an array of paths for the given asset type and optionally
+        # asset group. See the assets function documentation for details.
+        def assets_paths(type)
           o = self.class.assets_opts
           type, *dirs = type if type.is_a?(Array)
           stype = type.to_s
           ru = Rack::Utils
 
-          attrs = if attrs
-            attrs.map{|k,v| "#{k}=\"#{ru.escape_html(v.to_s)}\""}.join(SPACE)
-          else
-            EMPTY_STRING
-          end
-
-          if type == :js
-            tag_start = "<script type=\"text/javascript\" #{attrs} src=\""
-            tag_end = JS_END
-          else
-            tag_start = "<link rel=\"stylesheet\" #{attrs} href=\""
-            tag_end = CSS_END
-          end
-
           url_prefix = request.script_name if self.class.opts[:add_script_name]
 
-          # Create a tag for each individual file
           if compiled = o[:compiled]
             asset_host = o[:compiled_asset_host]
             if dirs && !dirs.empty?
@@ -636,7 +628,9 @@ class Roda
                 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}"
+              [ "#{asset_host}#{url_prefix}/#{o[:"compiled_#{stype}_prefix"]}.#{ukey}.#{stype}#{integrity}" ]
+            else
+              []
             end
           else
             asset_dir = o[type]
@@ -644,8 +638,42 @@ class Roda
               dirs.each{|f| asset_dir = asset_dir[f]}
               prefix = "#{dirs.join(SLASH)}/" if o[:group_subdirs]
             end
-            Array(asset_dir).map{|f| "#{tag_start}#{url_prefix}/#{o[:"#{stype}_prefix"]}#{prefix}#{f}#{o[:"#{stype}_suffix"]}#{tag_end}"}.join(NEWLINE)
+            Array(asset_dir).map{|f| "#{url_prefix}/#{o[:"#{stype}_prefix"]}#{prefix}#{f}#{o[:"#{stype}_suffix"]}"}
+          end
+        end
+
+        # Return a string containing html tags for the given asset type.
+        # This will use a script tag for the :js type and a link tag for
+        # the :css type.
+        #
+        # To return the tags for a specific asset group, use an array for
+        # the type, such as [:css, :frontend].
+        #
+        # When the assets are not compiled, this will result in a separate
+        # tag for each asset file.  When the assets are compiled, this will
+        # result in a single tag to the compiled asset file.
+        def assets(type, attrs = nil)
+          ru = Rack::Utils
+          attrs = if attrs
+            attrs.map{|k,v| "#{k}=\"#{ru.escape_html(v.to_s)}\""}.join(SPACE)
+          else
+            EMPTY_STRING
           end
+
+          ltype = if type.is_a?(Array)
+            type[0]
+          else
+            type
+          end
+          if ltype == :js
+            tag_start = "<script type=\"text/javascript\" #{attrs} src=\""
+            tag_end = JS_END
+          else
+            tag_start = "<link rel=\"stylesheet\" #{attrs} href=\""
+            tag_end = CSS_END
+          end
+
+          assets_paths(type).map{|p| "#{tag_start}#{p}#{tag_end}"}.join(NEWLINE)
         end
 
         # Render the asset with the given filename.  When assets are compiled,

data/lib/roda/plugins/assets_preloading.rb

@@ -0,0 +1,91 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The assets_preloading plugin generates html tags or a header value
+    # to facilitate browser preloading of your assets. This allows
+    # compatible browsers to fetch assets before they are required,
+    # streamlining page rendering.
+    #
+    # For a list of compatible browsers, see
+    # http://caniuse.com/#search=link-rel-preload
+    #
+    # The plugin provides two functions - preload_assets_link_header and
+    # preload_assets_link_tags. The resulting preloading should be
+    # identical, it is up to you which system you prefer.
+    #
+    # preload_assets_link_header returns a string suitable for populating
+    # the response Link header:
+    #
+    #   response.headers['Link'] = preload_assets_link_header(:css)
+    #   # Link header will now contain something like:
+    #   # </assets/app.css>;rel="preload";as="style"
+    #
+    # preload_assets_link_tags returns a string to drop into your
+    # templates containing link tags:
+    #
+    #   preload_assets_link_tags(:css)
+    #   # returns <link href="/assets/app.css" rel="preload" as="style">
+    #
+    # Note that these link tags are different to the usual asset
+    # declarations in markup; this will only instruct a compatible browser
+    # to fetch the file and cache it for later; the browser will not parse
+    # the asset until it encounters a traditional link or script tag.
+    #
+    # You must still setup and link to your assets as you did previously.
+    #
+    # Both functions can be passed any combination of asset types or
+    # asset groups, as multiple arguments:
+    #
+    #   # generate tags for css assets and the app js asset group
+    #   preload_assets_link_tags(:css, [:js, :app], [:js, :bar])
+    #
+    #   # generate Link header for css assets and js asset groups app and bar
+    #   preload_assets_link_header(:css, [:js, :app])
+    #
+    module AssetsPreloading
+      TYPE_AS = {
+        :css => 'style'.freeze,
+        :js => 'script'.freeze,
+      }.freeze
+      COMMA = ",".freeze
+      NEWLINE= "\n".freeze
+
+      # Depend on the assets plugin, as we'll be calling some functions in it.
+      def self.load_dependencies(app)
+        app.plugin :assets
+      end
+
+      module InstanceMethods
+        # Return a string of <link> tags for the given asset
+        # types/groups.
+        def preload_assets_link_tags(*args)
+          _preload_assets_array(args).map{|path, as| "<link href=\"#{path}\" rel=\"preload\" as=\"#{as}\">"}.join(NEWLINE)
+        end
+
+        # Return a string suitable for a Link header for the
+        # given asset types/groups.
+        def preload_assets_link_header(*args)
+          _preload_assets_array(args).map{|path, as| "<#{path}>;rel=preload;as=#{as}"}.join(COMMA)
+        end
+
+        private
+
+        # Return an array of paths/as pairs for the given asset
+        # types and/or groups.
+        def _preload_assets_array(assets)
+          assets.map do |type|
+            paths = assets_paths(type)
+            type = type[0] if type.is_a?(Array)
+            as = TYPE_AS[type]
+
+            paths.map{|path| [path, as]}
+          end.flatten(1)
+        end
+      end
+    end
+
+    register_plugin(:assets_preloading, AssetsPreloading)
+  end
+end

data/lib/roda/plugins/head.rb

@@ -26,6 +26,10 @@ class Roda
     # HEAD requests for +/+, +/a+, and +/b+ will all return 200 status
     # with an empty body.
     #
+    # This plugin also works with the not_allowed plugin if it is loaded
+    # after the not_allowed plugin.  In that case, if GET is one of Allow
+    # header options, then HEAD will be as well.
+    #
     # NOTE: if you have a public facing website it is recommended that
     # you enable this plugin. Search engines and other bots may send a
     # HEAD request prior to crawling a page with a GET request. Without
@@ -59,6 +63,13 @@ class Roda
         def match_method(method)
           super || (!method.is_a?(Array) && head? && method.to_s.upcase == 'GET')
         end
+
+        # Work with the not_allowed plugin so that if GET is one
+        # of the Allow header options, then HEAD is as well.
+        def method_not_allowed(verbs)
+          verbs = verbs.sub('GET', 'HEAD, GET')
+          super
+        end
       end
     end
 

data/lib/roda/plugins/not_allowed.rb

@@ -102,7 +102,7 @@ class Roda
 
         # Setup methods for all verbs.  If inside an is block and not given
         # arguments, record the verb used.  If given an argument, add an is
-        # check with the argu
+        # check with the arguments.
         %w'get post delete head options link patch put trace unlink'.each do |verb|
           if ::Rack::Request.method_defined?("#{verb}?")
             class_eval(<<-END, __FILE__, __LINE__+1)

data/lib/roda/plugins/public.rb

@@ -41,7 +41,7 @@ class Roda
         # Serve files from the public directory if the file exists and this is a GET request.
         def public
           if is_get?
-            path = PARSER.unescape(remaining_path)
+            path = PARSER.unescape(real_remaining_path)
             return if path.include?(NULL_BYTE)
 
             roda_opts = roda_class.opts
@@ -89,7 +89,9 @@ class Roda
         def public_file_readable?(path)
           ::File.file?(path) && ::File.readable?(path)
         rescue SystemCallError
+          # :nocov:
           false
+          # :nocov:
         end
 
         if ::Rack.release > '2'

data/lib/roda/plugins/static_routing.rb

@@ -0,0 +1,134 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The static_routing plugin adds static_* routing class methods for handling
+    # static routes (i.e. routes with static paths, no placeholders).  These
+    # routes are processed before the normal routing tree and designed for
+    # maximum performance.  This can be substantially faster than Roda's normal
+    # tree based routing if you have large numbers of static routes, about 3-4x
+    # for 100-10000 static routes.  Example:
+    #
+    #   plugin :static_routing
+    #   
+    #   static_route '/foo' do |r|
+    #     @var = :foo
+    #
+    #     r.get do
+    #       'Not actually reached'
+    #     end
+    #
+    #     r.post{'static POST /#{@var}'}
+    #   end
+    #
+    #   static_get '/foo' do |r|
+    #     'static GET /foo'
+    #   end
+    #
+    #   route do |r|
+    #     'Not a static route'
+    #   end
+    #
+    # A few things to note in the above example.  First, unlike most other
+    # routing methods in Roda, these take the full path of the request, and only
+    # match if r.path_info matches exactly.  This is why you need to include the
+    # leading slash in the path argument.
+    #
+    # Second, the static_* routing methods only take a single string argument for
+    # the path, they do not acccept other options, and do not handle placeholders
+    # in strings.  For any routes needing placeholders, you should use Roda's
+    # routing tree.
+    #
+    # There are separate static_* methods for each type of request method, and these
+    # request method specific routes are tried first.  There is also a static_route
+    # method that will match regardless of the request method, if there is no
+    # matching request methods specific route.  This is why the static_get
+    # method call takes precedence over the static_route method call for /foo.
+    # As shown above, you can use Roda's routing tree methods inside the
+    # static_route block to have shared behavior for different request methods,
+    # while still having handling the request methods differently.
+    module StaticRouting
+      def self.configure(app)
+        app.opts[:static_routes] = {}
+      end
+
+      module ClassMethods
+        # Freeze the static route metadata when freezing the app.
+        def freeze
+          super
+          opts[:static_routes].freeze
+          opts[:static_routes].each_value(&:freeze)
+        end
+
+        # Duplicate static route metadata in subclass.
+        def inherited(subclass)
+          super
+          static_routes = subclass.opts[:static_routes]
+          opts[:static_routes].each do |k, v|
+            static_routes[k] = v.dup
+          end
+        end
+
+        # Add a static route for any request method.  These are
+        # tried after the request method specific static routes (e.g.
+        # static_get), but allow you to use Roda's routing tree
+        # methods inside the route for handling shared behavior while
+        # still allowing request method specific handling.
+        def static_route(path, &block)
+          add_static_route(nil, path, &block)
+        end
+        
+        # Return the static route for the given request method and path.
+        def static_route_for(method, path)
+          if h = opts[:static_routes][path]
+            h[method] || h[nil]
+          end
+        end
+
+        [:get, :post, :delete, :head, :options, :link, :patch, :put, :trace, :unlink].each do |meth|
+          request_method = meth.to_s.upcase
+          define_method("static_#{meth}") do |path, &block|
+            add_static_route(request_method, path, &block)
+          end
+        end
+
+        private
+
+        # Add a static route for the given method.
+        def add_static_route(method, path, &block)
+          (opts[:static_routes][path] ||= {})[method] = block
+        end
+      end
+
+      module InstanceMethods
+        # If there is a static routing method for the given path, call it
+        # instead having the routing tree handle the request.
+        def call
+          r = @_request
+          path_info = r.env['PATH_INFO']
+          if route = self.class.static_route_for(r.request_method, r.path_info)
+            catch(:halt){r.static_route(&route)}
+          else
+            super
+          end
+        end
+      end
+
+      module RequestMethods
+        # Assume that this request matches a static route, setting
+        # the remaining path to the emptry string and passing
+        # control to the given block.
+        def static_route(&block)
+          @remaining_path = ''
+
+          always do
+            scope.instance_exec(self, &block)
+          end
+        end
+      end
+    end
+
+    register_plugin(:static_routing, StaticRouting)
+  end
+end

data/lib/roda/plugins/type_routing.rb

@@ -159,14 +159,14 @@ 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(_)
+        # Append the type routing extension back to the path if it was
+        # removed before routing.
+        def real_remaining_path
           if defined?(@type_routing_extension)
-            @remaining_path += ".#{@type_routing_extension}"
+            "#{super}.#{@type_routing_extension}"
+          else
+            super
           end
-          super
         end
 
         private

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

data/spec/matchers_spec.rb

@@ -131,10 +131,15 @@ describe "matchers" do
       r.on "posts/:id" do |id|
         id
       end
+
+      r.on "responses-:id" do |id|
+        id
+      end
     end
 
     body('/posts/123').must_equal '123'
     status('/post/123').must_equal 404
+    body('/responses-123').must_equal '123'
   end
 
   it "should handle multiple params in single string" do

data/spec/plugin/assets_preloading_spec.rb

@@ -0,0 +1,82 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "assets_preloading plugin" do
+  before do
+    app(:bare) do
+      plugin :assets, {
+        :css => ['app.scss'],
+        :js => { :head => ['app.js'] },
+        :path => 'spec/assets',
+        :public => 'spec',
+      }
+      plugin :assets_preloading
+
+      route do |r|
+        r.is 'header-css' do
+          preload_assets_link_header :css
+        end
+        r.is 'header-js' do
+          preload_assets_link_header [:js, :head]
+        end
+        r.is 'header-multiple' do
+          preload_assets_link_header :css, [:js, :head]
+        end
+
+        r.is 'tags-css' do
+          preload_assets_link_tags :css
+        end
+        r.is 'tags-js' do
+          preload_assets_link_tags [:js, :head]
+        end
+        r.is 'tags-multiple' do
+          preload_assets_link_tags :css, [:js, :head]
+        end
+      end
+    end
+  end
+
+  it "preload_assets_link_header returns a well-formed header" do
+    html = body('/header-multiple')
+
+    assets = html.split(',')
+    assets.count.must_equal 2
+
+    assets.each do |asset|
+      parts = asset.split(';')
+      parts.count.must_equal 3
+
+      parts[0].scan(/^<.*>$/).count.must_equal 1
+      parts.select{|c| c == 'rel=preload' }.count.must_equal 1
+      parts.select{|c| c.match(/^as=\w+$/) }.count.must_equal 1
+    end
+  end
+
+  it "preload_assets_link_header returns the correct 'as' for an asset type" do
+    html = body('/header-css')
+    html.scan('as=style').count.must_equal 1
+
+    html = body('/header-js')
+    html.scan('as=script').count.must_equal 1
+  end
+
+  it "preload_assets_link_tags returns well-formed tags" do
+    html = body('/tags-multiple')
+
+    tags = html.scan(/<link.+?>/)
+    tags.count.must_equal 2
+
+    tags.each do |tag|
+      tag.scan(' rel="preload"').count.must_equal 1
+      tag.scan(/ href=".+"/).count.must_equal 1
+      tag.scan(/ as=".+"/).count.must_equal 1
+    end
+  end
+
+  it "preload_assets_link_tags returns the correct 'as' for an asset type" do
+    html = body('/tags-css')
+    html.scan('as="style"').count.must_equal 1
+
+    html = body('/tags-js')
+    html.scan('as="script"').count.must_equal 1
+  end
+end

data/spec/plugin/assets_spec.rb

@@ -43,6 +43,15 @@ if run_tests
           r.is 'test' do
             "#{assets(:css)}\n#{assets([:js, :head])}"
           end
+
+          r.is 'paths_test' do
+            css_paths = assets_paths(:css)
+            js_paths = assets_paths([:js, :head])
+            empty_paths = assets_paths(:empty)
+            { 'css' => css_paths, 'js' => js_paths, 'empty' => empty_paths }.map do |k, a|
+            "#{k}:#{a.class}:#{a.length}:#{a.join(',')}"
+            end.join("\n")
+          end
         end
       end
     end
@@ -139,6 +148,23 @@ if run_tests
       app.assets_opts.values_at(*keys).must_equal [{'Content-Type'=>"C", 'A'=>'B1', 'C'=>'D', 'E'=>'G'}, {'Content-Type'=>"C", 'A'=>'B', 'E'=>'F1'}, {'a'=>'b', 'c'=>'d1'}]
     end
 
+    it 'assets_paths should return arrays of source paths' do
+      html = body('/paths_test')
+      html.scan('css:Array:2:/assets/css/app.scss,/assets/css/raw.css').length.must_equal 1
+      html.scan('js:Array:1:/assets/js/head/app.js').length.must_equal 1
+      html.scan('empty:Array:0').length.must_equal 1
+    end
+
+    it 'assets_paths should return the compiled path in an array' do
+      app.compile_assets
+      html = body('/paths_test')
+      css_hash = app.assets_opts[:compiled]['css']
+      js_hash = app.assets_opts[:compiled]['js.head']
+      html.scan("css:Array:1:/assets/app.#{css_hash}.css").length.must_equal 1
+      html.scan("js:Array:1:/assets/app.head.#{js_hash}.js").length.must_equal 1
+      html.scan('empty:Array:0').length.must_equal 1
+    end
+
     it 'should handle rendering assets, linking to them, and accepting requests for them when not compiling' do
       html = body('/test')
       html.scan(/<link/).length.must_equal 2

data/spec/plugin/not_allowed_spec.rb

@@ -62,5 +62,8 @@ describe "not_allowed plugin" do
     body('/c', 'REQUEST_METHOD'=>'PATCH').must_equal 'c'
     status('/c', 'REQUEST_METHOD'=>'PATCH').must_equal 405
     header('Allow', '/c', 'REQUEST_METHOD'=>'PATCH').must_equal 'GET, POST'
+
+    @app.plugin :head
+    header('Allow', '/c', 'REQUEST_METHOD'=>'PATCH').must_equal 'HEAD, GET, POST'
   end
 end

data/spec/plugin/static_routing_spec.rb

@@ -0,0 +1,108 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "static_routing plugin" do 
+  it "adds support for static routes that are taken before normal routes" do
+    app(:bare) do
+      plugin :static_routing
+      static_route "/foo" do |r|
+        "#{r.path}:#{r.remaining_path}"
+      end
+      static_route "/bar" do |r|
+        r.get{"GET:#{r.path}:#{r.remaining_path}"}
+        r.post{"POST:#{r.path}:#{r.remaining_path}"}
+      end
+      static_get "/bar" do |r|
+        r.get{"GET2:#{r.path}:#{r.remaining_path}"}
+      end
+      static_route "/quux" do |r|
+         r.halt [500, {}, []]
+      end
+
+      route do |r|
+        r.on 'foo' do
+          r.get true do
+            'foo1'
+          end
+          r.root do
+            'foo2'
+          end
+        end
+
+        r.get 'baz' do
+          'baz'
+        end
+      end
+    end
+
+    2.times do
+      body('/foo').must_equal '/foo:'
+      body('/foo/').must_equal 'foo2'
+      body('/bar').must_equal 'GET2:/bar:'
+      body('/bar', 'REQUEST_METHOD'=>'POST').must_equal 'POST:/bar:'
+      status('/bar', 'REQUEST_METHOD'=>'PATCH').must_equal 404
+      body('/baz').must_equal 'baz'
+      status('/quux').must_equal 500
+      @app = Class.new(@app)
+    end
+  end
+
+  it "does not allow placeholders in static routes" do
+    app(:bare) do
+      plugin :static_routing
+      static_route "/:foo" do |r|
+        "#{r.path}:#{r.remaining_path}"
+      end
+
+      route{}
+    end
+    body('/:foo').must_equal '/:foo:'
+    status('/a').must_equal 404
+  end
+
+  it "duplicates data structures in subclasses" do
+    app(:bare) do
+      plugin :static_routing
+      static_route "/foo" do |r|
+        'foo'
+      end
+
+      route{}
+    end
+
+    old_app = @app
+    @app = Class.new(old_app)
+    old_app.static_route '/bar' do |r|
+      'bar1'
+    end
+    old_app.static_get '/foo' do |r|
+      'foop'
+    end
+    @app.static_route '/bar' do |r|
+      'bar2'
+    end
+
+    body('/foo').must_equal 'foo'
+    body('/bar').must_equal 'bar2'
+    body('/foo', 'REQUEST_METHOD'=>'POST').must_equal 'foo'
+    @app = old_app
+    body('/foo').must_equal 'foop'
+    body('/bar').must_equal 'bar1'
+    body('/foo', 'REQUEST_METHOD'=>'POST').must_equal 'foo'
+  end
+
+  it "freezes static routes when app is frozen" do
+    app(:bare) do
+      plugin :static_routing
+      static_route "/foo"
+      freeze
+
+      proc do
+        static_get "/foo"
+      end.must_raise
+
+      proc do
+        static_route "/bar"
+      end.must_raise
+    end
+  end
+end

data/spec/plugin/type_routing_spec.rb

@@ -58,6 +58,7 @@ describe "type_routing plugin" do
       r.run(sup_app)
     end
     
+    body('/a', 'HTTP_ACCEPT' => 'text/html').must_equal 'HTML: html'
     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'
@@ -264,4 +265,32 @@ describe "type_routing plugin" do
     body('/a.html').must_equal 'HTML'
     body('/a.json').must_equal 'JSON'
   end
+
+  it "removes the handled part from r.remaining_path" do
+    app(:bare) do
+      plugin :type_routing
+
+      route do |r|
+        r.is 'a' do
+          r.html{ r.remaining_path }
+        end
+      end
+    end
+
+    body('/a.html').must_equal ''
+  end
+
+  it "overrides r.real_remaining_path correctly" do
+    app(:bare) do
+      plugin :type_routing
+
+      route do |r|
+        r.is 'a' do
+          r.html{ r.real_remaining_path }
+        end
+      end
+    end
+
+    body('/a.html').must_equal '.html'
+  end
 end

data/spec/request_spec.rb

@@ -12,6 +12,18 @@ describe "request.path, .remaining_path, and .matched_path" do
   end
 end
 
+describe "request.real_remaining_path" do
+  it "should be an alias of remaining_path" do
+    app do |r|
+      r.on "foo" do
+        "#{r.remaining_path}:#{r.real_remaining_path}"
+      end
+    end
+
+    body("/foo/bar").must_equal "/bar:/bar"
+  end
+end
+
 describe "request.halt" do
   it "should return rack response as argument given it as argument" do
     app do |r|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 2.17.0
+  version: 2.18.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-13 00:00:00.000000000 Z
+date: 2016-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -183,6 +183,7 @@ extra_rdoc_files:
 - 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.18.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -203,6 +204,7 @@ files:
 - 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.18.0.txt
 - doc/release_notes/2.2.0.txt
 - doc/release_notes/2.3.0.txt
 - doc/release_notes/2.4.0.txt
@@ -216,6 +218,7 @@ files:
 - lib/roda/plugins/_erubis_escaping.rb
 - lib/roda/plugins/all_verbs.rb
 - lib/roda/plugins/assets.rb
+- lib/roda/plugins/assets_preloading.rb
 - lib/roda/plugins/backtracking_array.rb
 - lib/roda/plugins/caching.rb
 - lib/roda/plugins/chunked.rb
@@ -277,6 +280,7 @@ files:
 - lib/roda/plugins/slash_path_empty.rb
 - lib/roda/plugins/static.rb
 - lib/roda/plugins/static_path_info.rb
+- lib/roda/plugins/static_routing.rb
 - lib/roda/plugins/status_handler.rb
 - lib/roda/plugins/streaming.rb
 - lib/roda/plugins/symbol_matchers.rb
@@ -301,6 +305,7 @@ files:
 - spec/opts_spec.rb
 - spec/plugin/_erubis_escaping_spec.rb
 - spec/plugin/all_verbs_spec.rb
+- spec/plugin/assets_preloading_spec.rb
 - spec/plugin/assets_spec.rb
 - spec/plugin/backtracking_array_spec.rb
 - spec/plugin/caching_spec.rb
@@ -361,6 +366,7 @@ files:
 - spec/plugin/shared_vars_spec.rb
 - spec/plugin/sinatra_helpers_spec.rb
 - spec/plugin/slash_path_empty_spec.rb
+- spec/plugin/static_routing_spec.rb
 - spec/plugin/static_spec.rb
 - spec/plugin/status_handler_spec.rb
 - spec/plugin/streaming_spec.rb