padrino-core 0.18.2 → 0.18.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf357f68006699d9e80fa024da18fbf0b64bd7d0365ea2ecfd90c12b0b8a6cfa
-  data.tar.gz: f702562744c51a4dee46da71739b7864ba3ebc1c9c937ddb8d5af3a07efc391c
+  metadata.gz: 8e40ac3a18ee55e92777a0cffe27c3356801c5ff773df28798d7208b7022d127
+  data.tar.gz: 586a5335ad2611ffe9600dbe85e09e4499f9698bc3c37456039234ef519512bf
 SHA512:
-  metadata.gz: 140423832026779eb7731e1145ab1d6d7b7197bf77e85d83c40077f639bcbc3fc0f7ee4ed2bedaee35a6b9b1188ae8ce9437e09fb605c17c605abfbf413c7383
-  data.tar.gz: ea73969e005298405dd22072d18a211634d038a68e53b7c3b9cfead7d29b2471eb06f30b723702f50fa00ab331cdb1a5bc29cbdc98449be874629e91dab50e05
+  metadata.gz: 457e2ddeb208461c25e4b5f4b81b090140ce9399db212969ca8da0114d9290cf2d721740173b13240b22b52e8934e1494a9db4209ba01f785ea84bb119cf7885
+  data.tar.gz: 30c4a57736742138bc8b283f1450b2d78ceb4c208a0f3ff0a29be1518c66b26da6c51dfe729cd994b749387fd348fb57ecb310bade5f7c3544e0edd594272fcb

data/lib/padrino-core/application/authenticity_token.rb

@@ -1,5 +1,8 @@
 module Padrino
   class AuthenticityToken < Rack::Protection::AuthenticityToken
+    # A path with more dots than this isn't exempted by a Regexp: each dot adds forms to compare.
+    MAX_DOTS = 16
+
     def initialize(app, options = {})
       @app = app
       @except = options[:except]
@@ -19,8 +22,21 @@ module Padrino
       return false unless @except
       return @except.call(env) if @except.is_a?(Proc)
 
-      path_info = env['PATH_INFO']
-      @except.any? { |path| path.is_a?(Regexp) ? path.match(path_info) : path == path_info }
+      # A request is excepted only if every form of the path that can reach a route is. This
+      # middleware has no route to ask for a format, so the forms without one count too, unless
+      # String entries name the path as it is. A path with a newline is never excepted.
+      forms = Routing.path_forms(env['PATH_INFO'].to_s)
+      return false if forms.any? { |form| form.include?("\n") }
+      return true if forms.all? { |form| @except.include?(form) }
+      return false if forms.any? { |form| form.count('.') > MAX_DOTS }
+
+      Routing.served_forms(forms).all? { |form| excepted?(form) }
+    end
+
+    private
+
+    def excepted?(form)
+      @except.any? { |path| path.is_a?(Regexp) ? path.match?(form) : path == form }
     end
   end
 end

data/lib/padrino-core/application/routing.rb

@@ -17,6 +17,8 @@ module Padrino
     CONTENT_TYPE_ALIASES = { htm: :html } unless defined?(CONTENT_TYPE_ALIASES)
     # Defines the available route priorities supporting route deferrals.
     ROUTE_PRIORITY = { high: 0, normal: 1, low: 2 } unless defined?(ROUTE_PRIORITY)
+    # What without_extra_slashes gives for a path that doesn't end in a slash.
+    NO_EXTRA_SLASHES = [].freeze unless defined?(NO_EXTRA_SLASHES)
 
     # Raised when a route was invalid or cannot be processed.
     class UnrecognizedException < RuntimeError; end
@@ -51,6 +53,126 @@ module Padrino
         app.extend(ClassMethods)
       end
       alias included registered
