padrino-core 0.16.0.pre4 → 0.16.0

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

@@ -14,9 +14,9 @@ module Padrino
   #
   module Routing
     # Defines common content-type alias mappings.
-    CONTENT_TYPE_ALIASES = { :htm => :html } unless defined?(CONTENT_TYPE_ALIASES)
+    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)
+    ROUTE_PRIORITY = { high: 0, normal: 1, low: 2 } unless defined?(ROUTE_PRIORITY)
 
     # Raised when a route was invalid or cannot be processed.
     class UnrecognizedException < RuntimeError; end
@@ -30,13 +30,11 @@ module Padrino
     end
 
     class Parent < String
-      attr_reader :map
-      attr_reader :optional
-      attr_reader :options
+      attr_reader :map, :optional, :options
 
-      alias_method :optional?, :optional
+      alias optional? optional
 
-      def initialize(value, options={})
+      def initialize(value, options = {})
         super(value.to_s)
         @map      = options.delete(:map)
         @optional = options.delete(:optional)
@@ -52,7 +50,7 @@ module Padrino
         app.send(:include, InstanceMethods)
         app.extend(ClassMethods)
       end
-      alias :included :registered
+      alias included registered
     end
 
     # Class methods responsible for enhanced routing for controllers.
@@ -70,20 +68,20 @@ module Padrino
       # @example
       #   controller :admin do
       #     get :index do; ...; end
-      #     get :show, :with => :id  do; ...; end
+      #     get :show, with: :id  do; ...; end
       #   end
       #
       #   url(:admin_index) # => "/admin"
-      #   url(:admin_show, :id => 1) # "/admin/show/1"
+      #   url(:admin_show, id: 1) # "/admin/show/1"
       #
       # @example Using named routes follow the sinatra way:
-      #   controller "/admin" do
-      #     get "/index" do; ...; end
-      #     get "/show/:id" do; ...; end
+      #   controller '/admin' do
+      #     get '/index' do; ...; end
+      #     get '/show/:id' do; ...; end
       #   end
       #
       # @example Supply +:provides+ to all controller routes:
-      #   controller :provides => [:html, :xml, :json] do
+      #   controller provides: [:html, :xml, :json] do
       #     get :index do; "respond to html, xml and json"; end
       #     post :index do; "respond to html, xml and json"; end
       #     get :foo do; "respond to html, xml and json"; end
@@ -93,40 +91,42 @@ module Padrino
       #   controllers :product, :parent => :user do
       #     get :index do
       #       # url is generated as "/user/#{params[:user_id]}/product"
-      #       # url_for(:product, :index, :user_id => 5) => "/user/5/product"
+      #       # url_for(:product, :index, user_id: 5) => "/user/5/product"
       #     end
-      #     get :show, :with => :id do
+      #     get :show, with: :id do
       #       # url is generated as "/user/#{params[:user_id]}/product/show/#{params[:id]}"
-      #       # url_for(:product, :show, :user_id => 5, :id => 10) => "/user/5/product/show/10"
+      #       # url_for(:product, :show, user_id: 5, id: 10) => "/user/5/product/show/10"
       #     end
       #   end
       #
       # @example Specify conditions to run for all routes:
-      #   controller :conditions => {:protect => true} do
+      #   controller conditions: { protect: true } do
       #     def self.protect(protected)
       #       condition do
-      #         halt 403, "No secrets for you!" unless params[:key] == "s3cr3t"
+      #         halt 403, 'No secrets for you!' unless params[:key] == 's3cr3t'
       #       end if protected
       #     end
       #
       #     # This route will only return "secret stuff" if the user goes to
       #     # `/private?key=s3cr3t`.
-      #     get("/private") { "secret stuff" }
+      #     get("/private") { 'secret stuff' }
       #
       #     # And this one, too!
-      #     get("/also-private") { "secret stuff" }
+      #     get("/also-private") { 'secret stuff' }
       #
       #     # But you can override the conditions for each route as needed.
       #     # This route will be publicly accessible without providing the
       #     # secret key.
