padrino-core 0.18.1 → 0.18.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8eef091fc9fe0d2d4b9ffdf24e35d6626f8f1f335ab766ae76e3baff1af3263a
-  data.tar.gz: ecf826091bcdb34a1d67c79f333627d57ea367ba97c48c1a926937be198fb703
+  metadata.gz: bf357f68006699d9e80fa024da18fbf0b64bd7d0365ea2ecfd90c12b0b8a6cfa
+  data.tar.gz: f702562744c51a4dee46da71739b7864ba3ebc1c9c937ddb8d5af3a07efc391c
 SHA512:
-  metadata.gz: 601689861cc5ecada66374c61811e158127ed481d118e19518e2d41ed396e394e40d8cf003b380d67cd7123479ac68b0dea20413af3160b2a4af227bbaf41608
-  data.tar.gz: 81d7b0f8fc4f2c054a944a7c34b112836276ae1cd1c59f33de261ccbd31b101685443edc0b476a6efe42bc7c85c2bbdd075364022b2ce5be42a0f76b862276b4
+  metadata.gz: 140423832026779eb7731e1145ab1d6d7b7197bf77e85d83c40077f639bcbc3fc0f7ee4ed2bedaee35a6b9b1188ae8ce9437e09fb605c17c605abfbf413c7383
+  data.tar.gz: ea73969e005298405dd22072d18a211634d038a68e53b7c3b9cfead7d29b2471eb06f30b723702f50fa00ab331cdb1a5bc29cbdc98449be874629e91dab50e05

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

@@ -417,25 +417,25 @@ 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 : {}
 
-        CONTROLLER_OPTIONS.each { |key| replace_instance_variable("@_#{key}", options.delete(key)) }
-        replace_instance_variable(:@_controller, args)
-        replace_instance_variable(:@_defaults, options)
-        replace_instance_variable(:@filters, before: @filters[:before].dup, after: @filters[:after].dup)
-        replace_instance_variable(:@layout, @layout)
+        CONTROLLER_OPTIONS.each { |key| replace_instance_variable(original, "@_#{key}", options.delete(key)) }
+        replace_instance_variable(original, :@_controller, args)
+        replace_instance_variable(original, :@_defaults, options)
+        replace_instance_variable(original, :@filters, before: @filters[:before].dup, after: @filters[:after].dup)
+        replace_instance_variable(original, :@layout, @layout)
 
         yield
-
-        @original_instance.each do |key, value|
+      ensure
+        original.each do |key, value|
           instance_variable_set(key, value)
         end
       end
 
-      # Sets instance variable by name and saves the original value in @original_instance hash
-      def replace_instance_variable(name, value)
-        @original_instance ||= {}
-        @original_instance[name] = instance_variable_get(name)
+      # Sets instance variable by name and saves the original value in the given hash
+      def replace_instance_variable(original, name, value)
+        original[name] = instance_variable_get(name)
         instance_variable_set(name, value)
       end
 
@@ -1019,6 +1019,7 @@ module Padrino
           (route.before_filters - settings.filters[:before]).each { |block| instance_eval(&block) }
           @layout = route.use_layout if route.use_layout
           route.custom_conditions.each { |block| pass if block.bind(self).call == false }
+          env['sinatra.route'] = "#{@request.request_method} #{route.sinatra_pattern}"
           route_response = route.block[self, captured_params]
           @_response_buffer = route_response.instance_of?(Array) ? route_response.last : route_response
           halt(route_response)

data/lib/padrino-core/caller.rb