+
+      ##
+      # Decodes the %XX escapes in a request path, %2F included; a '+' stays a
+      # plus, as it does for the router and Sinatra. Returns a new UTF-8 string
+      # and leaves +path+ untouched.
+      #
+      # Invalid UTF-8 (such as '/%ff') is kept byte for byte, so the result's
+      # +valid_encoding?+ is false: replacing it would name a different file.
+      # The router matches no route for such a path; callers that compare the
+      # result with Regexps scrub it first.
+      #
+      # @example
+      #   Padrino::Routing.decode_path('/caf%C3%A9/a+b') # => "/café/a+b"
+      #
+      # @api private
+      def decode_path(path)
+        Rack::Utils.unescape_path(path.b).force_encoding(Encoding::UTF_8)
+      end
+
+      ##
+      # Decodes a request path into the form routes are matched against: like
+      # decode_path, but an encoded slash stays '%2F' (from '%2F' or '%2f'), so
+      # it can't split a path segment. Invalid UTF-8 and malformed escapes are
+      # kept as they are; the router matches no route for such a path.
+      #
+      # @example
+      #   Padrino::Routing.decode_route_path('/%70osts%2F1') # => "/posts%2F1"
+      #
+      # @api private
+      def decode_route_path(path)
+        path.b.split(/%2F/i, -1).map { |segment| decode_path(segment) }.join('%2F').force_encoding(Encoding::UTF_8)
+      end
+
+      ##
+      # The forms a request path is compared in, router form first: as the
+      # router matches it (decode_route_path), fully decoded (decode_path), and
+      # as route params receive it (the router form decoded again, as a splat
+      # or param value is). Invalid UTF-8 is scrubbed so Regexps can match it;
+      # duplicates are dropped. +route_path+ is decode_route_path(path), for a
+      # caller that has it already.
+      #
+      # @example
+      #   Padrino::Routing.path_forms('/files%252Freport') # => ["/files%2Freport", "/files/report"]
+      #
+      # @api private
+      def path_forms(path, route_path = decode_route_path(path))
+        return [route_path.scrub] unless path.include?('%')
+
+        [route_path, decode_path(path), decode_path(route_path)].map(&:scrub).uniq
+      end
+
+      ##
+      # Whether a provides condition for +types+ accepts +format+, a Symbol
+      # decoded as route params receive it.
+      #
+      # @example
+      #   Padrino::Routing.provided_format?(%i[html json], :json) # => true
+      #
+      # @api private
+      def provided_format?(types, format)
+        !([:any, format] & types).empty?
+      end
+
+      ##
+      # Whether an app with +settings+ answers a format its provides
+      # conditions don't accept with 406 itself (treat_format_as_accept),
+      # instead of handing the request on.
+      #
+      # @api private
+      def treat_format_as_accept?(settings)
+        settings.respond_to?(:treat_format_as_accept) && settings.treat_format_as_accept ? true : false
+      end
+
+      ##
+      # A path with trailing slashes also counts with none and with one, as the
+      # router serves '/posts/' from a '/posts' route. A path that doesn't end
+      # in a slash gives [], and a path of slashes only gives ['', '/'].
+      #
+      # @example
+      #   Padrino::Routing.without_extra_slashes('/posts//') # => ["/posts", "/posts/"]
+      #
+      # @api private
+      def without_extra_slashes(path)
+        return NO_EXTRA_SLASHES unless path.end_with?('/')
+
+        index = path.rindex(%r{[^/]})
+        stripped = index ? path[0..index] : ''
+        [stripped, "#{stripped}/"]
+      end
+
+      ##
+      # Yields the forms the router may serve a request path as, without
+      # knowing the route: each of +forms+ (path_forms) and, for each form
+      # found, the form without its trailing slashes and with one
+      # (without_extra_slashes), and the form up to the last dot of its last
+      # segment, as a route can capture what follows as a format. Walking
+      # those in turn gives the form up to each such dot. Each form is yielded
+      # once, as it is found, so a caller can stop early. Returns an
+      # Enumerator without a block.
+      #
+      # @example
+      #   Padrino::Routing.served_forms(['/feed.json//']).to_a # => ["/feed.json//", "/feed.json", "/feed.json/", "/feed"]
+      #
+      # @api private
+      def served_forms(forms)
+        return enum_for(__method__, forms) unless block_given?
+
+        seen = {}
+        queue = forms.dup
+        while (form = queue.shift)
+          next if seen.key?(form)
+
+          seen[form] = true
+          yield form
+          queue.concat(without_extra_slashes(form).reject(&:empty?))
+          slash = form.rindex('/').to_i
+          last = form.rindex('.')
+          queue << form[0, last] if last && last > slash
+        end
+      end
     end
 
     # Class methods responsible for enhanced routing for controllers.
@@ -291,6 +413,8 @@ module Padrino
 
       def reset_router!
         @deferred_routes = nil
+        # Keep only the provides formats of conditions no route has taken yet (provides_format).
+        @_provided_formats&.keep_if { |cond, _| @conditions.any? { |pending| pending.equal?(cond) } }
         router.reset!
       end
 
