padrino-core 0.12.2 → 0.12.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dec1c7a3513869018c0576596a7888261759d25c
-  data.tar.gz: 6ba616394f122fc4bf166facc114554cbddf2331
+  metadata.gz: b0c4e1103a6097258ff654c266fbc979a4115409
+  data.tar.gz: be1ce195a701fc3a868069bdfee1847d87bfedfe
 SHA512:
-  metadata.gz: 6507e1e6ae0a0d2ca472e740928b548d7d9340d5d046725c8c049ece42e595db33018b1f551c148c846a1618e5cc2dd583bca65d202b49e8e86aa669eb770c85
-  data.tar.gz: bc2666c168ba2678e3045db54803ddcec24fd9c486a8b77e03e01c7eb0a01785ed15ac95c487955723f5b7ed864cbd5939a67d4252a5aff5a622ba3c1ba760e0
+  metadata.gz: 08c3823803340970a7c3e5138e0705439a7db34880f075de1f886725ac44792d1cba96f7c396aadb4f2fa7e153313dda9611468721a66d71bc80c4a9c4e31630
+  data.tar.gz: cf6e3a2954d7541a981318094e9600d266a593189852b3028a91d3c9316b03a39b2719087e231eac55f800ca65be5f9a7d455d55b9f2083f0ddbf462df1ccd8b

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

@@ -23,10 +23,9 @@ module Padrino
         set :default_builder, 'StandardFormBuilder'
 
         # TODO: Remove this hack after getting rid of thread-unsafe http_router:
-        set :init_mutex, Mutex.new
-
-        # TODO: Remove this line after sinatra version up.
-        set :add_charset, %w[javascript xml xhtml+xml].map{ |type| "application/#{type}" }
+        if RUBY_PLATFORM == "java"
+          set :init_mutex, Mutex.new
+        end
 
         default_paths
         default_security

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

@@ -1,261 +1,9 @@
-require 'http_router' unless defined?(HttpRouter)
 require 'padrino-support'
