padrino-core 0.18.3 → 0.18.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0292970725ed26c9ba8a10d8f5b735d1a65c5fd35059a42f8d11b1c226fab310'
-  data.tar.gz: f9420665a99ea9e3647212aa634ae115e5823bb7a03a4f09e4272fcb1bcaa935
+  metadata.gz: be05253b26516488a094d26e9867de40bf05e08fef5d5522bd0cd0d17cd31c9b
+  data.tar.gz: 7c6cd5ead1fd9ffac74c8c2dad9d74d64156af2c9ae04bf33bbbc5a0e6a8d177
 SHA512:
-  metadata.gz: 8ba4b407587927ea087c9c00367bc81d3c2a4384e6653d07b7a5b0b233f4ef6e15e7fc9bf3bacda94e47c66a0bdfa5d8db9a65a664e8d8db1dc79ae4abfe27b5
-  data.tar.gz: 026a7d57274931d997a8c624ac157bd5973755756c607749ea6deb066f84c8c13861287823fa8a35d6bca952a869a7e961383239be25e738ddd3e9a3d1dede3c
+  metadata.gz: 62df53f97d43739feaf1a71c3b09f27f39f28972ad242f321a60f41327ec3fb2dc854b75f7b109fe02cb3389a1ee10e13d20f6e9a01ce424dd02ed06c5309581
+  data.tar.gz: fcac6597b21ff08a3c7c20d35ddfeaeb1b7e9ac5dbfd5e83ab9bd0a9d1c705f3c3474da8daaa12d6519c9e9c1227bbcf66057f801719748db3e74fa859ce3e1b

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

@@ -38,6 +38,7 @@ module Padrino
 
       def initialize(value, options = {})
         super(value.to_s)
+        options   = options.dup
         @map      = options.delete(:map)
         @optional = options.delete(:optional)
         @options  = options
@@ -339,10 +340,10 @@ module Padrino
       # @see http://padrinorb.com/guides/controllers/route-filters/
       #
       def construct_filter(*args, &block)
-        options = args.last.is_a?(Hash) ? args.pop : {}
+        options = args.last.is_a?(Hash) ? args.pop.dup : {}
         if (except = options.delete(:except))
           raise 'You cannot use :except with other options specified' unless args.empty? && options.empty?
-          except = Array(except)
+          except = Array(except).dup
           options = except.last.is_a?(Hash) ? except.pop : {}
         end
         Filter.new(!except, @_controller, options, Array(except || args), &block)
@@ -376,8 +377,7 @@ module Padrino
         return super() unless name
         defaults = { optional: false, map: name.to_s }
         options = defaults.merge(options)
-        @_parent = Array(@_parent) unless @_parent.is_a?(Array)
-        @_parent << Parent.new(name, options)
+        @_parent = Array(@_parent) + [Parent.new(name, options)]
       end
 
       ##
@@ -462,7 +462,7 @@ module Padrino
       #   url(:index, fragment: 'comments')
       #
       def url(*args)
-        params = args.last.is_a?(Hash) ? args.pop : {}
+        params = args.last.is_a?(Hash) ? args.pop.dup : {}
         fragment = params.delete(:fragment) || params.delete(:anchor)
         path = make_path_with_params(args, value_to_param(params))
         rebase_url(fragment ? "#{path}##{fragment}" : path)
@@ -497,8 +497,8 @@ module Padrino
       def rebase_url(url)
         if url.start_with?('/')
           new_url = String.new
-          new_url << conform_uri(ENV['RACK_BASE_URI']) if ENV['RACK_BASE_URI']
-          new_url << conform_uri(uri_root) if defined?(uri_root)
+          new_url << conformed_uri(:@_conformed_base_uri, ENV['RACK_BASE_URI']) if ENV['RACK_BASE_URI']
+          new_url << conformed_uri(:@_conformed_uri_root, uri_root) if defined?(uri_root)
           new_url << url
         else
           url.empty? ? '/' : url
@@ -542,7 +542,7 @@ module Padrino
       # Saves controller options, yields the block, restores controller options.
       def with_new_options(*args)
         original = {}