@@ -4,19 +4,22 @@ module Padrino
     PADRINO_IGNORE_CALLERS = [
       *Sinatra::Base.callers_to_ignore,                            # Inherit Sinatra's default ignore patterns
       Regexp.new(Regexp.escape(RbConfig::CONFIG['rubylibdir'])),   # Ignore the Ruby standard lib path
-      %r{lib/padrino-.*$},
-      %r{/padrino-.*/(lib|bin)},
+      %r{/lib/padrino-(admin|cache|core|gen|helpers|mailer|performance|support)/},
+      %r{/lib/padrino/(core_ext/|rendering/|rendering\.rb$|safe_buffer\.rb$)},
+      %r{/lib/padrino(-[^/]+)?\.rb$},
+      %r{/padrino-[^/]+/(lib|bin)/},
       %r{/bin/padrino$},
-      %r{lib/rack.*\.rb$},
-      %r{lib/mongrel.*\.rb$},
-      %r{lib/shotgun.*\.rb$},
+      %r{/lib/rack(up)?(\.rb$|/)},
+      %r{/lib/mongrel(\.rb$|/)},
+      %r{/lib/shotgun(\.rb$|/)},
       %r{bin/shotgun$},
       %r{shoulda/context\.rb$},
-      %r{mocha/integration},
-      %r{test/unit},
+      %r{/lib/mocha/integration(\.rb$|/)},
+      %r{/lib/test/unit(\.rb$|/)},
       /rake_test_loader\.rb/,
       /custom_require\.rb$/,
-      %r{/thor}
+      %r{/lib/thor(\.rb$|/)},
+      %r{/bin/thor$}
     ]
 
     ##

data/lib/padrino-core/cli/base.rb

@@ -62,8 +62,10 @@ module Padrino
         ARGV.shift
         ARGV << 'help' if ARGV.empty?
         exit 1 unless Padrino.bin_gen(*ARGV)
-      rescue StandardError
-        puts '<= You need padrino-gen! Run: gem install padrino-gen'
+      rescue LoadError => e
+        raise unless (e.path || e.message[/-- (\S+)\z/, 1]) == 'padrino-gen/command'
+
+        abort "<= padrino g needs padrino-gen. Add gem 'padrino-gen' to your Gemfile and run bundle install, or run: gem install padrino-gen"
       end
 
       desc 'version', 'Show current Padrino version.'

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

@@ -55,6 +55,20 @@ module Padrino
         @path
       end
 
+      ##
+      # Returns the pattern as Sinatra writes it in env['sinatra.route']. Sinatra
+      # stringifies a Regexp through Mustermann, which drops the (?-mix:) wrapper.
+      # The root route is stored as an empty path; Sinatra names it "/".
+      #
+      def sinatra_pattern
+        @sinatra_pattern ||=
+          if @path.is_a?(Regexp)
+            Mustermann.new(@path, check_anchors: false).to_s
+          else
+            @path.to_s.empty? ? '/' : @path.to_s
+          end
+      end
+
       SIGNIFICANT_VARIABLES_REGEX = /(^|[^\\])[:*]([a-zA-Z0-9_]+)/
 
       ##
@@ -111,6 +125,7 @@ module Padrino
       def path=(pattern)
         @path = pattern
         @matcher = nil
+        @sinatra_pattern = nil
         @significant_variable_names = nil
       end
 

data/lib/padrino-core/version.rb

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

data/padrino-core.gemspec

@@ -6,17 +6,21 @@ Gem::Specification.new do |s|
   s.authors = ['Padrino Team', 'Nathan Esquenazi', "Davide D'Agostino", 'Arthur Chiu']
   s.email = 'padrinorb@gmail.com'
   s.summary = 'The required Padrino core gem'
-  s.homepage = 'http://www.padrinorb.com'
+  s.homepage = 'https://padrinorb.com'
   s.description = 'The Padrino core gem required for use of this framework'
   s.required_ruby_version = '>= 2.7.8'
   s.required_rubygems_version = '>= 1.3.6'
   s.version = Padrino.version
-  s.date = Time.now.strftime('%Y-%m-%d')
   s.license = 'MIT'
+  s.metadata = {
+    'bug_tracker_uri' => 'https://github.com/padrino/padrino-framework/issues',
+    'changelog_uri' => 'https://github.com/padrino/padrino-framework/blob/master/CHANGES.rdoc',
+    'documentation_uri' => 'https://padrinorb.com/guides/',
+    'source_code_uri' => 'https://github.com/padrino/padrino-framework'
+  }
 
   s.extra_rdoc_files = Dir['*.rdoc']
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ['lib']
   s.rdoc_options  = ['--charset=UTF-8']

data/test/test_caller.rb