-      #     get :index, :protect => false do
-      #       "Welcome!"
+      #     get :index, protect: false do
+      #       'Welcome!'
       #     end
       #   end
       #
       # @example Supply default values:
-      #   controller :lang => :de do
-      #     get :index, :map => "/:lang" do; "params[:lang] == :de"; end
+      #   controller lang: :de do
+      #     get :index, map: '/:lang' do
+      #       params[:lang] == :de
+      #     end
       #   end
       #
       # In a controller, before and after filters are scoped and don't
@@ -144,11 +144,11 @@ module Padrino
       def controller(*args, &block)
         if block_given?
           with_new_options(*args) { instance_eval(&block) }
-        else
-          include(*args) if extensions.any?
+        elsif extensions.any?
+          include(*args)
         end
       end
-      alias :controllers :controller
+      alias controllers controller
 
       ##
       # Add a before filter hook.
@@ -208,18 +208,18 @@ module Padrino
       #   # => match only path that are  +/+ or contains +main+
       #
       # @example filtering everything except an occurrence
-      #   before :except => :index do; ...; end
+      #   before except: :index do; ...; end
       #
       # @example you can also filter using a request param
-      #   before :agent => /IE/ do; ...; end
+      #   before agent: /IE/ do; ...; end
       #   # => match +HTTP_USER_AGENT+ containing +IE+
       #
       # @see http://padrinorb.com/guides/controllers/route-filters/
       #
       def construct_filter(*args, &block)
         options = args.last.is_a?(Hash) ? args.pop : {}
-        if except = options.delete(:except)
-          fail "You cannot use :except with other options specified" unless args.empty? && options.empty?
+        if (except = options.delete(:except))
+          raise 'You cannot use :except with other options specified' unless args.empty? && options.empty?
           except = Array(except)
           options = except.last.is_a?(Hash) ? except.pop : {}
         end
@@ -237,22 +237,22 @@ module Padrino
       #
       # @example
       #   controllers :product do
-      #     parent :shop, :optional => true, :map => "/my/stand"
-      #     parent :category, :optional => true
-      #     get :show, :with => :id do
+      #     parent :shop, optional: true, map: "/my/stand"
+      #     parent :category, optional: true
+      #     get :show, with: :id do
       #       # generated urls:
       #       #   "/product/show/#{params[:id]}"
       #       #   "/my/stand/#{params[:shop_id]}/product/show/#{params[:id]}"
       #       #   "/my/stand/#{params[:shop_id]}/category/#{params[:category_id]}/product/show/#{params[:id]}"
-      #       # url_for(:product, :show, :id => 10) => "/product/show/10"
-      #       # url_for(:product, :show, :shop_id => 5, :id => 10) => "/my/stand/5/product/show/10"
-      #       # url_for(:product, :show, :shop_id => 5, :category_id => 1, :id => 10) => "/my/stand/5/category/1/product/show/10"
+      #       # url_for(:product, :show, id: 10) => "/product/show/10"
+      #       # url_for(:product, :show, shop_id: 5, id: 10) => "/my/stand/5/product/show/10"
+      #       # url_for(:product, :show, shop_id: 5, category_id: 1, id: 10) => "/my/stand/5/category/1/product/show/10"
       #     end
       #   end
       #
-      def parent(name = nil, options={})
+      def parent(name = nil, options = {})
         return super() unless name
-        defaults = { :optional => false, :map => name.to_s }
+        defaults = { optional: false, map: name.to_s }
         options = defaults.merge(options)
         @_parent = Array(@_parent) unless @_parent.is_a?(Array)
         @_parent << Parent.new(name, options)
@@ -269,7 +269,7 @@ module Padrino
         @router ||= PathRouter.new
         block_given? ? yield(@router) : @router
       end
-      alias :urls :router
+      alias urls router
 
       def compiled_router
         if @deferred_routes
