roda 2.15.0 → 2.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 625daaffa474b5553308633c41d20b76fa3096d8
-  data.tar.gz: 4bcfc8c8c1258f6860e8ac430ba59679b2c62c69
+  metadata.gz: c3051f95d0665c935a0aa391b7f5b3d4ec3905ec
+  data.tar.gz: c3a81d9c6384dc8708c941fcb8171295fcaff6bc
 SHA512:
-  metadata.gz: 2331dd19bd5efb8c3187df90917c4a23f814d52ec205b553ac1131fb39a787fffc83930ce697011cda5ac6926ab7cf31a209033dfc5589342b9410ff09b6a743
-  data.tar.gz: 0abd741f20b87dbe497eba823357ce323aa1d82f7a8048895afe4d5b47eefeb340e50fdf9c71daa8c9cb2c064a5e4f30cda800aa751a345f84f57d2424a6a617
+  metadata.gz: e6479fd6fffd9fdcefc3c09e3543142668b7cd15b3f52af8fda896d438a174b54c1a8350c5aea6a5745188f5eaec78b5fe3a11405365a1318ff38a0098acd307
+  data.tar.gz: 1a837206ad2a4a158e5c939c0a52107752f3e9c9108255e843db681c1f2a62265ee5ca54ba96071b441ca760de7ee2871cf58822ce9f12ed704fa283fcb786b2

data/CHANGELOG