@@ -0,0 +1,104 @@
+require_relative 'helper'
+require 'tmpdir'
+
+describe 'PADRINO_IGNORE_CALLERS' do
+  def ignored?(file)
+    Padrino::PADRINO_IGNORE_CALLERS.any? { |pattern| file =~ pattern }
+  end
+
+  gems = '/usr/lib/ruby/gems/4.0.0/gems'
+
+  [
+    "#{gems}/padrino-0.18.1/lib/padrino.rb",
+    "#{gems}/padrino-core-0.18.1/lib/padrino-core/application.rb",
+    "#{gems}/padrino-helpers-0.18.1/lib/padrino/rendering.rb",
+    "#{gems}/padrino-helpers-0.18.1/lib/padrino/rendering/erb_template.rb",
+    "#{gems}/padrino-helpers-0.18.1/lib/padrino/safe_buffer.rb",
+    "#{gems}/padrino-helpers-0.18.1/lib/padrino/core_ext/output_safety.rb",
+    "#{gems}/padrino-gen-0.18.1/bin/padrino-gen",
+    "#{gems}/padrino-contrib-0.3.0/lib/padrino-contrib/helpers/flash.rb",
+    '/home/me/.bundle/gems/padrino-framework-abc123/padrino-core/lib/padrino-core/mounter.rb',
+    '/home/me/.gem/bin/padrino',
+    '/srv/vendor/core/lib/padrino-core/application/application_setup.rb',
+    '/srv/vendor/core/lib/padrino-core.rb',
+    "#{gems}/acme-padrino-core-1.0/lib/padrino-core/mounter.rb",
+    '/home/me/.bundle/gems/fork-abc123/padrino-helpers/lib/padrino/rendering.rb',
+    "#{gems}/padrino-performance-0.18.1/lib/suites/json.rb",
+    "#{gems}/acme/lib/padrino-acme.rb",
+    "#{gems}/padrino-foo-1.0/lib/foo.rb",
+    "#{gems}/puma-6.4/lib/rack/handler/puma.rb",
+    "#{gems}/thor-1.5.0/lib/thor.rb",
+    "#{gems}/thor-1.5.0/lib/thor/base.rb",
+    "#{gems}/thor-1.5.0/bin/thor",
+    "#{gems}/rack-3.2.8/lib/rack.rb",
+    "#{gems}/rack-3.2.8/lib/rack/builder.rb",
+    "#{gems}/rack-protection-4.2.1/lib/rack/protection/base.rb",
+    "#{gems}/rack-session-2.1.2/lib/rack/session/cookie.rb",
+    "#{gems}/rackup-2.3.1/lib/rackup/server.rb",
+    "#{gems}/shotgun-0.9/lib/shotgun/loader.rb",
+    "#{gems}/shotgun-0.9/bin/shotgun",
+    "#{gems}/mongrel-1.1/lib/mongrel/http_response.rb",
+    "#{gems}/mocha-3.1.0/lib/mocha/integration/mini_test.rb",
+    "#{gems}/test-unit-3.6/lib/test/unit/testcase.rb",
+    "#{gems}/test-unit-3.6/lib/test/unit.rb",
+    "#{gems}/mocha-3.1.0/lib/mocha/integration.rb"
+  ].each do |file|
+    it "should ignore the library file #{file}" do
+      assert ignored?(file), "#{file} should be ignored"
+    end
+  end
+
+  %w[
+    /home/thor/demo/app/app.rb
+    /srv/thor-apps/demo/app/app.rb
+    /srv/lib/padrino-blog/demo/app/app.rb
+    /srv/demo/bin/padrino-worker
+    /srv/padrino-demo/app/app.rb
+    /srv/lib/rack-app/demo/app/app.rb
+    /srv/lib/rack_demo/demo/app/app.rb
+    /srv/lib/mongrel-demo/app/app.rb
+    /srv/lib/shotgun-demo/app/app.rb
+    /srv/test/unit/demo/app/app.rb
+    /srv/mocha/integration/demo/app/app.rb
+    /srv/demo/app/thor_helpers.rb
+    /srv/lib/padrino/rendering-blog/app/app.rb
+    /srv/lib/padrino/safe_buffer_demo.rb
+    /srv/lib/padrino/core_extras/app/app.rb
+    /srv/lib/test/unit-app/app/app.rb
+    /srv/lib/mocha/integration-demo/app/app.rb
+  ].each do |file|
+    it "should keep the application file #{file}" do
+      refute ignored?(file), "#{file} should not be ignored"
+    end
+  end
+
+  %w[thor-apps lib/padrino-blog lib/rack-app test/unit].each do |parent|
+    it "should find the application file of an app under #{parent}" do
+      Dir.mktmpdir do |dir|
+        app_file = File.join(dir, parent, 'demo', 'app', 'app.rb')
+        FileUtils.mkdir_p(File.dirname(app_file))
+        File.write(app_file, "Class.new(Padrino::Application) { $caller_test_app = self }\n")
+        begin
+          load app_file
+          assert_equal File.realpath(app_file), File.realpath($caller_test_app.app_file)
+        ensure
+          $caller_test_app = nil
+        end
+      end
+    end
+  end
+
+  it 'should keep the first caller for a file under a matching directory' do
+    Dir.mktmpdir do |dir|
+      file = File.join(dir, 'thor-apps', 'boot.rb')
+      FileUtils.mkdir_p(File.dirname(file))
+      File.write(file, "$caller_test_file = Padrino.first_caller\n")
+      begin
+        load file
+        assert_equal File.realpath(file), File.realpath($caller_test_file)
+      ensure
+        $caller_test_file = nil
+      end
+    end
+  end
+end