-        options = args.last.is_a?(Hash) ? args.pop : {}
+        options = args.last.is_a?(Hash) ? args.pop.dup : {}
 
         CONTROLLER_OPTIONS.each { |key| replace_instance_variable(original, "@_#{key}", options.delete(key)) }
         replace_instance_variable(original, :@_controller, args)
@@ -594,6 +594,17 @@ module Padrino
         uri_string.gsub(%r{^(?!/)(.*)}, '/\1').gsub(%r{/+$}, '')
       end
 
+      # conform_uri, remembered in +ivar+ for the last value it was given (the base URI and
+      # uri_root rarely change). The memo is a frozen [value, result] pair, replaced whole.
+      def conformed_uri(ivar, uri_string)
+        memo = instance_variable_get(ivar)
+        return memo[1] if memo && memo[0] == uri_string
+
+        memo = [uri_string.dup.freeze, conform_uri(uri_string).freeze].freeze
+        instance_variable_set(ivar, memo)
+        memo[1]
+      end
+
       ##
       # Rewrite default routes.
       #

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

@@ -22,6 +22,7 @@ module Padrino
           route.index = index
           route.regexp = /\A(?<_#{index}>#{route.matcher.to_regexp})\z/
         end
+        index_by_prefix!
         @compiled = true
       end
 
@@ -46,11 +47,15 @@ module Padrino
       # Calls routes by using request.
       #
       def call_by_request(request)
+        path_info = pattern = nil
         rotation do |offset|
-          pattern = decode_pattern(request.path_info)
+          # A route's filters may change the path before passing; decode it again only then.
+          unless path_info && path_info == request.path_info
+            path_info = request.path_info.dup
+            pattern = decode_pattern(path_info)
+          end
           if (route = match?(offset, pattern))
-            params = route.params_for(pattern, request.params)
-            yield(route, params) if route.verb == request.request_method
+            yield(route, route.params_for(pattern, request.params)) if route.verb == request.request_method
             route
           end
         end
@@ -72,9 +77,64 @@ module Padrino
       def match?(offset, path)
         return unless path
 
-        @routes[offset..].find do |route|
-          route.regexp === path || (path.end_with?('/') && route.regexp === path[0..-2])
+        trimmed = path[0..-2] if path.end_with?('/')
+        routes = @routes
+        # The index holds positions in routes as they were compiled, so it is used only while
+        # routes still holds the same routes in the same order. After any other edit to routes,
+        # match? looks through them one by one.
+        if (prefix_index = @prefix_index) && path.length >= PREFIX_SIZE && routes == prefix_index[2]
+          by_prefix, unprefixed, = prefix_index
+          candidates = by_prefix.fetch(path[0, PREFIX_SIZE], unprefixed)
+          from = candidates.bsearch_index { |index| index >= offset }
+          return unless from
+
+          from.upto(candidates.size - 1) do |at|
+            route = routes[candidates[at]]
+            regexp = route.regexp
+            return route if regexp.match?(path) || (trimmed && regexp.match?(trimmed))
+          end
+          return
+        end
+        while (route = routes[offset])
+          regexp = route.regexp
+          # A route added after compiling has no regexp and matches nothing.
+          return route if regexp && (regexp.match?(path) || (trimmed && regexp.match?(trimmed)))
+          offset += 1
+        end
+      end
+
+      # How many leading characters of a path pick the routes to try (index_by_prefix!).
+      PREFIX_SIZE = 3
+      # The start of a Sinatra pattern that can only match itself: plain characters, up to the
+      # first one that may be special (':', '*', '(', '?', '{', '\\', '+' ...).
+      LITERAL_START = %r{\A[A-Za-z0-9_\-/.~]*}
+
+      ##
+      # Sorts the routes by the first PREFIX_SIZE characters a path they match must start with,
+      # so that match? only tries the routes that can match it. A route whose pattern doesn't
+      # fix that many (a Regexp, a capture or group early, an optional character, a '|') is tried
+      # for every path.
+      #
+      def index_by_prefix!
+        prefixed = Hash.new { |hash, key| hash[key] = [] }
+        unprefixed = []
+        @routes.each_with_index do |route, index|
+          (prefix = literal_prefix(route)) ? prefixed[prefix] << index : unprefixed << index
         end
+        by_prefix = prefixed.transform_values { |indexes| (indexes + unprefixed).sort.freeze }.freeze
+        # One frozen value, set in one assignment: match? reads it once, so a thread matching while
+        # another compiles the same engine sees the lists and routes from the same compile.
+        @prefix_index = [by_prefix, unprefixed.freeze, @routes.dup.freeze].freeze
+      end
+
+      # The first PREFIX_SIZE characters every path the route matches starts with, or nil.
+      def literal_prefix(route)
+        path = route.original_path
+        return unless path.is_a?(String) && !path.include?('|')
+
+        literal = path[LITERAL_START]
+        literal = literal[0..-2] if path[literal.length] == '?'
+        literal[0, PREFIX_SIZE] if literal.length >= PREFIX_SIZE
       end
 
       ##
@@ -82,11 +142,12 @@ module Padrino
       #
       def rotation(offset = 0)
         compile! unless compiled?
-        loop.with_object([]) do |_, candidacies|
-          return candidacies unless (route = yield(offset))
+        candidacies = []
+        while (route = yield(offset))
           candidacies << route
           offset = route.index.next
         end
+        candidacies
       end
 
       ##
@@ -97,6 +158,11 @@ module Padrino
       # (a '%0A' left by '%250A'), matches no route either.
       #
       def decode_pattern(pattern)
+        # Without an escape, decoding an ASCII path only changes its encoding.
+        if pattern.ascii_only? && !pattern.include?('%') && Encoding.default_external.ascii_compatible?
+          return pattern.include?("\n") ? nil : pattern.dup.force_encoding(Encoding::UTF_8)
+        end
+
         pattern = pattern.encode(Encoding.default_external)
         return if pattern.match?(/%(?!\h\h)/)
 

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

@@ -5,6 +5,8 @@ module Padrino
     class Matcher
       # To count group of regexp
       GROUP_REGEXP = /\((?!\?:|\?!|\?<=|\?<!|\?=).+?\)/
+      # Most key lists a matcher remembers for expand_path.
+      MAX_EXACT_KEYS = 32
 
       ##
       # Constructs an instance of PathRouter::Matcher.
@@ -45,9 +47,14 @@ module Padrino
       def expand(params)
         params = @default_values.merge(params) if @default_values.is_a?(Hash)
         params, query = params.each_with_object([{}, {}]) do |(key, val), parts|
-          parts[handler.names.include?(key.to_s) ? 0 : 1][key] = val
+          if names.include?(key.to_s)
+            # Mustermann escapes an Integer through a slow path; its digits need no escaping.
+            parts[0][key] = val.instance_of?(Integer) ? val.to_s : val
+          else
+            parts[1][key] = val
+          end
         end
-        expanded_path = handler.expand(:append, params)
+        expanded_path = expand_path(params)
         expanded_path += "?#{Padrino::Utils.build_uri_query(query)}" unless query.empty?
         expanded_path
       end
@@ -106,7 +113,7 @@ module Padrino
       # @see Regexp#names
       #
       def names
-        handler.names
+        @names ||= handler.names.dup.freeze
       end
 
       ##
@@ -122,6 +129,33 @@ module Padrino
 
       private
 
+      ##
+      # Mustermann's expand(:append, params). When the params fill one of the
+      # pattern's forms exactly, :append has nothing to append, and expand(:raise)
+      # gives the same path faster. Whether they do depends only on the keys,
+      # so it is found out once per list of keys, for params whose values are
+      # all Strings or Symbols (Integers arrive as Strings). Any other value
+      # (nil, an Array, an object) goes through :append and leaves the memo alone.
+      #
+      def expand_path(params)
+        return handler.expand(:append, params) unless params.all? { |_, value| value.instance_of?(String) || value.instance_of?(Symbol) }
+
+        keys = params.keys
+        exact = (@exact_keys ||= {}.freeze)[keys]
+        return handler.expand(:raise, params) if exact
+
+        path = handler.expand(:append, params)
+        if exact.nil? && @exact_keys.size < MAX_EXACT_KEYS
+          exact = begin
+            handler.expand(:raise, params) == path
+          rescue Mustermann::ExpandError, ArgumentError
+            false
+          end
+          @exact_keys = @exact_keys.merge(keys.freeze => exact).freeze
+        end
+        path
+      end
+
       ##
       # Creates a hash with indifferent access.
       #

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

@@ -4,7 +4,17 @@ module Padrino
       ##
       # The accessors are useful to access from PathRouter::Router
       #
-      attr_accessor :name, :capture, :order, :options, :index, :regexp
+      attr_accessor :capture, :order, :options, :index, :regexp
+
+      ##
+      # The route's name (url generation finds routes by it).
+      #
+      attr_reader :name
+
+      def name=(name)
+        @name = name
+        @router&.named_routes_changed!
+      end
 
       ##
       # A reader for compile option
@@ -16,6 +26,14 @@ module Padrino
       #
       attr_writer :router
 
+      ##
+      # Sets the route's router unless it has one (a route pushed onto Router#routes directly).
+      #
+      # @api private
+      def adopt(router)
+        @router ||= router
+      end
+
       ##
       # The accessors will be used in other classes
       #

data/lib/padrino-core/path_router.rb

@@ -32,6 +32,7 @@ module Padrino
         route = Route.new(path, verb, options, &block)
         route.router = self
         @routes << route
+        @named_routes = nil
         route
       end
 
@@ -56,13 +57,17 @@ module Padrino
       #
       def path(name, *args)
         params = args.last.is_a?(Hash) ? args.pop : {}
-        candidates = @routes.select { |route| route.name == name }
-        raise InvalidRouteException if candidates.empty?
-        i = 0
-        route = candidates.sort_by! do |candidate|
+        candidates = named_routes[name]
+        raise InvalidRouteException unless candidates
+        route = candidates.first
+        # Candidates that all take the same params (a GET and its HEAD) rank in their order.
+        unless candidates.all? { |candidate| candidate.matcher.names == route.matcher.names }
+          keys = params.keys.map(&:to_s)
           # Tries to find the route that matches more, but with fewer names, in stable order
-          [(params.keys.map(&:to_s) - candidate.matcher.names).length, candidate.matcher.names.size, i += 1]
-        end.shift
+          route = candidates.each_with_index.min_by do |candidate, i|
+            [(keys - candidate.matcher.names).length, candidate.matcher.names.size, i]
+          end.first
+        end
         matcher = route.matcher
         params_for_expand = params.dup
         if !args.empty? && matcher.mustermann?
@@ -86,6 +91,7 @@ module Padrino
       # Resets all routes, current order and preparation.
       #
       def reset!
+        @named_routes = nil
         @routes = []
         @current_order = 0
         @prepared = nil
@@ -107,10 +113,39 @@ module Padrino
         @prepared = true
         return if @current_order.zero?
         @routes.sort_by!(&:order)
+        @named_routes = nil
+      end
+
+      ##
+      # Forgets the routes by name, after a route was added, sorted or renamed.
+      #
+      # @api private
+      def named_routes_changed!
+        @named_routes = nil
       end
 
       private
 
+      ##
+      # The routes by name, in the order of +routes+, rebuilt when +routes+ changes size so
+      # that a route added to or deleted from +routes+ directly is seen.
+      # ceiling: a direct edit that keeps the size (one route swapped for another) isn't seen,
+      # nor is a rename of a route this router shares with, or took from, another router;
+      # rebuild on every call if that has to work.
+      #
+      def named_routes
+        size = @routes.size
+        memo = @named_routes
+        return memo[1] if memo && memo[0] == size
+
+        # A route pushed onto +routes+ directly has no router; give it this one, so that
+        # renaming it clears this index.
+        @routes.each { |route| route.adopt(self) }
+        by_name = @routes.group_by(&:name).freeze
+        @named_routes = [size, by_name].freeze
+        by_name
+      end
+
       ##
       # Returns true if the router has been prepared.
       #

data/lib/padrino-core/version.rb

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

data/test/test_filters.rb

@@ -416,6 +416,49 @@ describe 'Filters' do
     assert_equal 'before', body
   end
 
+  it 'should apply one except options hash to each filter it is passed to' do
+    opts = { except: :index }
+    mock_app do
+      before(opts) { @first = 'first' }
+      before(opts) { @second = 'second' }
+      get(:index) { "#{@first}#{@second}" }
+      get(:main) { "#{@first}#{@second}" }
+    end
+    get '/'
+    assert_equal '', body
+    get '/main'
+    assert_equal 'firstsecond', body
+    assert_equal({ except: :index }, opts)
+  end
+
+  it 'should apply one except list with options to each filter it is passed to' do
+    except = [:index, { agent: /IE/ }]
+    mock_app do
+      before(except: except) { @first = 'first' }
+      before(except: except) { @second = 'second' }
+      get(:index) { "#{@first}#{@second}" }
+      get(:main) { "#{@first}#{@second}" }
+    end
+    get '/main', {}, { 'HTTP_USER_AGENT' => 'IE' }
+    assert_equal '', body
+    get '/main'
+    assert_equal 'firstsecond', body
+    assert_equal [:index, { agent: /IE/ }], except
+  end
+
+  it 'should accept frozen except options' do
+    mock_app do
+      before({ except: :index }.freeze) { @first = 'first' }
+      before(except: [:index, { agent: /IE/ }.freeze].freeze) { @second = 'second' }
+      get(:index) { "#{@first}#{@second}" }
+      get(:main) { "#{@first}#{@second}" }
+    end
+    get '/'
+    assert_equal '', body
+    get '/main'
+    assert_equal 'firstsecond', body
+  end
+
   it 'should be able to filter excluding based on a symbol when specify the multiple routes and use nested controller' do
     mock_app do
       controller :test, :nested do

data/test/test_routing.rb

@@ -434,6 +434,17 @@ describe 'Routing' do
     end
   end
 
+  it 'should give 404 for a path with a raw newline' do
+    mock_app do
+      get('/names/:name') { 'name' }
+    end
+    ["/names/a\nb", "/names/a\n"].each do |path|
+      env = Rack::MockRequest.env_for('/')
+      env['PATH_INFO'] = path
+      assert_equal 404, @app.call(env)[0], path.inspect
+    end
+  end
+
   it 'should cascade a path with a control character to the next app at the same mount' do
     first = mock_app do
       before('/admin') { halt 401, 'first' }
@@ -2440,6 +2451,89 @@ describe 'Routing' do
     assert_equal 1, counter
   end
 
+  describe 'with options hashes and lists reused or frozen' do
+    def mock_app_needing_ok(&block)
+      mock_app do
+        set(:needs_ok) { |on| condition { halt 403, 'no ok' unless params[:ok] } if on }
+        instance_eval(&block)
+      end
+    end
+
+    it 'should apply the options to each controller and leave the hash unchanged' do
+      opts = { conditions: { needs_ok: true }, map: '/area' }
+      mock_app_needing_ok do
+        controller(:a, opts) { get(:one) { 'one' } }
+        controllers(:b, opts) { get(:two) { 'two' } }
+      end
+      %w[one two].each do |name|
+        get "/area/#{name}"
+        assert_equal 'no ok', body
+        get "/area/#{name}", ok: 1
+        assert_equal name, body
+      end
+      assert_equal({ conditions: { needs_ok: true }, map: '/area' }, opts)
+    end
+
+    it 'should accept a frozen options hash' do
+      opts = { conditions: { needs_ok: true } }.freeze
+      mock_app_needing_ok do
+        controller(:a, opts) { get(:index) { 'a' } }
+        controller(:b, opts) { get(:index) { 'b' } }
+      end
+      %w[a b].each do |name|
+        get "/#{name}"
+        assert_equal 'no ok', body
+        get "/#{name}", ok: 1
+        assert_equal name, body
+      end
+    end
+
+    it 'should accept a frozen parent list and a parent declared inside the controller' do
+      mock_app do
+        controller(:product, parent: [:shop].freeze) do
+          parent :category
+          get(:show) { 'product' }
+        end
+      end
+      get '/shop/1/category/2/product/show'
+      assert_equal 'product', body
+    end
+
+    it 'should leave the options given to a parent unchanged' do
+      opts = { map: 'store', optional: true }.freeze
+      first = Padrino::Routing::Parent.new(:a, opts)
+      second = Padrino::Routing::Parent.new(:b, opts)
+      assert_equal ['store', true], [first.map, first.optional]
+      assert_equal ['store', true], [second.map, second.optional]
+    end
+
+    it 'should keep the fragment of a params hash used for several urls' do
+      mock_app { get(:show, with: :id) { 'show' } }
+      params = { id: 1, fragment: 'top' }
+      assert_equal '/show/1#top', @app.url(:show, params)
+      assert_equal '/show/1#top', @app.url(:show, params)
+      assert_equal '/show/1', @app.url(:show, { id: 1 }.freeze)
+    end
+
+    it 'should not add a parent declared in a controller to the parents it was given' do
+      parents = [:shop]
+      mock_app do
+        controller(:product, parent: parents) do
+          parent :category
+          get(:show) { 'product' }
+        end
+        controller(:item, parent: parents) { get(:show) { 'item' } }
+      end
+      get '/shop/1/category/2/product/show'
+      assert_equal 'product', body
+      get '/shop/1/item/show'
+      assert_equal 'item', body
+      get '/shop/1/category/2/item/show'
+      assert_equal 404, status
+      assert_equal [:shop], parents
+    end
+  end
+
   it 'should parse params with class level provides' do
     mock_app do
       controllers :posts, provides: %i[html js] do
@@ -3136,4 +3230,280 @@ describe 'Routing' do
       assert_equal 'GET /posts/:id', outer_env['sinatra.route']
     end
   end
+
+  describe 'route matching' do
+    it 'matches the path a route rewrote before passing' do
+      mock_app do
+        get(:rewrite, map: '/rewrite/:id') do
+          request.path_info = '/target'
+          pass
+        end
+        get(:in_place, map: '/in_place/:id') do
+          request.path_info.replace('/target')
+          pass
+        end
+        get(:target, map: '/target') { 'target' }
+      end
+      get '/rewrite/1'
+      assert_equal 200, status
+      assert_equal 'target', body
+      get '/in_place/1'
+      assert_equal 200, status
+      assert_equal 'target', body
+    end
+
+    it 'keeps serving its routes when a route is added after a request' do
+      mock_app do
+        get('/first') { 'first' }
+      end
+      get '/first'
+      @app.get('/second') { 'second' }
+      get '/first'
+      assert_equal 'first', body
+      get '/m'
+      assert_equal 404, status
+      get '/missing'
+      assert_equal 404, status
+    end
+
+    it 'keeps serving its routes when routes are removed or inserted after a request' do
+      mock_app do
+        get(:gone, map: '/gone') { 'gone' }
+        get(:abc, map: '/abc') { 'abc' }
+        get(:cap, map: '/:x') { 'cap' }
+      end
+      get '/abc'
+      @app.router.routes.reject! { |route| route.name == :gone }
+      get '/abc'
+      assert_equal 'abc', body
+      get '/zz'
+      assert_equal 'cap', body
+      @app.router.routes.unshift(Padrino::PathRouter::Route.new('/new', :get))
+      get '/abc'
+      assert_equal 'abc', body
+      get '/gone'
+      assert_equal 'cap', body
+    end
+
+    it 'keeps serving its routes when routes are reordered after a request' do
+      mock_app do
+        get('/abc') { 'abc' }
+        get('/abd') { 'abd' }
+        get('/zzz') { 'zzz' }
+      end
+      get '/abc'
+      routes = @app.router.routes
+      first = routes.index { |route| route.original_path == '/abc' && route.verb == 'GET' }
+      last = routes.rindex { |route| route.original_path == '/zzz' && route.verb == 'GET' }
+      routes[first], routes[last] = routes[last], routes[first]
+      get '/abc'
+      assert_equal 200, status
+      assert_equal 'abc', body
+      get '/zzz'
+      assert_equal 'zzz', body
+    end
+
+    it 'matches routes whose pattern starts with an optional or variable part' do
+      mock_app do
+        get('/colou?r') { 'color' }
+        get('/xy?z') { 'optional' }
+        get('/one|/two') { 'union' }
+        get('/:lang/start') { 'capture' }
+        get('/*/files') { 'splat' }
+        get('/ab') { 'short' }
+        get(%r{/rx[0-9]+}) { 'regexp' }
+      end
+      { '/color' => 'color', '/colour' => 'color', '/xz' => 'optional', '/xyz' => 'optional', '/two' => 'union', '/de/start' => 'capture',
+        '/a/b/files' => 'splat', '/ab' => 'short', '/ab/' => 'short', '/rx12' => 'regexp' }.each do |path, expected|
+        get path
+        assert_equal expected, body, path
+      end
+    end
+
+    it 'picks the routes to try by the decoded path' do
+      mock_app do
+        get('/abc/first') { 'first' }
+        get('/ABC/x') { 'upper' }
+        get('/a/') { 'slash' }
+      end
+      get '/%61bc/first'
+      assert_equal 200, status
+      assert_equal 'first', body
+      get '/ABC/x'
+      assert_equal 200, status
+      assert_equal 'upper', body
+      get '/a/'
+      assert_equal 200, status
+      assert_equal 'slash', body
+    end
+
+    it 'lets a StopIteration raised in a route reach the error handlers' do
+      mock_app do
+        set :raise_errors, false
+        set :show_exceptions, false
+        get('/boom') { [].each.next }
+        error(StopIteration) { 'handled' }
+      end
+      get '/boom'
+      assert_equal 500, status
+      assert_equal 'handled', body
+    end
+
+    it 'serves a route when an earlier route for another verb matches the path' do
+      mock_app do
+        set :raise_errors, false
+        set :show_exceptions, false
+        post('(/:lang)?') { 'post' }
+        get('/') { 'root' }
+      end
+      get '/'
+      assert_equal 200, status
+      assert_equal 'root', body
+    end
+
+    it 'tries routes in the order they were defined, whatever their pattern starts with' do
+      mock_app do
+        get('/abc/first') { 'literal' }
+        get('/:name/first') { 'capture' }
+        get('/:name/second') { 'capture' }
+        get('/abc/second') { 'literal' }
+      end
+      get '/abc/first'
+      assert_equal 'literal', body
+      get '/abc/second'
+      assert_equal 'capture', body
+    end
+  end
+
+  describe 'url generation after routes change' do
+    it 'finds a renamed route by its new name' do
+      mock_app do
+        get(:old, map: '/page') { 'page' }
+      end
+      assert_equal '/page', @app.url(:old)
+      @app.routes.each { |route| route.name = :new if route.name == :old }
+      assert_equal '/page', @app.url(:new)
+      assert_raises(Padrino::Routing::UnrecognizedException) { @app.url(:old) }
+    end
+
+    it 'uses the routes defined after reset_routes!' do
+      mock_app do
+        get(:page, map: '/old') { 'old' }
+      end
+      assert_equal '/old', @app.url(:page)
+      @app.reset_routes!
+      assert_raises(Padrino::Routing::UnrecognizedException) { @app.url(:page) }
+      @app.get(:page, map: '/new') { 'new' }
+      assert_equal '/new', @app.url(:page)
+    end
+
+    it 'finds no route deleted from the routes' do
+      mock_app do
+        get(:gone, map: '/gone') { 'gone' }
+      end
+      assert_equal '/gone', @app.url(:gone)
+      @app.router.routes.reject! { |route| route.name == :gone }
+      assert_raises(Padrino::Routing::UnrecognizedException) { @app.url(:gone) }
+    end
+
+    it 'finds a route pushed onto the routes by its new name after a rename' do
+      mock_app do
+        get(:index) { 'index' }
+      end
+      route = Padrino::PathRouter::Route.new('/page', :get, name: :old)
+      @app.router.routes << route
+      assert_equal '/page', @app.url(:old)
+      route.name = :new
+      assert_equal '/page', @app.url(:new)
+      assert_raises(Padrino::Routing::UnrecognizedException) { @app.url(:old) }
+    end
+
+    it 'keeps the router a route was added to when another router indexes it' do
+      owner = Padrino::PathRouter.new
+      route = owner.add(:get, '/shared', name: :old)
+      owner.path(:old)
+      other = Padrino::PathRouter.new
+      other.routes << route
+      other.path(:old)
+      route.name = :new
+      assert_equal '/shared', owner.path(:new)
+    end
+
+    it 'finds a route added to the router with a name' do
+      router = Padrino::PathRouter.new
+      router.add(:get, '/one', name: :one)
+      assert_equal '/one', router.path(:one)
+      router.add(:get, '/two', name: :two)
+      assert_equal '/two', router.path(:two)
+      router.routes.pop
+      router.add(:get, '/three', name: :three)
+      assert_equal '/three', router.path(:three)
+    end
+
+    it 'finds the routes added to the router after reset!' do
+      router = Padrino::PathRouter.new
+      router.add(:get, '/old', name: :page)
+      assert_equal '/old', router.path(:page)
+      router.reset!
+      router.routes << Padrino::PathRouter::Route.new('/new', :get, name: :page)
+      assert_equal '/new', router.path(:page)
+    end
+
+    it 'picks the first route of a name in the order requests try them' do
+      mock_app do
+        get(:page, map: '/low', priority: :low) { 'low' }
+        get(:page, map: '/normal') { 'normal' }
+      end
+      @app.url(:page)
+      get '/normal'
+      assert_equal '/normal', @app.url(:page)
+    end
+
+    it 'picks the route of a name that takes the params given' do
+      mock_app do
+        get(:show, map: '/show/:id') { 'id' }
+        get(:show, map: '/show/:id/:slug') { 'slug' }
+      end
+      2.times do
+        assert_equal '/show/1', @app.url(:show, id: 1)
+        assert_equal '/show/1/x', @app.url(:show, id: 1, slug: 'x')
+        assert_equal '/show/1?ref=a', @app.url(:show, id: 1, ref: 'a')
+      end
+    end
+
+    it 'expands the same url for each form of the params' do
+      mock_app do
+        get(:item, map: '/item/:id(.:format)?') { 'item' }
+        get(:opt, map: '/opt(/:a(/:b))?') { 'opt' }
+      end
+      2.times do
+        assert_equal '/item/7', @app.url(:item, id: 7)
+        assert_equal '/item/7', @app.url(:item, 'id' => 7)
+        assert_equal '/item/-7', @app.url(:item, id: -7)
+        assert_equal '/item/7.json', @app.url(:item, id: '7', format: :json)
+        assert_equal '/item/a%20b', @app.url(:item, id: 'a b')
+        assert_equal '/opt/1/2', @app.url(:opt, a: 1, b: 2)
+        assert_equal '/opt?b=2', @app.url(:opt, b: 2)
+        assert_equal '/opt?b=2', @app.url(:opt, a: nil, b: 2)
+        assert_equal '/opt/1/2', @app.routes.find { |route| route.name == :opt }.path(a: 1, b: 2)
+        assert_equal '/opt?b=2', @app.routes.find { |route| route.name == :opt }.path(a: nil, b: 2)
+      end
+    end
+
+    it 'expands values other than Strings, Symbols and Integers as before' do
+      list = Class.new(Array)
+      value = Class.new { def to_s; 'v1'; end }.new
+      mock_app do
+        get(:files, map: '/files/*') { 'files' }
+        get(:opt, map: '/opt(/:a(/:b))?') { 'opt' }
+      end
+      2.times do
+        assert_equal '/files/x', @app.url(:files, splat: 'x')
+        assert_equal '/files/x', @app.url(:files, splat: list['x'])
+        assert_equal '/opt/1/2', @app.url(:opt, a: 1, b: 2)
+        assert_equal '/opt/v1/2', @app.url(:opt, a: value, b: 2)
+        assert_equal '/opt/false/2', @app.url(:opt, a: false, b: 2)
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: padrino-core
 version: !ruby/object:Gem::Version
-  version: 0.18.3
+  version: 0.18.5
 platform: ruby
 authors:
 - Padrino Team
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-11-03 00:00:00.000000000 Z
+date: 2026-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ostruct
@@ -33,14 +33,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.3
+        version: 0.18.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.3
+        version: 0.18.5
 - !ruby/object:Gem::Dependency
   name: rackup
   requirement: !ruby/object:Gem::Requirement