@@ -569,6 +693,7 @@ module Padrino
 
         conditions, @conditions = @conditions, []
         route.custom_conditions.concat(conditions)
+        route.provided_formats = conditions.filter_map { |cond| @_provided_formats[cond] } if @_provided_formats
 
         invoke_hook(:padrino_route_added, route, verb, path, args, options, block)
 
@@ -730,6 +855,7 @@ module Padrino
         provides_format(*types)
       end
 
+      # Each route records the formats of its provides conditions (PathRouter::Route#provided_formats).
       def provides_format(*types)
         mime_types = types.map { |type| mime_type(CONTENT_TYPE_ALIASES[type] || type) }
         condition do
@@ -754,6 +880,8 @@ module Padrino
             catch_all ? true : halt(406)
           end
         end
+        (@_provided_formats ||= {}.compare_by_identity)[@conditions.last] = types
+        @conditions
       end
 
       ##
@@ -876,8 +1004,7 @@ module Padrino
       #
       def static_file?(path_info)
         return unless (public_dir = settings.public_folder)
-        # Decode the path the way Sinatra's static! and the router do: %XX only, so '+' stays a plus.
-        file = Rack::Utils.unescape_path(path_info.b).force_encoding(Encoding::UTF_8)
+        file = Routing.decode_path(path_info)
         [File.expand_path(public_dir), settings.shared_public_folder].compact.each do |dir|
           path = "#{dir}#{file}"
           next unless Rack::Utils.valid_path?(path)
@@ -930,14 +1057,12 @@ module Padrino
       end
 
       def provides_format?(types, format)
-        if ([:any, format] & types).empty?
-          # Per rfc2616-sec14:
-          # Answer with 406 if accept is given but types to not match any provided type.
-          halt 406 if settings.respond_to?(:treat_format_as_accept) && settings.treat_format_as_accept
-          false
-        else
-          content_type(format || :html)
-        end
+        return content_type(format || :html) if Routing.provided_format?(types, format)
+
+        # Per rfc2616-sec14:
+        # Answer with 406 if accept is given but types to not match any provided type.
+        halt 406 if Routing.treat_format_as_accept?(settings)
+        false
       end
 
       def mime_symbol(media_type)
@@ -949,7 +1074,20 @@ module Padrino
         base.filters[type].each { |block| instance_eval(&block) }
       end
 
+      # Runs the app's before filters for the route being tried. Each runs to its end at most once
+      # for a level of routes, so one with no match on a route, or that passed on it, gets another
+      # chance on the next, and a request that ends up elsewhere doesn't run them again.
+      def before_filter!(base = settings)
+        before_filter!(base.superclass) if base.superclass.respond_to?(:filters)
+        base.filters[:before].each do |block|
+          next if @_ran_filters[block]
+
+          @_ran_filters[block] = true unless Filter::SKIPPED.equal?(instance_eval(&block))
+        end
+      end
+
       def dispatch!
+        @_ran_filters = {}.compare_by_identity
         @params = defined?(Sinatra::IndifferentHash) ? Sinatra::IndifferentHash[@request.params] : indifferent_params(@request.params)
         force_encoding(@params)
         invoke do
@@ -957,7 +1095,7 @@ module Padrino
           route!
         end
       rescue ::Exception => e
-        filter! :before if e.is_a? ::Sinatra::NotFound
+        catch(:pass) { before_filter! } if e.is_a? ::Sinatra::NotFound
         invoke { @boom_handled = handle_exception!(e) }
       ensure
         @boom_handled || begin
@@ -1013,7 +1151,12 @@ module Padrino
         @params[:format] = params[:format] if params[:format]
         @params[:captures] = captured_params if !captured_params.empty? && route.path.is_a?(Regexp)
 
-        filter! :before if first_time
+        @_ran_filters.clear if first_time
+        passed = catch(:pass) do
+          before_filter!
+          :filtered
+        end
+        return passed unless passed == :filtered
 
         catch(:pass) do
           (route.before_filters - settings.filters[:before]).each { |block| instance_eval(&block) }

data/lib/padrino-core/filter.rb

@@ -1,5 +1,15 @@
 module Padrino
   class Filter