data/test/test_cli.rb

@@ -81,6 +81,65 @@ describe 'Padrino::Cli' do
     refute_includes err, "add gem 'irb'"
   end
 
+  it 'should say how to add padrino-gen when padrino g cannot load it' do
+    _, err, status = run_in_project(<<~RUBY)
+      # A bundle without padrino-gen
+      module Kernel
+        alias_method :require_before_test, :require
+        def require(name)
+          if name == 'padrino-gen/command'
+            error = LoadError.new('cannot load such file -- padrino-gen/command')
+            error.define_singleton_method(:path) { 'padrino-gen/command' }
+            raise error
+          end
+
+          require_before_test(name)
+        end
+      end
+      require 'padrino-core/cli/base'
+      Padrino::Cli::Base.start(['g', 'controller', 'demo'])
+    RUBY
+    assert_equal 1, status.exitstatus
+    assert_includes err, "Add gem 'padrino-gen' to your Gemfile"
+  end
+
+  it 'should say how to add padrino-gen when the LoadError has no path' do
+    _, err, status = run_in_project(<<~RUBY)
+      module Kernel
+        alias_method :require_before_test, :require
+        def require(name)
+          if name == 'padrino-gen/command'
+            error = LoadError.new('cannot load such file -- padrino-gen/command')
+            error.define_singleton_method(:path) { nil }
+            raise error
+          end
+
+          require_before_test(name)
+        end
+      end
+      require 'padrino-core/cli/base'
+      Padrino::Cli::Base.start(['g', 'controller', 'demo'])
+    RUBY
+    assert_equal 1, status.exitstatus
+    assert_includes err, "Add gem 'padrino-gen' to your Gemfile"
+  end
+
+  it 'should not hide a LoadError from inside padrino-gen in padrino g' do
+    _, err, status = run_in_project(<<~RUBY)
+      module Kernel
+        alias_method :require_before_test, :require
+        def require(name)
+          require_before_test(name == 'padrino-gen/command' ? 'padrino_missing_gen_dependency' : name)
+        end
+      end
+      require 'padrino-core/cli/base'
+      Padrino::Cli::Base.start(['g', 'controller', 'demo'])
+    RUBY
+    refute status.success?
+    assert_includes err, 'padrino_missing_gen_dependency'
+    refute_includes err, "Add gem 'padrino-gen'"
+  end
+
   it 'should load the models in the rake environment task after a skeleton task' do
     out, err, status = run_in_project(<<~RUBY)
       require 'rake'

data/test/test_routing.rb

@@ -980,6 +980,137 @@ describe 'Routing' do
     assert_equal 'foo_bar_index', body
   end
 