@@ -286,7 +286,7 @@ module Padrino
       end
 
       def deferred_routes
-        @deferred_routes ||= ROUTE_PRIORITY.map{[]}
+        @deferred_routes ||= ROUTE_PRIORITY.map { [] }
       end
 
       def reset_router!
@@ -305,16 +305,16 @@ module Padrino
       #
       # @example Giving a controller like:
       #   controller :foo do
-      #     get :bar, :map => 'foo-bar-:id'; ...; end
+      #     get :bar, map: 'foo-bar-:id'; ...; end
       #   end
       #
       # @example You should be able to reverse:
-      #   MyApp.url(:foo_bar, :id => :mine)
+      #   MyApp.url(:foo_bar, id: :mine)
       #   # => /foo-bar-mine
       #
       # @example Into this:
       #   MyApp.recognize_path('foo-bar-mine')
-      #   # => [:foo_bar, :id => :mine]
+      #   # => [:foo_bar, { id: :mine }]
       #
       def recognize_path(path)
         responses = @router.recognize_path(path)
@@ -330,12 +330,12 @@ module Padrino
       #   Synonym for fragment.
       #
       # @example
-      #   url(:show, :id => 1)
-      #   url(:show, :name => 'test', :id => 24)
+      #   url(:show, id: 1)
+      #   url(:show, name: 'test', id: 24)
       #   url(:show, 1)
-      #   url(:controller_name, :show, :id => 21)
-      #   url(:controller_show, :id => 29)
-      #   url(:index, :fragment => 'comments')
+      #   url(:controller_name, :show, id: 21)
+      #   url(:controller_show, id: 29)
+      #   url(:index, fragment: 'comments')
       #
       def url(*args)
         params = args.last.is_a?(Hash) ? args.pop : {}
@@ -343,7 +343,7 @@ module Padrino
         path = make_path_with_params(args, value_to_param(params))
         rebase_url(fragment ? path << '#' << fragment.to_s : path)
       end
-      alias :url_for :url
+      alias url_for url
 
       ##
       # Returns absolute url. By default adds 'http://localhost' before generated url.
@@ -393,22 +393,22 @@ module Padrino
           part
         end
 
-        [parent_prefix, path].flatten.join("")
+        [parent_prefix, path].flatten.join('')
       end
 
       private
 
       # temporary variables named @_parent, @_provides, @_use_format, @_cache, @_expires, @_map, @_conditions, @_accepts, @_params