+    PATH_OPTIONS = %i[path path_info].freeze
+    # The env keys that hold the forms of the request's path_info and path (path_entry), and route_cuts.
+    PATH_FORMS_KEYS = { path_info: 'padrino.decoded_path_info'.freeze, path: 'padrino.decoded_path'.freeze }.freeze
+    ROUTE_CUTS_KEY = 'padrino.route_cuts'.freeze
+    NO_ROUTE_CUTS = [[].freeze, [].freeze].freeze
+    NOT_FORMAT_DELIMITER = %r{[^./]}.freeze
+    MAX_FORMAT_DELIMITER = 3 # ceiling: the longest delimiter format_cuts takes before a format; raise it for a route with a longer one
+    # What a filter's proc returns when it doesn't apply to the route, so it is decided again.
+    SKIPPED = Object.new.freeze
+
     attr_reader :block
 
     def initialize(mode, scoped_controller, options, args, &block)
@@ -10,18 +20,18 @@ module Padrino
       @block = block
     end
 
-    def apply?(request)
-      detect = match_with_arguments?(request) || match_with_options?(request)
+    # +settings+, the settings of the app running the request, decide how its routes answer a
+    # format they don't provide (format_cuts).
+    def apply?(request, settings = nil)
+      detect = match_with_arguments?(request, settings) || match_with_options?(request, settings)
       detect ^ !@mode
     end
 
     def to_proc
-      if @args.empty? && @options.empty?
-        block
-      else
-        filter = self
-        proc { instance_eval(&filter.block) if filter.apply?(request) }
-      end
+      return block if @args.empty? && @options.empty?
+
+      filter = self
+      proc { filter.apply?(request, settings) ? instance_eval(&filter.block) : SKIPPED }
     end
 
     private
@@ -30,23 +40,177 @@ module Padrino
       @scoped_controller_name ||= Array(@scoped_controller).join('_')
     end
 
-    def match_with_arguments?(request)
+    def match_with_arguments?(request, settings)
       route = request.route_obj
-      path = request.path_info
       @args.any? do |argument|
         if argument.instance_of?(Symbol)
           next unless route
           name = route.name
           argument == name || name == [scoped_controller_name, argument].join(' ').to_sym
         else
-          argument === path
+          entry = path_entry(request)
+          match_path?(argument, request, settings, all_paths(entry), entry)
         end
       end
     end
 