+  it 'should not give routes defined after a nested controller block the outer controller options' do
+    mock_app do
+      get(:early) { 'early' }
+      controller :admin, provides: :json, conditions: { agent: /Admin/ } do
+        before { response['x-outer'] = 'admin' }
+        after { response['x-outer-after'] = 'admin' }
+        controller :posts do
+          before { response['x-inner'] = 'posts' }
+          get(:index) { 'posts' }
+        end
+        get(:show) { 'show' }
+      end
+      get(:top) { 'top' }
+    end
+    get '/posts'
+    assert_equal 'posts', body
+    assert_equal 'admin', response['x-outer']
+    assert_equal 'posts', response['x-inner']
+    get '/admin/show', {}, 'HTTP_USER_AGENT' => 'Admin'
+    assert_equal 'show', body
+    assert_equal 'admin', response['x-outer']
+    assert_nil response['x-inner']
+    assert_match %r{^application/json}, response['Content-Type']
+    get '/admin/show'
+    assert_equal 404, status
+    get '/top'
+    assert_equal 200, status
+    assert_equal 'top', body
+    assert_nil response['x-outer']
+    assert_nil response['x-outer-after']
+    assert_match %r{^text/html}, response['Content-Type']
+    assert_equal '/top', @app.url(:top)
+    get '/early'
+    assert_equal 'early', body
+    assert_nil response['x-outer']
+    assert_nil response['x-outer-after']
+    get '/admin/top', {}, 'HTTP_USER_AGENT' => 'Admin'
+    assert_equal 404, status
+  end
+
+  it 'should not give routes defined after a nested controller block the outer map, layout or default values' do
+    mock_app do
+      controller :admin, map: '/manage', lang: 'en' do
+        @layout = :admin_layout # what padrino-helpers' `layout :admin_layout` sets
+        controller(:posts) { get(:index) { 'posts' } }
+        get(:show) { 'show' }
+      end
+      get(:top) { 'top' }
+      controller(:other) { get(:x) { 'x' } }
+    end
+    show = @app.routes.find { |route| route.action == :show }
+    top = @app.routes.find { |route| route.action == :top }
+    other = @app.routes.find { |route| route.action == :x }
+    assert_equal :admin_layout, show.use_layout
+    assert_equal({ lang: 'en' }, show.default_values)
+    assert_nil top.use_layout
+    assert_nil top.default_values
+    assert_nil other.use_layout
+    get '/manage/show'
+    assert_equal 'show', body
+    get '/top'
+    assert_equal 'top', body
+  end
+
+  it 'should restore each level of controllers nested three deep' do
+    mock_app do
+      controller :one, conditions: { agent: /One/ } do
+        before { response['x-one'] = 'one' }
+        controller :two do
+          before { response['x-two'] = 'two' }
+          controller :three do
+            get(:index) { 'three' }
+          end
+          get(:in_two) { 'in two' }
+        end
+        get(:in_one) { 'in one' }
+      end
+      get(:top) { 'top' }
+    end
+    get '/three'
+    assert_equal 'three', body
+    assert_equal 'two', response['x-two']
+    get '/two/in_two'
+    assert_equal 'in two', body
+    assert_equal 'one', response['x-one']
+    assert_equal 'two', response['x-two']
+    get '/one/in_one', {}, 'HTTP_USER_AGENT' => 'One'
+    assert_equal 'in one', body
+    assert_equal 'one', response['x-one']
+    assert_nil response['x-two']
+    get '/one/in_one'
+    assert_equal 404, status
+    get '/top'
+    assert_equal 'top', body
+    assert_nil response['x-one']
+    assert_nil response['x-two']
+  end
+
+  it 'should restore the outer options after sibling nested controller blocks' do
+    mock_app do
+      controller :admin, conditions: { agent: /Admin/ } do
+        controller(:posts) { get(:index) { 'posts' } }
+        controller(:users) { get(:index) { 'users' } }
+        get(:show) { 'show' }
+      end
+      get(:top) { 'top' }
+    end
+    get '/posts'
+    assert_equal 'posts', body
+    get '/users'
+    assert_equal 'users', body
+    get '/admin/show', {}, 'HTTP_USER_AGENT' => 'Admin'
+    assert_equal 'show', body
+    get '/top'
+    assert_equal 'top', body
+  end
+
+  it 'should restore the options when a controller block raises' do
+    mock_app
+    assert_raises(RuntimeError) do
+      @app.controller :broken, conditions: { agent: /Broken/ } do
+        before { response['x-broken'] = 'broken' }
+        raise 'broken controller'
+      end
+    end
+    @app.get(:top) { 'top' }
+    get '/top'
+    assert_equal 'top', body
+    assert_nil response['x-broken']
+  end
+
   it 'should use map and with' do
     mock_app do
       get :index, map: '/bugs', with: :id do
@@ -2599,4 +2730,224 @@ describe 'Routing' do
       assert_equal 'static', body
     end
   end