-      CONTROLLER_OPTIONS = [ :parent, :provides, :use_format, :cache, :expires, :map, :conditions, :accepts, :params ].freeze
+      CONTROLLER_OPTIONS = %i[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.last.is_a?(Hash) ? args.pop : {}
 
-        CONTROLLER_OPTIONS.each{ |key| replace_instance_variable("@_#{key}", options.delete(key)) }
+        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(:@filters, before: @filters[:before].dup, after: @filters[:after].dup)
         replace_instance_variable(:@layout, @layout)
 
         yield
@@ -427,8 +427,8 @@ module Padrino
 
       # 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
+        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 PathRouter::InvalidRouteException
         raise Padrino::Routing::UnrecognizedException, "Route mapping for url(#{name.inspect}) could not be found"
@@ -444,7 +444,8 @@ module Padrino
             next all if value.nil?
             all[key] = value_to_param(value)
           end
-        when nil
+        when NilClass
+          nil
         else
           object.respond_to?(:to_param) ? object.to_param : object
         end
@@ -452,46 +453,47 @@ module Padrino
 
       # Add prefix slash if its not present and remove trailing slashes.
       def conform_uri(uri_string)
-        uri_string.gsub(/^(?!\/)(.*)/, '/\1').gsub(/\/+$/, '')
+        uri_string.gsub(%r{^(?!/)(.*)}, '/\1').gsub(%r{/+$}, '')
       end
 
       ##
       # Rewrite default routes.
       #
       # @example
-      #   get :index                                             # => "/"
-      #   get :index, "/"                                        # => "/"
-      #   get :index, :map => "/"                                # => "/"
-      #   get :show, "/show-me"                                  # => "/show-me"
-      #   get :show,  :map => "/show-me"                         # => "/show-me"
-      #   get "/foo/bar"                                         # => "/show"
-      #   get :index, :parent => :user                           # => "/user/:user_id/index"
-      #   get :show, :with => :id, :parent => :user              # => "/user/:user_id/show/:id"
-      #   get :show, :with => :id                                # => "/show/:id"
-      #   get [:show, :id]                                       # => "/show/:id"
-      #   get :show, :with => [:id, :name]                       # => "/show/:id/:name"
-      #   get [:show, :id, :name]                                # => "/show/:id/:name"
-      #   get :list, :provides => :js                            # => "/list.{:format,js)"
-      #   get :list, :provides => :any                           # => "/list(.:format)"
-      #   get :list, :provides => [:js, :json]                   # => "/list.{!format,js|json}"
-      #   get :list, :provides => [:html, :js, :json]            # => "/list(.{!format,js|json})"
-      #   get :list, :priority => :low                           # Defers route to be last
-      #   get /pattern/, :name => :foo, :generate_with => '/foo' # Generates :foo as /foo
+      #   get :index                                       # => "/"
+      #   get :index, '/'                                  # => "/"
+      #   get :index, map: '/'                             # => "/"
+      #   get :show, '/show-me'                            # => "/show-me"
+      #   get :show,  map: '/show-me'                      # => "/show-me"
+      #   get '/foo/bar'                                   # => "/show"
+      #   get :index, parent: :user                        # => "/user/:user_id/index"
+      #   get :show, with: :id, parent: :user              # => "/user/:user_id/show/:id"
+      #   get :show, with: :id                             # => "/show/:id"
+      #   get [:show, :id]                                 # => "/show/:id"
+      #   get :show, with: [:id, :name]                    # => "/show/:id/:name"
+      #   get [:show, :id, :name]                          # => "/show/:id/:name"
+      #   get :list, provides: :js                         # => "/list.{:format,js)"
+      #   get :list, provides: :any                        # => "/list(.:format)"
+      #   get :list, provides: [:js, :json]                # => "/list.{!format,js|json}"
+      #   get :list, provides: [:html, :js, :json]         # => "/list(.{!format,js|json})"
+      #   get :list, priority: :low                        # Defers route to be last
+      #   get /pattern/, name: :foo, generate_with: '/foo' # Generates :foo as /foo
       def route(verb, path, *args, &block)
-        options = case args.size
+        options =
+          case args.size
           when 2
-            args.last.merge(:map => args.first)
+            args.last.merge(map: args.first)
           when 1
             map = args.shift if args.first.is_a?(String)
             if args.first.is_a?(Hash)
-              map ? args.first.merge(:map => map) : args.first
+              map ? args.first.merge(map: map) : args.first
             else
-              {:map => map || args.first}
+              { map: map || args.first }
             end
           when 0
             {}
           else raise
-        end
+          end
 
         route_options = options.dup
         route_options[:provides] = @_provides if @_provides
@@ -500,9 +502,7 @@ module Padrino
 
         # Add Sinatra condition to check rack-protection failure.
         if respond_to?(:protect_from_csrf) && protect_from_csrf && (report_csrf_failure || allow_disabled_csrf)
-          unless route_options.has_key?(:csrf_protection)
-            route_options[:csrf_protection] = true
-          end
+          route_options[:csrf_protection] = route_options.fetch(:csrf_protection, true)
         end
 
         path, *route_options[:with] = path if path.is_a?(Array)
@@ -514,15 +514,15 @@ module Padrino
         unbound_method = generate_method(method_name.to_sym, &block)
 
         block_arity = block.arity
-        block = if block_arity == 0
-                  proc{ |request, _| unbound_method.bind(request).call }
+        block = if block_arity.zero?
+                  proc { |request, _| unbound_method.bind(request).call }
                 else
-                  proc{ |request, block_params| unbound_method.bind(request).call(*block_params) }
+                  proc { |request, block_params| unbound_method.bind(request).call(*block_params) }
                 end
 
         invoke_hook(:route_added, verb, path, block)
 
-        path[0, 0] = "/" if path == "(.:format)?"
+        path[0, 0] = '/' if path == '(.:format)?'
         route = router.add(verb, path, route_options)
         route.name = name if name
         route.action = action
@@ -530,14 +530,16 @@ module Padrino
         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.parent = route_parents&.count == 1 ? route_parents.first : route_parents
         route.host = options.delete(:host) if options.key?(:host)
         route.user_agent = options.delete(:agent) if options.key?(:agent)
+
         if options.key?(:default_values)
           defaults = options.delete(:default_values)
-          #route.options[:default_values] = defaults if defaults
+          # route.options[:default_values] = defaults if defaults
           route.default_values = defaults if defaults
         end
+
         options.delete_if do |option, captures|
           if route.significant_variable_names.include?(option.to_s)
             route.capture[option] = Array(captures).first
@@ -546,18 +548,19 @@ module Padrino
         end
 
         # Add Sinatra conditions.
-        options.each do |option, _args|
+        options.each do |option, args|
           option = :provides_format if option == :provides
-          route.respond_to?(option) ? route.send(option, *_args) : send(option, *_args)
+          route.respond_to?(option) ? route.send(option, *args) : send(option, *args)
         end
+
         conditions, @conditions = @conditions, []
         route.custom_conditions.concat(conditions)
 
         invoke_hook(:padrino_route_added, route, verb, path, args, options, block)
 
         block_parameter_length = route.block_parameter_length
-        if block_arity > 0 && block_parameter_length != block_arity
-          fail BlockArityError.new(route.path, block_arity, block_parameter_length)
+        if block_arity.positive? && block_parameter_length != block_arity
+          raise BlockArityError.new(route.path, block_arity, block_parameter_length)
         end
 
         # Add Application defaults.
@@ -580,7 +583,7 @@ module Padrino
       # controllers, parents, 'with' parameters, and other options.
       #
       def parse_route(path, options, verb)
-        path = path.dup if path.kind_of?(String)
+        path = path.dup if path.is_a?(String)
         route_options = {}
 
         if options[:params] == true
@@ -594,9 +597,9 @@ module Padrino
         map = options.delete(:map)
 
         # path i.e :index or :show
-        if path.kind_of?(Symbol)
+        if path.is_a?(Symbol)
           name = path
-          path = map ? map.dup : (path == :index ? '/' : path.to_s)
+          path = map&.dup || (path == :index ? '/' : path.to_s)
         end
 
         # Build our controller
@@ -605,13 +608,13 @@ module Padrino
         case path
         when String # path i.e "/index" or "/show"
           # Now we need to parse our 'with' params
-          if with_params = options.delete(:with)
+          if (with_params = options.delete(:with))
             path = process_path_for_with_params(path, with_params)
           end
 
           # Now we need to parse our provides
           options.delete(:provides) if options[:provides].nil?
-        
+
           options.delete(:accepts) if options[:accepts].nil?
 
           if @_use_format || options[:provides]
@@ -620,19 +623,17 @@ module Padrino
             # options[:add_match_with][:format] = /[^\.]+/
           end
 
-          absolute_map = map && map[0] == ?/
+          absolute_map = map && map[0] == '/'
 
-          unless controller.empty?
-            # Now we need to add our controller path only if not mapped directly
-            if !map && !absolute_map
-              controller_path = controller.join("/")
-              path.gsub!(%r{^\(/\)|/\?}, "")
-              path = File.join(controller_path, path)  unless @_map
-            end
+          # Now we need to add our controller path only if not mapped directly
+          if controller.any? && !map && !absolute_map
+            controller_path = controller.join('/')
+            path.gsub!(%r{^\(/\)|/\?}, '')
+            path = File.join(controller_path, path) unless @_map
           end
 
           # Now we need to parse our 'parent' params and parent scope.
-          if !absolute_map and parent_params = options.delete(:parent) || @_parent
+          if !absolute_map && (parent_params = options.delete(:parent) || @_parent)
             parent_params = (Array(@_parent) + Array(parent_params)).uniq
             path = process_path_for_parent_params(path, parent_params)
           end
@@ -641,11 +642,11 @@ module Padrino
           path = "#{@_map}/#{path}".squeeze('/') unless absolute_map || !@_map
 
           # Small reformats
-          path.gsub!(%r{/\?$}, '(/)')                  # Remove index path
-          path.gsub!(%r{//$}, '/')                     # Remove index path
-          path[0,0] = "/" if path !~ %r{^\(?/}         # Paths must start with a /
-          path.sub!(%r{/(\))?$}, '\\1') if path != "/" # Remove latest trailing delimiter
-          path.gsub!(/\/(\(\.|$)/, '\\1')              # Remove trailing slashes
+          path.gsub!(%r{/\?$}, '(/)')                   # Remove index path
+          path.gsub!(%r{//$}, '/')                      # Remove index path
+          path[0, 0] = '/' if path !~ %r{^\(?/}         # Paths must start with a /
+          path.sub!(%r{/(\))?$}, '\\1') if path != '/'  # Remove latest trailing delimiter
+          path.gsub!(%r{/(\(\.|$)}, '\\1')              # Remove trailing slashes
           path.squeeze!('/')
         when Regexp
           route_options[:path_for_generation] = options.delete(:generate_with) if options.key?(:generate_with)
@@ -654,11 +655,11 @@ module Padrino
         name = options.delete(:route_name) if name.nil? && options.key?(:route_name)
         name = options.delete(:name) if name.nil? && options.key?(:name)
         if name
-          controller_name = controller.join("_")
+          controller_name = controller.join('_')
           name = "#{controller_name} #{name}".to_sym unless controller_name.empty?
         end
 
-        options[:default_values] = @_defaults unless options.has_key?(:default_values)
+        options[:default_values] = @_defaults unless options.key?(:default_values)
 
         [path, name, parent_params, options, route_options]
       end
@@ -669,8 +670,8 @@ module Padrino
       #
       def process_path_for_with_params(path, with_params)
         File.join(path, Array(with_params).map do |step|
-          step.kind_of?(String) ? step : step.inspect
-        end.join("/"))
+          step.is_a?(String) ? step : step.inspect
+        end.join('/'))
       end
 
       ##
@@ -678,7 +679,7 @@ module Padrino
       # Used for calculating path in route method.
       #
       def process_path_for_provides(path)
-        path << "(.:format)?" unless path[-11, 11] == '(.:format)?'
+        path << '(.:format)?' unless path[-11, 11] == '(.:format)?'
       end
 
       ##
@@ -695,17 +696,17 @@ module Padrino
       # returned.
       #
       # @example
-      #   get "/a", :provides => [:html, :js]
+      #   get "/a", provides: [:html, :js]
       #   # => GET /a      => :html
       #   # => GET /a.js   => :js
       #   # => GET /a.xml  => 404
       #
-      #   get "/b", :provides => [:html]
+      #   get "/b", provides: [:html]
       #   # => GET /b; ACCEPT: html => html
       #   # => GET /b; ACCEPT: js   => 406
       #
       #   enable :treat_format_as_accept
-      #   get "/c", :provides => [:html, :js]
+      #   get "/c", provides: [:html, :js]
       #   # => GET /c.xml => 406
       #
       def provides(*types)
@@ -714,18 +715,18 @@ module Padrino
       end
 
       def provides_format(*types)
-        mime_types = types.map{ |type| mime_type(CONTENT_TYPE_ALIASES[type] || type) }
+        mime_types = types.map { |type| mime_type(CONTENT_TYPE_ALIASES[type] || type) }
         condition do
           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("*/*")
+          catch_all = accepts.delete('*/*')
 
           return provides_any?(accepts) if types.include?(:any)
 
-          accepts = accepts.empty? ? mime_types.slice(0,1) : (accepts & mime_types)
+          accepts = accepts.empty? ? mime_types.slice(0, 1) : (accepts & mime_types)
 
           type = accepts.first && mime_symbol(accepts.first)
           type ||= catch_all && types.first
@@ -743,13 +744,13 @@ module Padrino
       # Allows routing by Media type.
       #
       # @example
-      #   get "/a", :accepts => [:html, :js]
+      #   get "/a", accepts: [:html, :js]
       #   # => GET /a CONTENT_TYPE text/html => :html
       #   # => GET /a CONTENT_TYPE application/javascript => :js
       #   # => GET /a CONTENT_TYPE application/xml => 406
       #
       def accepts(*types)
-        mime_types = types.map{ |type| mime_type(CONTENT_TYPE_ALIASES[type] || type) }
+        mime_types = types.map { |type| mime_type(CONTENT_TYPE_ALIASES[type] || type) }
         condition do
           halt 406 unless mime_types.include?(request.media_type)
           content_type(mime_symbol(request.media_type))
@@ -761,13 +762,13 @@ module Padrino
       # `report_csrf_failure` is enabled.
       #
       # @example
-      #   post("/", :csrf_protection => false)
+      #   post("/", csrf_protection: false)
       #
       def csrf_protection(enabled)
         return unless enabled
         condition do
           if request.env['protection.csrf.failed']
-            message = settings.protect_from_csrf.kind_of?(Hash) && settings.protect_from_csrf[:message] || 'Forbidden'
+            message = settings.protect_from_csrf.is_a?(Hash) && settings.protect_from_csrf[:message] || 'Forbidden'
             halt(403, message)
           end
         end
@@ -782,8 +783,8 @@ module Padrino
       # Instance method for URL generation.
       #
       # @example
-      #   url(:show, :id => 1)
-      #   url(:show, :name => :test)
+      #   url(:show, id: 1)
+      #   url(:show, name: :test)
       #   url(:show, 1)
       #   url("/foo", false, false)
       #
@@ -804,16 +805,16 @@ module Padrino
           settings.url(*args)
         end
       end
-      alias :url_for :url
+      alias url_for url
 
       ##
       # Returns absolute url. Calls Sinatra::Helpers#uri to generate protocol version, hostname and port.
       #
       # @example
-      #   absolute_url(:show, :id => 1)  # => http://example.com/show?id=1
-      #   absolute_url(:show, 24)        # => https://example.com/admin/show/24
-      #   absolute_url('/foo/bar')       # => https://example.com/admin/foo/bar
-      #   absolute_url('baz')            # => https://example.com/admin/foo/baz
+      #   absolute_url(:show, id: 1)  # => http://example.com/show?id=1
+      #   absolute_url(:show, 24)     # => https://example.com/admin/show/24
+      #   absolute_url('/foo/bar')    # => https://example.com/admin/foo/bar
+      #   absolute_url('baz')         # => https://example.com/admin/foo/baz
       #
       def absolute_url(*args)
         url_path = args.shift
@@ -857,7 +858,7 @@ module Padrino
       # serving files from the public directory.
       #
       def static_file?(path_info)
-        return unless public_dir = settings.public_folder
+        return unless (public_dir = settings.public_folder)
         public_dir = File.expand_path(public_dir)
         path = File.expand_path(public_dir + unescape(path_info))
         return unless path.start_with?(public_dir)
@@ -869,7 +870,7 @@ module Padrino
       # Method for deliver static files.
       #
       def static!(options = {})
-        if path = static_file?(request.path_info)
+        if (path = static_file?(request.path_info))
           env['sinatra.static_file'] = path
           cache_control(*settings.static_cache_control) if settings.static_cache_control?
           send_file(path, options)
@@ -893,7 +894,7 @@ module Padrino
       #     end
       #   end
       #
-      def content_type(type=nil, params={})
+      def content_type(type = nil, params = {})
         return @_content_type unless type
         super(type, params)
         @_content_type = type
@@ -919,10 +920,10 @@ module Padrino
       end
 
       def mime_symbol(media_type)
-        ::Rack::Mime::MIME_TYPES.key(media_type).sub(/\./,'').to_sym
+        ::Rack::Mime::MIME_TYPES.key(media_type).sub(/\./, '').to_sym
       end
 
-      def filter!(type, base=settings)
+      def filter!(type, base = settings)
         filter! type, base.superclass if base.superclass.respond_to?(:filters)
         base.filters[type].each { |block| instance_eval(&block) }
       end
@@ -934,14 +935,14 @@ module Padrino
           static! if settings.static? && (request.get? || request.head?)
           route!
         end
-      rescue ::Exception => boom
-        filter! :before if boom.kind_of? ::Sinatra::NotFound
-        invoke { @boom_handled = handle_exception!(boom) }
+      rescue ::Exception => e
+        filter! :before if e.is_a? ::Sinatra::NotFound
+        invoke { @boom_handled = handle_exception!(e) }
       ensure
-        @boom_handled or begin
-          filter! :after  unless env['sinatra.static_file']
-        rescue ::Exception => boom
-          invoke { handle_exception!(boom) } unless @env['sinatra.error']
+        @boom_handled || begin
+          filter! :after unless env['sinatra.static_file']
+        rescue ::Exception => e
+          invoke { handle_exception!(e) } unless @env['sinatra.error']
         end
       end
 
@@ -950,7 +951,7 @@ module Padrino
         first_time = true
 
         routes = base.compiled_router.call(@request) do |route, params|
-          next if route.user_agent && !(route.user_agent =~ @request.user_agent)
+          next if route.user_agent && route.user_agent !~ @request.user_agent
           original_params, parent_layout = @params.dup, @layout
           returned_pass_block = invoke_route(route, params, first_time)
           pass_block = returned_pass_block if returned_pass_block
@@ -960,9 +961,9 @@ module Padrino
 
         unless routes.empty?
           verb = request.request_method
-          candidacies, allows = routes.partition{|route| route.verb == verb }
+          candidacies, allows = routes.partition { |route| route.verb == verb }
           if candidacies.empty?
-            response["Allows"] = allows.map(&:verb).join(", ")
+            response['Allows'] = allows.map(&:verb).join(', ')
             halt 405
           end
         end
@@ -982,9 +983,11 @@ module Padrino
         captured_params = captures_from_params(params)
 
         # Should not overwrite params by given query
-        @params.merge!(params) do |key, original, newval|
-          @route.significant_variable_names.include?(key) ? newval : original
-        end unless params.empty?
+        unless params.empty?
+          @params.merge!(params) do |key, original, newval|
+            @route.significant_variable_names.include?(key) ? newval : original
+          end
+        end
 
         @params[:format] = params[:format] if params[:format]
         @params[:captures] = captured_params if !captured_params.empty? && route.path.is_a?(Regexp)
@@ -992,16 +995,14 @@ module Padrino
         filter! :before if first_time
 
         catch(:pass) do
-          
-              (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 }
-              route_response = route.block[self, captured_params]
-              @_response_buffer = route_response.instance_of?(Array) ? route_response.last : route_response
-              halt(route_response)
-          ensure
-            (route.after_filters - settings.filters[:after]).each {|block| instance_eval(&block) }
-          
+          (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 }
+          route_response = route.block[self, captured_params]
+          @_response_buffer = route_response.instance_of?(Array) ? route_response.last : route_response
+          halt(route_response)
+        ensure
+          (route.after_filters - settings.filters[:after]).each { |block| instance_eval(&block) }
         end
       end