-
-##
-# Adds to Sinatra +controller+ informations
-#
-class Sinatra::Request
-  attr_accessor :route_obj
-
-  def controller
-    route_obj && route_obj.controller
-  end
-  def action
-    route_obj && route_obj.action
-  end
-end
-
-##
-# This patches Sinatra to accept UTF-8 urls on JRuby 1.7.6
-#
-if RUBY_ENGINE == 'jruby' && defined?(JRUBY_VERSION) && JRUBY_VERSION > '1.7.4'
-  class Sinatra::Base
-    class << self
-      alias_method :old_generate_method, :generate_method
-      def generate_method(method_name, &block)
-        old_generate_method(method_name.to_sym, &block)
-      end
-    end
-  end
-end
-
-class HttpRouter
-  def rewrite_partial_path_info(env, request); end
-  def rewrite_path_info(env, request); end
-
-  def process_destination_path(path, env)
-    Thread.current['padrino.instance'].instance_eval do
-      request.route_obj = path.route
-      @_response_buffer = nil
-      @route    = path.route
-      @params ||= {}
-      @params.update(env['router.params'])
-      @block_params = if match_data = env['router.request'].extra_env['router.regex_match']
-        params_list = match_data.to_a
-        params_list.shift
-        @params[:captures] = params_list
-        params_list
-      else
-        env['router.request'].params
-      end
-      # Provide access to the current controller to the request
-      # Now we can eval route, but because we have "throw halt" we need to be
-      # (en)sure to reset old layout and run controller after filters.
-      original_params = @params
-      parent_layout   = @layout
-      successful      = false
-      begin
-        filter! :before
-        (@route.before_filters - settings.filters[:before]).each { |block| instance_eval(&block) }
-        @layout = path.route.use_layout if path.route.use_layout
-        @route.custom_conditions.each { |block| pass if block.bind(self).call == false }
-        halt_response     = catch(:halt) { route_eval { @route.dest[self, @block_params] } }
-        @_response_buffer = halt_response.is_a?(Array) ? halt_response.last : halt_response
-        successful        = true
-        halt halt_response
-      ensure
-        (@route.after_filters - settings.filters[:after]).each { |block| instance_eval(&block) } if successful
-        @layout = parent_layout
-        @params = original_params
-      end
-    end
-  end
-
-  class Route
-    VALID_HTTP_VERBS.replace %w[GET POST PUT PATCH DELETE HEAD OPTIONS LINK UNLINK]
-
-    attr_accessor :use_layout, :controller, :action, :cache, :cache_key, :cache_expires, :parent
-
-    def before_filters(&block)
-      @_before_filters ||= []
-      @_before_filters << block if block_given?
-
-      @_before_filters
-    end
-
-    def after_filters(&block)
-      @_after_filters ||= []
-      @_after_filters << block if block_given?
-
-      @_after_filters
-    end
-
-    def custom_conditions(&block)
-      @_custom_conditions ||= []
-      @_custom_conditions << block if block_given?
-
-      @_custom_conditions
-    end
-
-    def significant_variable_names
-      @significant_variable_names ||= if @original_path.is_a?(String)
-        @original_path.scan(/(^|[^\\])[:\*]([a-zA-Z0-9_]+)/).map{|p| p.last.to_sym}
-      elsif @original_path.is_a?(Regexp) and @original_path.respond_to?(:named_captures)
-        @original_path.named_captures.keys.map(&:to_sym)
-      else
-        []
-      end
-    end
-
-    def to(dest = nil, &dest_block)
-      @dest = dest || dest_block || raise("you didn't specify a destination")
-
-      @router.current_order ||= 0
-      @order = @router.current_order
-      @router.current_order += 1
-
-      if @dest.respond_to?(:url_mount=)
-        urlmount = UrlMount.new(@path_for_generation, @default_values || {}) # TODO url mount should accept nil here.
-        urlmount.url_mount = @router.url_mount if @router.url_mount
-        @dest.url_mount = urlmount
-      end
-      self
-    end
-
-    attr_accessor :order
-
-  end
-
-  attr_accessor :current_order
-
-  def sort!
-    @routes.sort!{ |a, b| a.order <=> b.order }
-  end
-
-  class Node::Glob
-    def to_code
-      id = root.next_counter
-      "request.params << (globbed_params#{id} = [])
-       until request.path.empty?
-         globbed_params#{id} << request.path.shift
-         #{super}
-       end
-       request.path[0,0] = globbed_params#{id}
-       request.params.pop"
-    end
-  end
-
-  class Node::SpanningRegex
-    def to_code
-      params_count = @ordered_indicies.size
-      whole_path_var = "whole_path#{root.next_counter}"
-      "#{whole_path_var} = request.joined_path
-      if match = #{@matcher.inspect}.match(#{whole_path_var}) and match.begin(0).zero?
-        _#{whole_path_var} = request.path.dup
-        " << param_capturing_code << "
-        remaining_path = #{whole_path_var}[match[0].size + (#{whole_path_var}[match[0].size] == ?/ ? 1 : 0), #{whole_path_var}.size]
-        request.path = remaining_path.split('/')
-        #{node_to_code}
-        request.path = _#{whole_path_var}
-        request.params.slice!(#{-params_count}, #{params_count})
-      end
-      "
-    end
-  end
-
-  # Monkey patching the Request class. Using Rack::Utils.unescape rather than
-  # URI.unescape which can't handle utf-8 chars
-  class Request
-    def initialize(path, rack_request)
-      @rack_request = rack_request
-      @path = path.split(/\//).map{|part| Rack::Utils.unescape(part) }
-      @path.shift if @path.first == ''
-      @path.push('') if path[-1] == ?/
-      @extra_env = {}
-      @params = []
-      @acceptable_methods = Set.new
-    end
-  end
-
-  class Node::Path
-    def to_code
-      path_ivar = inject_root_ivar(self)
-      "#{"if !callback && request.path.size == 1 && request.path.first == '' && (request.rack_request.head? || request.rack_request.get?) && request.rack_request.path_info[-1] == ?/
-        catch(:pass) do
-          response = ::Rack::Response.new
-          response.redirect(request.rack_request.path_info[0, request.rack_request.path_info.size - 1], 302)
-          return response.finish
-        end
-      end" if router.redirect_trailing_slash?}
-
-      #{"if request.#{router.ignore_trailing_slash? ? 'path_finished?' : 'path.empty?'}" unless route.match_partially}
-        catch(:pass) do
-          if callback
-            request.called = true
-            callback.call(Response.new(request, #{path_ivar}))
-          else
-            env = request.rack_request.dup.env
-            env['router.request'] = request
-            env['router.params'] ||= {}
-            #{"env['router.params'].merge!(Hash[#{param_names.inspect}.zip(request.params)])" if dynamic?}
-            env['router.params'] = env['router.params'].with_indifferent_access
-            @router.rewrite#{"_partial" if route.match_partially}_path_info(env, request)
-            response = @router.process_destination_path(#{path_ivar}, env)
-            return response unless router.pass_on_response(response)
-          end
-        end
-      #{"end" unless route.match_partially}"
-    end
-  end
-end
+require 'padrino-core/ext/sinatra'
+require 'padrino-core/ext/http_router'
+require 'padrino-core/filter'
 
 module Padrino
-  class Filter
-    attr_reader :block
-
-    def initialize(mode, scoped_controller, options, args, &block)
-      @mode, @scoped_controller, @options, @args, @block = mode, scoped_controller, options, args, block
-    end
-
-    def apply?(request)
-      detect = match_with_arguments?(request) || match_with_options?(request)
-      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
-    end
-
-    private
-
-    def scoped_controller_name
-      @scoped_controller_name ||= Array(@scoped_controller).join("_")
-    end
-
-    def match_with_arguments?(request)
-      route, path = request.route_obj, 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
-        end
-      end
-    end
-
-    def match_with_options?(request)
-      user_agent = request.user_agent
-      @options.any?{|name, value| value === (name == :agent ? user_agent : request.send(name)) }
-    end
-  end
-
   ##
   # Padrino provides advanced routing definition support to make routes and
   # url generation much easier. This routing system supports named route
@@ -387,35 +135,7 @@ module Padrino
       #
       def controller(*args, &block)
         if block_given?
-          options = args.extract_options!
-
-          # Controller defaults.
-          @_controller, original_controller = args,                        @_controller
-          @_parents,    original_parent     = options.delete(:parent),     @_parents
-          @_provides,   original_provides   = options.delete(:provides),   @_provides
-          @_use_format, original_use_format = options.delete(:use_format), @_use_format
-          @_cache,      original_cache      = options.delete(:cache),      @_cache
-          @_map,        original_map        = options.delete(:map),        @_map
-          @_conditions, original_conditions = options.delete(:conditions), @_conditions
-          @_defaults,   original_defaults   = options,                     @_defaults
-          @_accepts,    original_accepts    = options.delete(:accepts),    @_accepts
-          @_params,     original_params     = options.delete(:params),     @_params
-
-          # Application defaults.
-          @filters,     original_filters    = { :before => @filters[:before].dup, :after => @filters[:after].dup }, @filters
-          @layout,      original_layout     = nil, @layout
-
-          instance_eval(&block)
-
-          # Application defaults.
-          @filters        = original_filters
-          @layout         = original_layout
-
-          # Controller defaults.
-          @_controller, @_parents,  @_cache     = original_controller, original_parent,   original_cache
-          @_defaults,   @_provides, @_map       = original_defaults,   original_provides, original_map
-          @_conditions, @_use_format, @_accepts = original_conditions, original_use_format, original_accepts
-          @_params                              = original_params
+          with_new_options(*args) { instance_eval(&block) }
         else
           include(*args) if extensions.any?
         end
@@ -489,10 +209,11 @@ module Padrino
       # @see http://www.padrinorb.com/guides/controllers#route-filters
       #
       def construct_filter(*args, &block)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        except = options.key?(:except) && Array(options.delete(:except))
-        raise("You cannot use except with other options specified") if except && (!args.empty? || !options.empty?)
-        options = except.last.is_a?(Hash) ? except.pop : {} if except
+        options = args.extract_options!
+        if except = options.delete(:except)
+          fail "You cannot use :except with other options specified" unless args.empty? && options.empty?
+          options = Array(except).extract_options!
+        end
         Filter.new(!except, @_controller, options, Array(except || args), &block)
       end
 
@@ -523,8 +244,8 @@ module Padrino
       def parent(name, options={})
         defaults = { :optional => false, :map => name.to_s }
         options = defaults.merge(options)
-        @_parents = Array(@_parents) unless @_parents.is_a?(Array)
-        @_parents << Parent.new(name, options)
+        @_parent = Array(@_parent) unless @_parent.is_a?(Array)
+        @_parent << Parent.new(name, options)
       end
 
       ##
@@ -612,20 +333,9 @@ module Padrino
       #
       def url(*args)
         params = args.extract_options!
-        names, params_array = args.partition{|a| a.is_a?(Symbol)}
-        name = names[0, 2].join(" ").to_sym    # route name is concatenated with underscores
         fragment = params.delete(:fragment) || params.delete(:anchor)
-        params = value_to_param(params.symbolize_keys)
-        url =
-          if params_array.empty?
-            compiled_router.path(name, params)
-          else
-            compiled_router.path(name, *(params_array << params))
-          end
-        rebase_url(fragment ? url + '#' + fragment : url)
-      rescue HttpRouter::InvalidRouteException
-        route_error = "route mapping for url(#{name.inspect}) could not be found!"
-        raise Padrino::Routing::UnrecognizedException.new(route_error)
+        path = make_path_with_params(args, value_to_param(params.symbolize_keys))
+        rebase_url(fragment ? path << '#' << fragment : path)
       end
       alias :url_for :url
 
@@ -637,6 +347,15 @@ module Padrino
         route('HEAD', path, *args, &block)
       end
 
+      def put(path, *args, &block)     route 'PUT',     path, *args, &block end
+      def post(path, *args, &block)    route 'POST',    path, *args, &block end
+      def delete(path, *args, &block)  route 'DELETE',  path, *args, &block end
+      def head(path, *args, &block)    route 'HEAD',    path, *args, &block end
+      def options(path, *args, &block) route 'OPTIONS', path, *args, &block end
+      def patch(path, *args, &block)   route 'PATCH',   path, *args, &block end
+      def link(path, *args, &block)    route 'LINK',    path, *args, &block end
+      def unlink(path, *args, &block)  route 'UNLINK',  path, *args, &block end
+
       def rebase_url(url)
         if url.start_with?('/')
           new_url = ''
@@ -649,19 +368,56 @@ module Padrino
       end
 
       private
+
+      CONTROLLER_OPTIONS = [ :parent, :provides, :use_format, :cache, :expires, :map, :conditions, :accepts, :params ].freeze
+
+      # Saves controller options, yields the block, restores controller options.
+      def with_new_options(*args)
+        options = args.extract_options!
+
+        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, nil)
+
+        yield
+
+        @original_instance.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)
+        instance_variable_set(name, value)
+      end
+
+      # Searches compiled router for a path responding to args and makes a path with params.
+      def make_path_with_params(args, params)
+        names, params_array = args.partition{ |arg| arg.is_a?(Symbol) }
+        name = names[0, 2].join(" ").to_sym
+        compiled_router.path(name, *(params_array << params))
+      rescue HttpRouter::InvalidRouteException
+        raise Padrino::Routing::UnrecognizedException, "Route mapping for url(#{name.inspect}) could not be found"
+      end
+
       # Parse params from the url method
-      def value_to_param(value)
-        case value
-          when Array
-            value.map { |v| value_to_param(v) }.compact
-          when Hash
-            value.inject({}) do |memo, (k,v)|
-              v = value_to_param(v)
-              memo[k] = v unless v.nil?
-              memo
-            end
-          when nil then nil
-          else value.respond_to?(:to_param) ? value.to_param : value
+      def value_to_param(object)
+        case object
+        when Array
+          object.map { |item| value_to_param(item) }.compact
+        when Hash
+          object.inject({}) do |all, (key, value)|
+            next all if value.nil?
+            all[key] = value_to_param(value)
+            all
+          end
+        when nil
+        else
+          object.respond_to?(:to_param) ? object.to_param : object
         end
       end
 
@@ -726,13 +482,14 @@ module Padrino
         path, name, route_parents, options, route_options = *parse_route(path, route_options, verb)
         options.reverse_merge!(@_conditions) if @_conditions
 
-        # Sinatra defaults
         method_name = "#{verb} #{path}"
         unbound_method = generate_method(method_name, &block)
 
-        block = block.arity != 0 ?
-          proc { |a,p| unbound_method.bind(a).call(*p) } :
-          proc { |a,p| unbound_method.bind(a).call }
+        block = if block.arity == 0
+                  proc{ |request, _| unbound_method.bind(request).call }
+                else
+                  proc{ |request, block_params| unbound_method.bind(request).call(*block_params) }
+                end
 
         invoke_hook(:route_added, verb, path, block)
 
@@ -743,6 +500,7 @@ module Padrino
         priority_name = options.delete(:priority) || :normal
         priority = ROUTE_PRIORITY[priority_name] or raise("Priority #{priority_name} not recognized, try #{ROUTE_PRIORITY.keys.join(', ')}")
         route.cache = options.key?(:cache) ? options.delete(:cache) : @_cache
+        route.cache_expires = options.key?(:expires) ? options.delete(:expires) : @_expires
         route.parent = route_parents ? (route_parents.count == 1 ? route_parents.first : route_parents) : route_parents
         route.add_request_method(verb.downcase.to_sym)
         route.host = options.delete(:host) if options.key?(:host)
@@ -759,7 +517,7 @@ module Padrino
         end
 
         # Add Sinatra conditions.
-        options.each { |o, a| route.respond_to?(o) ? route.send(o, *a) : send(o, *a) }
+        options.each{ |option, args| route.respond_to?(option) ? route.send(option, *args) : send(option, *args) }
         conditions, @conditions = @conditions, []
         route.custom_conditions.concat(conditions)
 
@@ -836,8 +594,8 @@ module Padrino
           end
 
           # Now we need to parse our 'parent' params and parent scope.
-          if !absolute_map and parent_params = options.delete(:parent) || @_parents
-            parent_params = (Array(@_parents) + Array(parent_params)).uniq
+          if !absolute_map and parent_params = options.delete(:parent) || @_parent
+            parent_params = (Array(@_parent) + Array(parent_params)).uniq
             path = process_path_for_parent_params(path, parent_params)
           end
 
@@ -873,7 +631,9 @@ module Padrino
       # Used for calculating path in route method.
       #
       def process_path_for_with_params(path, with_params)
-        File.join(path, Array(with_params).map(&:inspect).join("/"))
+        File.join(path, Array(with_params).map do |step|
+          step.kind_of?(String) ? step : step.inspect
+        end.join("/"))
       end
 
       ##
@@ -928,51 +688,29 @@ module Padrino
       #
       def provides(*types)
         @_use_format = true
+        mime_types = types.map{ |type| mime_type(CONTENT_TYPE_ALIASES[type] || type) }
         condition do
-          mime_types = types.map { |t| mime_type(t) }.compact
-          url_format = params[:format].to_sym if params[:format]
-          accepts    = request.accept.map(&:to_str)
-          accepts.clear if accepts == ["*/*"]
+          return provides_format?(types, params[:format].to_sym) if params[:format]
 
+          accepts = request.accept.map(&:to_str)
           # Per rfc2616-sec14:
           # Assume */* if no ACCEPT header is given.
-          catch_all = (accepts.delete "*/*" || accepts.empty?)
-          matching_types = accepts.empty? ? mime_types.slice(0,1) : (accepts & mime_types)
-          if matching_types.empty? && types.include?(:any)
-            matching_types = accepts
-          end
+          catch_all = accepts.delete("*/*")
 
-          if !url_format && matching_types.first
-            type = ::Rack::Mime::MIME_TYPES.find { |k, v| v == matching_types.first }[0].sub(/\./,'').to_sym
-            accept_format = CONTENT_TYPE_ALIASES[type] || type
-          elsif catch_all && !types.include?(:any)
-            type = types.first
-            accept_format = CONTENT_TYPE_ALIASES[type] || type
-          end
+          return provides_any?(accepts) if types.include?(:any)
 
-          matched_format = types.include?(:any)            ||
-                           types.include?(accept_format)   ||
-                           types.include?(url_format)      ||
-                           ((!url_format) && request.accept.empty? && types.include?(:html))
+          accepts = accepts.empty? ? mime_types.slice(0,1) : (accepts & mime_types)
 
-          # Per rfc2616-sec14:
-          # Answer with 406 if accept is given but types to not match any
-          # provided type.
-          halt 406 if
-            (!url_format && !accepts.empty? && !matched_format) ||
-            (settings.respond_to?(:treat_format_as_accept) && settings.treat_format_as_accept && url_format && !matched_format)
+          type = accepts.first && mime_symbol(accepts.first)
+          type ||= catch_all && types.first
 
-          if matched_format
-            @_content_type = url_format || accept_format || :html
-
-            if @_content_type != :json
-              content_type(@_content_type, :charset => 'utf-8')
-            else
-              content_type(@_content_type)
-            end
+          accept_format = CONTENT_TYPE_ALIASES[type] || type
+          if types.include?(accept_format)
+            content_type(accept_format || :html, :charset => 'utf-8')
+          else
+            halt 406 unless catch_all
+            false
           end
-
-          matched_format
         end
       end
 
@@ -986,14 +724,10 @@ module Padrino
       #   # => GET /a CONTENT_TYPE application/xml => 406
       #
       def accepts(*types)
-        mime_types = types.map { |type| mime_type(CONTENT_TYPE_ALIASES[type] || type) }.compact
+        mime_types = types.map{ |type| mime_type(CONTENT_TYPE_ALIASES[type] || type) }
         condition do
-          halt 406 unless media_type = mime_types.detect{|mime_type| mime_type == request.media_type }
-          if media_type != 'application/json'
-            content_type(media_type, :charset => 'utf-8')
-          else
-            content_type(media_type)
-          end
+          halt 406 unless mime_types.include?(request.media_type)
+          content_type(mime_symbol(request.media_type), :charset => 'utf-8')
         end
       end
 
@@ -1098,10 +832,10 @@ module Padrino
       # serving files from the public directory.
       #
       def static_file?(path_info)
-        return if (public_dir = settings.public_folder).nil?
+        return unless public_dir = settings.public_folder
         public_dir = File.expand_path(public_dir)
         path = File.expand_path(public_dir + unescape(path_info))
-        return if path[0, public_dir.length] != public_dir
+        return unless path.start_with?(public_dir)
         return unless File.file?(path)
         return path
       end
@@ -1135,15 +869,35 @@ module Padrino
       #   end
       #
       def content_type(type=nil, params={})
-        unless type.nil?
-          super(type, params)
-          @_content_type = type
-        end
-        @_content_type
+        return @_content_type unless type
+        params.delete(:charset) if type == :json
+        super(type, params)
+        @_content_type = type
       end
 
       private
 
+      def provides_any?(formats)
+        accepted_format = formats.first
+        type = accepted_format ? mime_symbol(accepted_format) : :html
+        content_type(CONTENT_TYPE_ALIASES[type] || type, :charset => 'utf-8')
+      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, :charset => 'utf-8')
+        end
+      end
+
+      def mime_symbol(media_type)
+        ::Rack::Mime::MIME_TYPES.key(media_type).sub(/\./,'').to_sym
+      end
+
       def filter!(type, base=settings)
         base.filters[type].each { |block| instance_eval(&block) }
       end
@@ -1166,20 +920,19 @@ module Padrino
 
       def route!(base=settings, pass_block=nil)
         Thread.current['padrino.instance'] = self
-        if base.compiled_router and match = base.compiled_router.call(@request.env)
-          if match.respond_to?(:each)
+
+        if base.compiled_router && result = base.compiled_router.call(@request.env)
+          if result.respond_to?(:each)
             route_eval do
-              match[1].each { |k,v| response[k] = v }
-              status match[0]
-              route_missing if match[0] == 404
-              route_missing if allow = response['Allow'] and allow.include?(request.env['REQUEST_METHOD'])
+              response.headers.merge!(result[1])
+              route_missing if status(result[0]) == 404
+              route_missing if (allow = response['Allow']) && allow.include?(request.env['REQUEST_METHOD'])
             end
           end
         else
           filter! :before
         end
 
-        # Run routes defined in superclass.
         if base.superclass.respond_to?(:router)
           route!(base.superclass, pass_block)
           return