@@ -1,3 +1,11 @@
+= 2.16.0 (2016-07-13)
+
+* Add type_routing plugin, for routing based on path extensions and Accept headers (Papierkorb, jeremyevans) (#75)
+
+* Add unescape_path plugin, for decoding URL-encoded PATH_INFO before routing (jeremyevans) (#74)
+
+* Add request_headers plugin, for simpler access to request headers (celsworth) (#72)
+
 = 2.15.0 (2016-06-13)
 
 * Add public plugin for r.public method for serving all files in the public directory (jeremyevans)

data/doc/release_notes/2.16.0.txt

@@ -0,0 +1,48 @@
+= New Features
+
+* A type_routing plugin has been added.  This plugin allows routing
+  based on the requested type, which can be submitted either via a
+  file extension or Accept header:
+
+    plugin :type_routing
+
+    route do |r|
+      r.get 'a' do
+        r.html{ "<h1>This is the HTML response</h1>" }
+        r.json{ '{"json": "ok"}' }
+        r.xml{ "<root>This is the XML response</root>" }
+      end
+    end
+
+    # /a or /a.html => HTML response
+    # /a.json => JSON response
+    # /a.xml => XML response
+
+  The response content type is set appropriately when the r.html,
+  r.json, or r.xml block is yielded to.  Using plugin options, you can
+  add support for custom types, and choose whether to use only file
+  extensions or only Accept headers for type matching.
+
+* A request_headers plugin has been added. This allows easier access
+  to request headers.  For example, to access a header called
+  X-My-Header, by default you would need to use the CGI mangled name:
+    
+    r.env['HTTP_X_MY_HEADER']
+
+  The request_headers plugin allows the easier to use:
+
+    r.headers['X-My-Header']
+
+* An unescape_path plugin has been added.  By default, Roda does not
+  unescape a URL-encoded PATH_INFO before routing.  This plugin allows
+  URL-encoded PATH_INFO to work, supporting %2f as well as / as path
+  separators, and having captures return unescaped values:
+
+    plugin :unescape_path
+  
+    route do |r|
+      # Assume /b/a URL encoded at %2f%62%2f%61
+      r.on :x, /(.)/ do |*x|
+        # x => ['b', 'a']
+      end
+    end

data/lib/roda.rb

@@ -350,7 +350,7 @@ class Roda
         def initialize(scope, env)
           @scope = scope
           @captures = []
-          @remaining_path = env[PATH_INFO]
+          @remaining_path = _remaining_path(env)
           super(env)
         end
 
@@ -722,6 +722,11 @@ class Roda
           SEGMENT
         end
 
+        # The base remaining path to use.
+        def _remaining_path(env)
+          env[PATH_INFO]
+        end
+
         # Backbone of the verb method support, using a terminal match if
         # args is not empty, or a regular match if it is empty.
         def _verb(args, &block)

data/lib/roda/plugins/per_thread_caching.rb

@@ -6,13 +6,9 @@ class Roda
     # The per_thread_caching plugin changes the default cache
     # from being a shared thread safe cache to a separate cache per
     # thread.  This means getting or setting values no longer
-    # needs a mutex on non-MRI ruby implementations, which may be
-    # faster when using a thread pool.  However, since the caches
-    # are no longer shared, this will take up more memory.
-    #
-    # Note that it does not make sense to use this plugin on MRI,
-    # since the default cache on MRI doesn't use a mutex as it
-    # is already thread safe due to the GVL.
+    # needs a mutex, which may be faster when using a thread pool.
+    # However, since the caches are no longer shared, this will
+    # take up more memory.
     #
     # Using this plugin changes the matcher regexp cache to use
     # per-thread caches, and changes the default for future

data/lib/roda/plugins/request_headers.rb

@@ -0,0 +1,83 @@
+# frozen-string-literal: true
+
+require 'set'
+
+class Roda
+  module RodaPlugins
+    # The request_headers plugin provides access to headers sent in the
+    # request in a more natural way than directly accessing the env hash.
+    #
+    # In practise this means you don't need to uppercase, convert dashes
+    # to underscores, or add a HTTP_ prefix.
+    #
+    # For example, to access a header called X-My-Header you
+    # would previously need to do:
+    #
+    #   r.env['HTTP_X_MY_HEADER']
+    #
+    # But with this plugin you can now say:
+    #
+    #   r.headers['X-My-Header']
+    #
+    # The name is actually case-insensitive so x-my-header will work as well.
+    #
+    #
+    # Example:
+    #
+    #   plugin :request_headers
+    #
+    module RequestHeaders
+      module RequestMethods
+        # Provide access to the request headers while normalising indexes.
+        def headers
+          @request_headers ||= Headers.new(@env)
+        end
+      end
+
+      class Headers
+        # Set of environment variable names that don't need HTTP_ prepended to them.
+        CGI_VARIABLES = Set.new(%w'
+          AUTH_TYPE
+          CONTENT_LENGTH
+          CONTENT_TYPE
+          GATEWAY_INTERFACE
+          HTTPS
+          PATH_INFO
+          PATH_TRANSLATED
+          QUERY_STRING
+          REMOTE_ADDR
+          REMOTE_HOST
+          REMOTE_IDENT
+          REMOTE_USER
+          REQUEST_METHOD
+          SCRIPT_NAME
+          SERVER_NAME
+          SERVER_PORT
+          SERVER_PROTOCOL
+          SERVER_SOFTWARE
+        ').freeze
+
+        def initialize(env)
+          @env = env
+        end
+
+        # Returns the value for the given key mapped to @env
+        def [](key)
+          @env[env_name(key)]
+        end
+
+        private
+
+        # Convert a HTTP header name into an environment variable name
+        def env_name(key)
+          key = key.to_s.upcase
+          key.tr!('-', '_')
+          key = 'HTTP_' + key unless CGI_VARIABLES.include?(key)
+          key
+        end
+      end
+    end
+
+    register_plugin(:request_headers, RequestHeaders)
+  end
+end

data/lib/roda/plugins/type_routing.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # Allows to respond to specific request data types. User agents can request
+    # specific data types by either supplying an appropriate +Accept+ header
+    # or by appending it as file extension to the path.
+    #
+    # Example:
+    #
+    #   plugin :type_routing
+    #
+    #   route do |r|
+    #     r.get 'a' do
+    #       r.html{ "<h1>This is the HTML response</h1>" }
+    #       r.json{ '{"json": "ok"}' }
+    #       r.xml{ "<root>This is the XML response</root>" }
+    #       "Unsupported data type"
+    #     end
+    #   end
+    #
+    # This application will handle the following paths:
+    # /a.html :: HTML response
+    # /a.json :: JSON response
+    # /a.xml :: XML response
+    # /a :: HTML, JSON, or XML response, depending on the Accept header
+    #
+    # The response +Content-Type+ header will be set to a suitable value when
+    # the block is matched.
+    #
+    # Note that if no match is found, code will continue to execute, which can
+    # result in unexpected behaviour.  This should only happen if you do not
+    # handle all supported/configured types.  If you want to simplify handling,
+    # you can just place the html handling after the other types, without using
+    # a separate block:
+    #
+    #   route do |r|
+    #     r.get 'a' do
+    #       r.json{ '{"json": "ok"}' }
+    #       r.xml{ "<root>This is the XML response</root>" }
+    #
+    #       "<h1>This is the HTML response</h1>"
+    #     end
+    #   end
+    #
+    # This works correctly because Roda assumes the html type by default.
+    #
+    # To match custom extensions, use the :types option:
+    #
+    #   plugin :type_routing, :types => {
+    #     :yaml => 'application/x-yaml',
+    #     :js => 'application/javascript; charset=utf-8',
+    #   }
+    #
+    #   route do |r|
+    #     r.get 'a' do
+    #       r.yaml{ YAML.dump "YAML data" }
+    #       r.js{ "JavaScript code" }
+    #       # or:
+    #       r.on_type(:js){ "JavaScript code" }
+    #       "Unsupported data type"
+    #     end
+    #   end
+    #
+    # = Plugin options
+    #
+    # The following plugin options are supported:
+    #
+    # :default_type :: The default data type to assume if the client did not
+    #                  provide one. Defaults to +:html+.
+    # :exclude :: Exclude one or more types from the default set (default set
+    #             is :html, :xml, :json).
+    # :types :: Mapping from a data type to its MIME-Type. Used both to match
+    #           incoming requests and to provide +Content-Type+ values.  If the
+    #           value is +nil+, no +Content-Type+ will be set.  The type may
+    #           contain media type parameters, which will be sent to the client
+    #           but ignored for request matching.
+    # :use_extension :: Whether to take the path extension into account.
+    #                   Default is +true+.
+    # :use_header :: Whether to take the +Accept+ header into account.
+    #                Default is +true+.
+    module TypeRouting
+      ACCEPT_HEADER = 'HTTP_ACCEPT'.freeze
+      CONTENT_TYPE_HEADER = 'Content-Type'.freeze
+
+      CONFIGURATION = {
+        :mimes => {
+          'text/json' => :json,
+          'application/json' => :json,
+          'text/xml' => :xml,
+          'application/xml' => :xml,
+          'text/html' => :html,
+        }.freeze,
+        :types => {
+          :json => 'application/json'.freeze,
+          :xml => 'application/xml'.freeze,
+          :html => 'text/html'.freeze,
+        }.freeze,
+        :use_extension => true,
+        :use_header => true,
+        :default_type => :html
+      }.freeze
+
+      def self.configure(app, opts = {})
+        config = (app.opts[:type_routing] || CONFIGURATION).dup
+        [:use_extension, :use_header, :default_type].each do |key|
+          config[key] = opts[key] if opts.has_key?(key)
+        end
+
+        types = config[:types] = config[:types].dup
+        mimes = config[:mimes] = config[:mimes].dup
+
+        Array(opts[:exclude]).each do |type|
+          types.delete(type)
+          mimes.reject!{|_, v| v == type}
+        end
+
+        if mapping = opts[:types]
+          types.merge!(mapping)
+
+          mapping.each do |k, v|
+            if v
+              mimes[v.split(';', 2).first] = k
+            end
+          end
+        end
+
+        types.freeze
+        mimes.freeze
+
+        type_keys = config[:types].keys
+        config[:extension_regexp] = /(.+)\.(#{Regexp.union(type_keys.map(&:to_s))})\z/
+
+        type_keys.each do |type|
+          app::RodaRequest.send(:define_method, type) do |&block|
+            on_type(type, &block)
+          end
+        end
+
+        app.opts[:type_routing] = config.freeze
+      end
+
+      module RequestMethods
+        # Yields if the given +type+ matches the requested data type and halts
+        # the request afterwards, returning the result of the block.
+        def on_type(type, &block)
+          return unless type == requested_type
+          response[CONTENT_TYPE_HEADER] ||= @scope.opts[:type_routing][:types][type]
+          always(&block)
+        end
+
+        # Returns the data type the client requests.
+        def requested_type
+          return @requested_type if defined?(@requested_type)
+
+          opts = @scope.opts[:type_routing]
+          @requested_type = accept_response_type if opts[:use_header]
+          @requested_type ||= opts[:default_type]
+        end
+
+        private
+
+        # Removes a trailing file extension from the path, and sets
+        # the requested type if so.
+        def _remaining_path(env)
+          opts = scope.opts[:type_routing]
+          path = super
+
+          if opts[:use_extension]
+            if m = path.match(opts[:extension_regexp])
+              @requested_type = m[2].to_sym
+              path = m[1]
+            end
+          end
+
+          path
+        end
+
+        # The response type indicated by the Accept request header.
+        def accept_response_type
+          mimes = @scope.opts[:type_routing][:mimes]
+
+          @env[ACCEPT_HEADER].to_s.split(/\s*,\s*/).map do |part|
+            mime, _= part.split(/\s*;\s*/, 2)
+            if sym = mimes[mime]
+              return sym
+            end
+          end
+
+          nil
+        end
+      end
+    end
+
+    register_plugin(:type_routing, TypeRouting)
+  end
+end

data/lib/roda/plugins/unescape_path.rb

@@ -0,0 +1,32 @@
+# frozen-string-literal: true
+
+#
+class Roda
+  module RodaPlugins
+    # The unescape_path plugin decodes a URL-encoded path
+    # before routing.  This fixes routing when the slashes
+    # are URL-encoded as %2f and returns decoded parameters
+    # when matched by symbols or regexps.
+    #
+    #   plugin :unescape_path
+    #
+    #   route do |r|
+    #     # Assume /b/a URL encoded at %2f%62%2f%61
+    #     r.on :x, /(.)/ do |*x|
+    #       # x => ['b', 'a']
+    #     end
+    #   end
+    module UnescapePath
+      module RequestMethods
+        private
+
+        # Unescape the path.
+        def _remaining_path(env)
+          Rack::Utils.unescape(super)
+        end
+      end
+    end
+
+    register_plugin(:unescape_path, UnescapePath)
+  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 = 15
+  RodaMinorVersion = 16
 
   # The patch version of Roda, updated only for bug fixes from the last
   # feature release.

data/spec/plugin/request_headers_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "request_headers plugin" do
+  def header_app(header_name)
+    app(:bare) do
+      plugin :request_headers
+      route do |r|
+        r.on do
+          # return the value of the request header in the response body,
+          # or the static string 'not found' if it hasn't been supplied.
+          r.headers[header_name] || 'not found'
+        end
+      end
+    end
+  end
+
+  it "must add HTTP_ prefix when appropriate" do
+    header_app('Foo')
+    body('/', {'HTTP_FOO' => 'a'}).must_equal 'a'
+  end
+
+  it "must ignore HTTP_ prefix when appropriate" do
+    header_app('Content-Type')
+    body('/', {'CONTENT_TYPE' => 'a'}).must_equal 'a'
+  end
+
+  it "must return nil for non-existant headers" do
+    header_app('X-Non-Existant')
+    body('/').must_equal 'not found'
+  end
+
+  it "must be case-insensitive" do
+    header_app('X-My-Header')
+    body('/', {'HTTP_X_MY_HEADER' => 'a'}).must_equal 'a'
+
+    header_app('x-my-header')
+    body('/', {'HTTP_X_MY_HEADER' => 'a'}).must_equal 'a'
+  end
+end

data/spec/plugin/type_routing_spec.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "type_routing plugin" do
+  before do
+    app(:type_routing) do |r|
+      r.is 'a' do
+        r.html{ "HTML: #{r.requested_type}" }
+        r.json{ "JSON: #{r.requested_type}" }
+        r.xml{ "XML: #{r.requested_type}" }
+        "No match"
+      end
+    end
+  end
+
+  it "uses the file extension in the path" do
+    body('/a').must_equal 'HTML: html'
+    header('Content-Type', '/a').must_equal 'text/html'
+
+    body('/a.html').must_equal 'HTML: html'
+    header('Content-Type', '/a.html').must_equal 'text/html'
+
+    body('/a.json').must_equal 'JSON: json'
+    header('Content-Type', '/a.json').must_equal 'application/json'
+
+    body('/a.xml').must_equal 'XML: xml'
+    header('Content-Type', '/a.xml').must_equal 'application/xml'
+
+    status('/a.yadda').must_equal 404
+  end
+
+  it "uses the Accept header value" do
+    body('/a', 'HTTP_ACCEPT' => 'text/html').must_equal 'HTML: html'
+    header('Content-Type', '/a', 'HTTP_ACCEPT' => 'text/html').must_equal 'text/html'
+
+    body('/a', 'HTTP_ACCEPT' => 'application/json').must_equal 'JSON: json'
+    header('Content-Type', '/a', 'HTTP_ACCEPT' => 'application/json').must_equal 'application/json'
+
+    body('/a', 'HTTP_ACCEPT' => 'application/xml').must_equal 'XML: xml'
+    header('Content-Type', '/a', 'HTTP_ACCEPT' => 'application/xml').must_equal 'application/xml'
+
+    body('/a', 'HTTP_ACCEPT' => 'some/thing').must_equal 'HTML: html'
+    header('Content-Type', '/a', 'HTTP_ACCEPT' => 'some/thing').must_equal 'text/html'
+  end
+
+  it "favors the file extension over the Accept header" do
+    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'
+    header('Content-Type', '/a').must_equal 'text/html'
+  end
+end
+
+describe "type_routing plugin" do
+  it "does not use the file extension if its disabled" do
+    app(:bare) do
+      plugin :type_routing, :use_extension => false
+
+      route do |r|
+        r.is 'a' do
+          r.html{ "HTML" }
+          r.json{ "JSON" }
+        end
+      end
+    end
+
+    status('/a.json').must_equal 404
+    status('/a.html').must_equal 404
+    body('/a', 'HTTP_ACCEPT' => 'text/html').must_equal 'HTML'
+    body('/a', 'HTTP_ACCEPT' => 'application/json').must_equal 'JSON'
+  end
+
+  it "does not use the Accept header if its disabled" do
+    app(:bare) do
+      plugin :type_routing, :use_header => false
+
+      route do |r|
+        r.is 'a' do
+          r.html{ "HTML" }
+          r.json{ "JSON" }
+        end
+      end
+    end
+
+    body('/a', 'HTTP_ACCEPT' => 'text/html').must_equal 'HTML'
+    body('/a', 'HTTP_ACCEPT' => 'application/json').must_equal 'HTML'
+    body('/a.html', 'HTTP_ACCEPT' => 'application/json').must_equal 'HTML'
+    body('/a.json', 'HTTP_ACCEPT' => 'text/html').must_equal 'JSON'
+  end
+
+  it "only eats known file extensions" do
+    app(:bare) do
+      plugin :type_routing
+
+      route do |r|
+        r.is 'a' do
+          r.html{ "HTML" }
+          r.json{ "JSON" }
+          r.xml{ "XML" }
+          raise "Mismatch!"
+        end
+
+        r.is 'a.jpg' do
+          "Okay"
+        end
+      end
+    end
+
+    body('/a.html').must_equal 'HTML'
+    body('/a.json').must_equal 'JSON'
+    body('/a.xml').must_equal 'XML'
+    body('/a.jpg').must_equal 'Okay'
+  end
+
+  it "uses custom data types" do
+    app(:bare) do
+      plugin :type_routing, :types => { :yaml => 'application/x-yaml' }
+
+      route do |r|
+        r.is 'a' do
+          r.html{ "HTML" }
+          r.yaml{ "YAML" }
+          raise "Mismatch!"
+        end
+      end
+    end
+
+    body('/a.html').must_equal 'HTML'
+    body('/a.yaml').must_equal 'YAML'
+    header('Content-Type', '/a.yaml').must_equal 'application/x-yaml'
+  end
+
+  it "handles response-specific type information when using custom types" do
+    app(:bare) do
+      plugin :type_routing, :exclude=>:html, :default_type=>:json, :types => { :html => 'text/html; charset=utf-8' }
+
+      route do |r|
+        r.is 'a' do
+          r.json{ "JSON" }
+          r.html{ "HTML" }
+          raise "Mismatch!"
+        end
+      end
+    end
+
+    body('/a').must_equal 'JSON'
+    body('/a.html').must_equal 'HTML'
+    header('Content-Type', '/a.html').must_equal 'text/html; charset=utf-8'
+    header('Content-Type', '/a', 'HTTP_ACCEPT' => 'text/html').must_equal 'text/html; charset=utf-8'
+  end
+
+  it "Handle nil content type when using custom types" do
+    app(:bare) do
+      plugin :type_routing, :exclude=>:html, :default_type=>:json, :types => { :html => nil}
+
+      route do |r|
+        r.is 'a' do
+          r.html{ "HTML" }
+          r.json{ "JSON" }
+          raise "Mismatch!"
+        end
+      end
+    end
+
+    body('/a').must_equal 'JSON'
+    body('/a.html').must_equal 'HTML'
+    header('Content-Type', '/a.html').must_equal 'text/html'
+    header('Content-Type', '/a', 'HTTP_ACCEPT' => 'text/html').must_equal 'application/json'
+  end
+
+  it "uses custom default type" do
+    app(:bare) do
+      plugin :type_routing, :default_type => :json
+
+      route do |r|
+        r.is 'a' do
+          r.html{ "HTML" }
+          r.json{ "JSON" }
+          raise "Mismatch!"
+        end
+      end
+    end
+
+    body('/a').must_equal 'JSON'
+    body('/a.html').must_equal 'HTML'
+    body('/a.json').must_equal 'JSON'
+  end
+
+  it "supports nil default type" do
+    app(:bare) do
+      plugin :type_routing, :default_type => nil
+
+      route do |r|
+        r.is 'a' do
+          r.html{ "HTML" }
+          r.json{ "JSON" }
+          "None"
+        end
+      end
+    end
+
+    body('/a').must_equal 'None'
+    body('/a.html').must_equal 'HTML'
+    body('/a.json').must_equal 'JSON'
+  end
+
+  it "excludes given types" do
+    app(:bare) do
+      plugin :type_routing, :exclude => [ :xml ]
+
+      route do |r|
+        r.is 'a' do
+          r.html{ "HTML" }
+          r.json{ "JSON" }
+          r.xml{ raise "Mismatch!" }
+          raise "Mismatch"
+        end
+      end
+    end
+
+    body('/a.html').must_equal 'HTML'
+    body('/a.json').must_equal 'JSON'
+    status('/a.xml').must_equal 404
+
+    body('/a', 'HTTP_ACCEPT' => 'text/xml').must_equal 'HTML'
+    body('/a', 'HTTP_ACCEPT' => 'application/json').must_equal 'JSON'
+    body('/a', 'HTTP_ACCEPT' => 'text/xml').must_equal 'HTML'
+    body('/a', 'HTTP_ACCEPT' => 'application/xml').must_equal 'HTML'
+  end
+
+  it "handles loading the plugin multiple times correctly" do
+    app(:bare) do
+      plugin :type_routing, :default_type => :json
+      plugin :type_routing
+
+      route do |r|
+        r.is 'a' do
+          r.html{ "HTML" }
+          r.json{ "JSON" }
+          raise "Mismatch!"
+        end
+      end
+    end
+
+    body('/a').must_equal 'JSON'
+    body('/a.html').must_equal 'HTML'
+    body('/a.json').must_equal 'JSON'
+  end
+end

data/spec/plugin/unescape_path_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path("spec_helper", File.dirname(File.dirname(__FILE__)))
+
+describe "unescape_path_path plugin" do 
+  it "decodes URL-encoded routing path" do
+    app(:unescape_path) do |r|
+      r.on 'b' do
+        r.get /(.)/ do |a|
+          "#{a}-b"
+        end
+      end
+
+      r.get :name do |name|
+        name
+      end
+    end
+
+    body('/a').must_equal 'a'
+    body('/%61').must_equal 'a'
+    body('%2f%61').must_equal 'a'
+    body('%2f%62%2f%61').must_equal 'a-b'
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roda
 version: !ruby/object:Gem::Version
-  version: 2.15.0
+  version: 2.16.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-13 00:00:00.000000000 Z
+date: 2016-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -181,6 +181,7 @@ extra_rdoc_files:
 - doc/release_notes/2.13.0.txt
 - doc/release_notes/2.14.0.txt
 - doc/release_notes/2.15.0.txt
+- doc/release_notes/2.16.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -199,6 +200,7 @@ files:
 - doc/release_notes/2.13.0.txt
 - 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.2.0.txt
 - doc/release_notes/2.3.0.txt
 - doc/release_notes/2.4.0.txt
@@ -264,6 +266,7 @@ files:
 - lib/roda/plugins/public.rb
 - lib/roda/plugins/render.rb
 - lib/roda/plugins/render_each.rb
+- lib/roda/plugins/request_headers.rb
 - lib/roda/plugins/response_request.rb
 - lib/roda/plugins/run_handler.rb
 - lib/roda/plugins/shared_vars.rb
@@ -276,6 +279,8 @@ files:
 - lib/roda/plugins/symbol_matchers.rb
 - lib/roda/plugins/symbol_status.rb
 - lib/roda/plugins/symbol_views.rb
+- lib/roda/plugins/type_routing.rb
+- lib/roda/plugins/unescape_path.rb
 - lib/roda/plugins/view_options.rb
 - lib/roda/plugins/view_subdirs.rb
 - lib/roda/plugins/websockets.rb
@@ -346,6 +351,7 @@ files:
 - spec/plugin/public_spec.rb
 - spec/plugin/render_each_spec.rb
 - spec/plugin/render_spec.rb
+- spec/plugin/request_headers_spec.rb
 - spec/plugin/response_request_spec.rb
 - spec/plugin/run_handler_spec.rb
 - spec/plugin/shared_vars_spec.rb
@@ -357,6 +363,8 @@ files:
 - spec/plugin/symbol_matchers_spec.rb
 - spec/plugin/symbol_status_spec.rb
 - spec/plugin/symbol_views_spec.rb
+- spec/plugin/type_routing_spec.rb
+- spec/plugin/unescape_path_spec.rb
 - spec/plugin/view_options_spec.rb
 - spec/plugin/websockets_spec.rb
 - spec/plugin_spec.rb