+
+  describe "env['sinatra.route']" do
+    it 'names the root route /' do
+      mock_app do
+        get(:index) { env['sinatra.route'] }
+        controller(:admin) { get(:index) { env['sinatra.route'] } }
+      end
+      get '/'
+      assert_equal 'GET /', body
+      get '/admin'
+      assert_equal 'GET /admin', body
+    end
+
+    it 'holds the verb and the pattern, as Sinatra writes it' do
+      mock_app do
+        get(:index, map: '/posts') { env['sinatra.route'] }
+        get('/posts/:id') { env['sinatra.route'] }
+        post('/posts/:id') { env['sinatra.route'] }
+      end
+      get '/posts'
+      assert_equal 'GET /posts', body
+      get '/posts/1'
+      assert_equal 'GET /posts/:id', body
+      post '/posts/1'
+      assert_equal 'POST /posts/:id', body
+    end
+
+    it 'writes a regexp the way Sinatra does' do
+      mock_app do
+        get(%r{/plain/(\d+)}) { env['sinatra.route'] }
+        get(%r{/flagged/(\d+)}i) { env['sinatra.route'] }
+        get(%r{/spaced/ (\d+)}x) { env['sinatra.route'] }
+      end
+      get '/plain/1'
+      assert_equal 'GET \/plain\/(\d+)', body
+      get '/flagged/1'
+      assert_equal 'GET (?i-mx:\/flagged\/(\d+))', body
+      get '/spaced/1'
+      assert_equal 'GET /spaced/(\d+)', body
+    end
+
+    it 'names a regexp with anchors, which Sinatra refuses' do
+      mock_app do
+        get(%r{^/anchored$}) { env['sinatra.route'] }
+      end
+      get '/anchored'
+      assert_equal 'GET ^\/anchored$', body
+    end
+
+    it 'includes the controller prefix, the parent and the with params' do
+      mock_app do
+        controller :admin do
+          get(:index) { env['sinatra.route'] }
+          get(:show, with: :id) { env['sinatra.route'] }
+        end
+        controller :items, parent: :user do
+          get(:index) { env['sinatra.route'] }
+        end
+      end
+      get '/admin'
+      assert_equal 'GET /admin', body
+      get '/admin/show/1'
+      assert_equal 'GET /admin/show/:id', body
+      get '/user/1/items'
+      assert_equal 'GET /user/:user_id/items', body
+    end
+
+    it 'keeps the format of a route with provides in the pattern' do
+      mock_app do
+        get(:index, map: '/feed', provides: %i[html json]) { env['sinatra.route'] }
+      end
+      get '/feed.json'
+      assert_equal 'GET /feed(.:format)?', body
+      get '/feed'
+      assert_equal 'GET /feed(.:format)?', body
+    end
+
+    it 'is set for after filters, and not yet for before filters, as in Sinatra' do
+      seen = []
+      mock_app do
+        before { seen << [:before, env['sinatra.route']] }
+        after { seen << [:after, env['sinatra.route']] }
+        controller :admin do
+          before { seen << [:controller_before, env['sinatra.route']] }
+          after { seen << [:controller_after, env['sinatra.route']] }
+          get(:show, with: :id) { 'ok' }
+        end
+      end
+      get '/admin/show/1'
+      assert_equal 200, status
+      assert_equal [
+        [:before, nil],
+        [:controller_before, nil],
+        [:controller_after, 'GET /admin/show/:id'],
+        [:after, 'GET /admin/show/:id']
+      ], seen
+    end
+
+    it 'stays unset when a before filter halts' do
+      mock_app do
+        before { halt 403, env.key?('sinatra.route').to_s }
+        get('/secret') { 'never' }
+      end
+      get '/secret'
+      assert_equal 403, status
+      assert_equal 'false', body
+    end
+
+    it 'reaches an error handler reached from a route' do
+      mock_app do
+        set :raise_errors, false
+        set :show_exceptions, false
+        error(FooError) { env['sinatra.route'] }
+        get('/boom/:id') { raise FooError }
+      end
+      get '/boom/1'
+      assert_equal 500, status
+      assert_equal 'GET /boom/:id', body
+    end
+
+    it 'names the route that answers after a pass' do
+      seen = []
+      mock_app do
+        after { seen << env['sinatra.route'] }
+        get('/posts/:id') { pass }
+        get('/posts/*rest') { env['sinatra.route'] }
+      end
+      get '/posts/1'
+      assert_equal 'GET /posts/*rest', body
+      assert_equal ['GET /posts/*rest'], seen
+    end
+
+    it 'names a HEAD request as HEAD' do
+      seen = []
+      mock_app do
+        after { seen << env['sinatra.route'] }
+        get('/posts/:id') { 'ok' }
+      end
+      head '/posts/1'
+      assert_equal 200, status
+      assert_equal ['HEAD /posts/:id'], seen
+    end
+
+    it 'stays unset for a request that matches no route' do
+      seen = []
+      mock_app do
+        before { seen << env.key?('sinatra.route') }
+        not_found { env.key?('sinatra.route').to_s }
+        get('/posts') { 'ok' }
+      end
+      get '/nothing'
+      assert_equal 404, status
+      assert_equal 'false', body
+      assert_equal [false], seen
+    end
+
+    it 'stays unset when only the verb differs' do
+      mock_app do
+        error(405) { env.key?('sinatra.route').to_s }
+        get('/posts') { 'ok' }
+      end
+      post '/posts'
+      assert_equal 405, status
+      assert_equal 'false', body
+    end
+
+    it 'stays unset when the only matching route fails its condition' do
+      mock_app do
+        not_found { env.key?('sinatra.route').to_s }
+        get('/feed', provides: :json) { 'ok' }
+        condition { false }
+        get('/hidden') { 'ok' }
+        get('/bots', agent: /bot/) { 'ok' }
+      end
+      ['/feed.xml', '/hidden', '/bots'].each do |path|
+        get path
+        assert_equal 404, status
+        assert_equal 'false', body
+      end
+    end
+
+    it 'stays unset when a condition calls pass' do
+      mock_app do
+        not_found { env.key?('sinatra.route').to_s }
+        condition { pass }
+        get('/cp') { 'never' }
+      end
+      get '/cp'
+      assert_equal 404, status
+      assert_equal 'false', body
+    end
+
+    it 'keeps the passed route when the next route fails its condition' do
+      mock_app do
+        not_found { env['sinatra.route'] }
+        get('/posts/:id') { pass }
+        condition { false }
+        get('/posts/*rest') { 'never' }
+      end
+      get '/posts/1'
+      assert_equal 404, status
+      assert_equal 'GET /posts/:id', body
+    end
+
+    it 'leaves out the mount path, at the root and under a sub-path' do
+      mock_app do
+        get('/posts/:id') { env['sinatra.route'] }
+      end
+      map = Padrino::Router.new({ path: '/', to: @app }, { path: '/blog', to: @app })
+      outer_env = nil
+      outer = lambda { |env|
+        outer_env = env
+        map.call(env)
+      }
+
+      assert_equal 'GET /posts/:id', Rack::MockRequest.new(outer).get('/posts/1').body
+      assert_equal 'GET /posts/:id', Rack::MockRequest.new(outer).get('/blog/posts/1').body
+      assert_equal 'GET /posts/:id', outer_env['sinatra.route']
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: padrino-core
 version: !ruby/object:Gem::Version
-  version: 0.18.1
+  version: 0.18.2
 platform: ruby
 authors:
 - Padrino Team
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-31 00:00:00.000000000 Z
+date: 2026-11-01 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.1
+        version: 0.18.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.1
+        version: 0.18.2
 - !ruby/object:Gem::Dependency
   name: rackup
   requirement: !ruby/object:Gem::Requirement
@@ -223,6 +223,7 @@ files:
 - test/helper.rb
 - test/test_application.rb
 - test/test_binstub.rb
+- test/test_caller.rb
 - test/test_cli.rb
 - test/test_configuration.rb
 - test/test_core.rb
@@ -246,10 +247,14 @@ files:
 - test/test_router.rb
 - test/test_routing.rb
 - test/test_server.rb
-homepage: http://www.padrinorb.com
+homepage: https://padrinorb.com
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/padrino/padrino-framework/issues
+  changelog_uri: https://github.com/padrino/padrino-framework/blob/master/CHANGES.rdoc
+  documentation_uri: https://padrinorb.com/guides/
+  source_code_uri: https://github.com/padrino/padrino-framework
 post_install_message:
 rdoc_options:
 - "--charset=UTF-8"