-    def match_with_options?(request)
+    # +paths+ holds every decoded form of the path (all_paths), and for the path and path_info
+    # options the path as given too. A filter runs if one of them, or one of the forms route_forms
+    # gives for it, matches. An :except filter is skipped only if every one of them matches
+    # exactly, and none has a newline. +info+ is the path_entry of path_info, when the caller has it.
+    def match_path?(argument, request, settings, paths, info = nil)
+      return paths.all? { |path| !path.include?("\n") && argument === path } unless @mode
+
+      filter_paths(request, settings, paths, info || path_entry(request)).any? { |form| argument === form }
+    end
+
+    # +paths+ and the forms route_forms gives for each, once per request for each route run and
+    # each list of paths (with no route, kept on +entry+).
+    def filter_paths(request, settings, paths, entry)
+      suffixes, cuts, cache = route_cuts(request, settings, entry)
+      cache ||= (entry[:filter_paths] ||= {})
+      cache[paths] ||= paths.flat_map { |path| route_forms(path, suffixes, cuts) }.uniq.freeze
+    end
+
+    # The router also serves '/posts/' from a '/posts' route (PathRouter::Compiler#match?), and
+    # '/posts.json' from a route that captures a format: +path+ also counts without each format
+    # suffix of the route, each of those without its trailing slashes and with one, and with each
+    # cut applied (a suffix of the path and what replaces it) when it ends with that suffix.
+    def route_forms(path, suffixes, cuts)
+      forms = [path]
+      suffixes.each { |suffix| forms << path.delete_suffix(suffix) }
+      forms.concat(forms.flat_map { |form| Routing.without_extra_slashes(form) })
+      cuts.each { |suffix, rest| forms << "#{path.delete_suffix(suffix)}#{rest}" if path.end_with?(suffix) }
+      forms
+    end
+
+    # The format suffixes (format_suffixes) and cuts (format_cuts) of the route being run, and a
+    # cache for filter_paths, once per route, path and Routing.treat_format_as_accept? setting for
+    # the request. No suffixes or cuts, and no cache, without a route. Positive filters use both, as
+    # each gives forms the other doesn't: a suffix drops the format from every decoded form for any
+    # route that captures one, and a cut, for a route whose only capture is its format, also drops
+    # the delimiter before it ('/data' for '/data-json' from '/data(-:format)?').
+    def route_cuts(request, settings, entry)
+      route = request.route_obj
+      return NO_ROUTE_CUTS unless route
+
+      accept = Routing.treat_format_as_accept?(settings)
+      store = ((request.env[ROUTE_CUTS_KEY] ||= {})[accept] ||= {}.compare_by_identity)
+      memo(store, route, entry[:path]) do
+        [format_suffixes(route, all_paths(entry)), format_cuts(route, route_path(entry), accept), {}]
+      end
+    end
+
+    # What each of +forms+ has after what +route+ takes as the format-less path.
+    def format_suffixes(route, forms)
+      forms.filter_map do |form|
+        match = route.match(form)
+        format_suffix(form, match) if match.respond_to?(:names) && match.names.include?('format')
+      end
+    end
+
+    # A format ends the path, and a slash before it starts another segment, not a format. A route
+    # with an optional format can leave its dot behind without one.
+    def format_suffix(form, match)
+      offset = match.begin('format')
+      return suffix_after(form, form) unless offset
+
+      before = form[0...offset]
+      return if before.end_with?('/') || form.index(%r{[^/]}, match.end('format'))
+
+      suffix_after(form, before)
+    end
+
+    # What +form+ has after +before+ without its trailing delimiters, keeping one slash in the path.
+    def suffix_after(form, before)
+      size = (before.rindex(NOT_FORMAT_DELIMITER) || -1) + 1
+      form[size] == '/' ? form[(size + 1)..] : form[size..]
+    end
+
+    # For a route whose only capture is a format that it captured at the end of +form+, before
+    # slashes only, and that it serves (provided?): +form+ cut at the longest prefix, from the start
+    # of the format back to MAX_FORMAT_DELIMITER characters before it, that the same route matches
+    # without a format, and that prefix with one slash if the route matches that too. None for a
+    # route that requires its format, a route with another param or splat, and a Regexp route.
+    def format_cuts(route, form, accept)
+      matcher = route.matcher
+      return [] unless matcher.mustermann? && matcher.names == ['format']
+
+      match = route.match(form)
+      from, to = match.offset('format') if match
+      return [] unless from && from < to && form[to..].count('^/').zero? && provided?(route, match['format'], accept)
+
+      at = from.downto([from - MAX_FORMAT_DELIMITER, 0].max).find { |cut| without_format?(route, form[0, cut]) }
+      return [] unless at
+
+      suffix = form[at..]
+      without_format?(route, "#{form[0, at]}/") ? [[suffix, ''], [suffix, '/']] : [[suffix, '']]
+    end
+
+    # Whether the route matches +path+ as the router does, also without one trailing slash, with no format.
+    def without_format?(route, path)
+      match = route.match(path)
+      match && match['format'].nil?
+    end
+
+    # Whether the route serves +format+, as captured from the path the router matches: each of its
+    # provides conditions accepts it as route params receive it (provides_format?), or the app
+    # answers 406 for it itself instead of handing the request on (+accept+,
+    # Routing.treat_format_as_accept?).
+    def provided?(route, format, accept)
+      return true if accept
+
+      format = Routing.decode_path(format).scrub.to_sym
+      Array(route.provided_formats).all? { |types| Routing.provided_format?(types, format) }
+    end
+
+    # The memo of the request's path_info or path (+name+) that the forms below are kept in, once
+    # per request, and again if the path changes (a mounted app sees its own).
+    def path_entry(request, name = :path_info)
+      path = request.send(name)
+      memo(request.env, PATH_FORMS_KEYS.fetch(name), path) { |stored| { path: stored } }
+    end
+
+    # The path as the router matches it.
+    def route_path(entry)
+      entry[:route] ||= decoded_route_path(entry).scrub
+    end
+
+    # Every decoded form of the path, router form first (Routing.path_forms).
+    def all_paths(entry)
+      entry[:all] ||= Routing.path_forms(entry[:path], decoded_route_path(entry))
+    end
+
+    # The path as given, scrubbed.
+    def raw_path(entry)
+      entry[:raw] ||= entry[:path].dup.force_encoding(Encoding::UTF_8).scrub
+    end
+
+    def decoded_route_path(entry)
+      entry[:decoded] ||= Routing.decode_route_path(entry[:path])
+    end
+
+    # The block's value for +key+ in +store+, computed once for each +path+. The block gets the
+    # copy of +path+ the memo keeps.
+    def memo(store, key, path)
+      cached = store[key]
+      return cached[1] if cached && cached[0] == path
+
+      stored = path.dup
+      value = yield(stored)
+      store[key] = [stored, value]
+      value
+    end
+
+    def match_with_options?(request, settings)
       user_agent = request.user_agent
-      @options.any? { |name, value| value === (name == :agent ? user_agent : request.send(name)) }
+      @options.any? do |name, value|
+        next value === user_agent if name == :agent
+        next value === request.send(name) unless PATH_OPTIONS.include?(name)
+
+        entry = path_entry(request, name)
+        match_path?(value, request, settings, [raw_path(entry), *all_paths(entry)].uniq, name == :path_info ? entry : nil)
+      end
     end
   end
 end

data/lib/padrino-core/path_router/compiler.rb

@@ -20,7 +20,7 @@ module Padrino
         return if compiled?
         @routes.each_with_index do |route, index|
           route.index = index
-          route.regexp = /(?<_#{index}>#{route.matcher.to_regexp})/
+          route.regexp = /\A(?<_#{index}>#{route.matcher.to_regexp})\z/
         end
         @compiled = true
       end
@@ -93,26 +93,18 @@ module Padrino
       # Decode env["PATH_INFO"]. Returns nil when the path doesn't decode to valid text
       # (a malformed or non-UTF-8 escape such as "/%ff"), so it matches no route.
       #
+      # A path that decodes to a newline, as routes see it or as route params decode it again
+      # (a '%0A' left by '%250A'), matches no route either.
+      #
       def decode_pattern(pattern)
-        decoded = decode_uri(encode_default_external(pattern))
-        decoded if decoded.valid_encoding?
+        pattern = pattern.encode(Encoding.default_external)
+        return if pattern.match?(/%(?!\h\h)/)
+
+        decoded = Padrino::Routing.decode_route_path(pattern)
+        decoded if decoded.valid_encoding? && !decoded.match?(/\n|%0a/i)
       rescue ArgumentError, EncodingError
         nil
       end
-
-      ##
-      # Encode string with Encoding.default_external
-      #
-      def encode_default_external(string)
-        string.encode(Encoding.default_external)
-      end
-
-      ##
-      # Decode uri escape sequences
-      #
-      def decode_uri(string)
-        string.split(/%2F|%2f/, -1).map { |part| Rack::Utils.unescape(part.gsub('+', '%2B')) }.join('%2F')
-      end
     end
   end
 end

data/lib/padrino-core/path_router/matcher.rb

@@ -19,13 +19,19 @@ module Padrino
       # Matches a pattern with the route matcher.
       #
       def match(pattern)
-        if (match_data = handler.match(pattern))
+        if (match_data = whole_regexp.match(pattern))
           match_data
         elsif pattern != '/' && pattern.end_with?('/')
-          handler.match(pattern[0..-2])
+          whole_regexp.match(pattern[0..-2])
         end
       end
 
+      # The handler, anchored to the whole path as PathRouter::Compiler matches routes
+      # (Mustermann's \Z and a Regexp route's ^$ stop before a newline).
+      def whole_regexp
+        @whole_regexp ||= to_regexp.is_a?(Regexp) ? /\A(?:#{to_regexp})\z/ : handler
+      end
+
       ##
       # Returns a regexp from handler.
       #

data/lib/padrino-core/path_router/route.rb

@@ -20,7 +20,8 @@ module Padrino
       # The accessors will be used in other classes
       #
       attr_accessor :action, :cache, :cache_key, :cache_expires,
-                    :parent, :use_layout, :controller, :user_agent, :path_for_generation, :default_values
+                    :parent, :use_layout, :controller, :user_agent, :path_for_generation, :default_values,
+                    :provided_formats
 
       ##
       # Constructs an instance of PathRouter::Route.

data/lib/padrino-core/version.rb

@@ -6,7 +6,7 @@
 #
 module Padrino
   # The version constant for the current version of Padrino.
-  VERSION = '0.18.2' unless defined?(Padrino::VERSION)
+  VERSION = '0.18.4' unless defined?(Padrino::VERSION)
 
   #
   # The current Padrino version.