padrino-core 0.16.0.pre4 → 0.16.0

data/lib/padrino-core/logger.rb

@@ -63,14 +63,16 @@ module Padrino
     # :debug:: low-level information for developers
     # :devel:: Development-related information that is unnecessary in debug mode
     #
-    Levels = {
-      :fatal =>  4,
-      :error =>  3,
-      :warn  =>  2,
-      :info  =>  1,
-      :debug =>  0,
-      :devel => -1,
-    } unless defined?(Levels)
+    unless defined?(Levels)
+      Levels = {
+        fatal: 4,
+        error: 3,
+        warn: 2,
+        info: 1,
+        debug: 0,
+        devel: -1
+      }
+    end
 
     module Extensions
       ##
@@ -79,22 +81,20 @@ module Padrino
       Padrino::Logger::Levels.each_pair do |name, number|
         define_method(name) do |*args|
           return if number < level
+
           if args.size > 1
             bench(args[0], args[1], args[2], name)
           else
-            if location = resolve_source_location(caller(1).shift)
-              args.unshift(location)
-            end if enable_source_location?
+            location = resolve_source_location(caller(1).shift)
+            args.unshift(location) if location && enable_source_location?
             push(args * '', name)
           end
         end
 
-        define_method(:"#{name}?") do
-          number >= level
-        end
+        define_method(:"#{name}?") { number >= level }
       end
 
-      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/.freeze
+      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/
 
       ##
       # Returns true if :source_location is set to true.
@@ -109,11 +109,12 @@ module Padrino
       def resolve_source_location(message)
         path, line = *message.scan(SOURCE_LOCATION_REGEXP).first
         return unless path && line
+
         root = Padrino.root
         path = File.realpath(path) if Pathname.new(path).relative?
-        if path.start_with?(root) && !path.start_with?(Padrino.root("vendor"))
-          "[#{path.gsub("#{root}/", "")}:#{line}] "
-        end
+        return unless path.start_with?(root) && !path.start_with?(Padrino.root('vendor'))
+
+        "[#{path.gsub("#{root}/", '')}:#{line}] "
       end
 
       ##
@@ -132,13 +133,13 @@ module Padrino
       #   logger.bench 'GET', started_at, '/blog/categories'
       #   # => DEBUG - GET (0.0056s) - /blog/categories
       #
-      def bench(action, began_at, message, level=:debug, color=:yellow)
+      def bench(action, began_at, message, level = :debug, color = :yellow)
         @_pad  ||= 8
         @_pad    = action.to_s.size if action.to_s.size > @_pad
         duration = Time.now - began_at
         color    = :red if duration > 1
         action   = colorize(action.to_s.upcase.rjust(@_pad), color)
-        duration = colorize('%0.4fs' % duration, color, :bold)
+        duration = colorize(Kernel.format('%0.4fs', duration), color, :bold)
         push "#{action} (#{duration}) #{message}", level
       end
 
@@ -223,29 +224,34 @@ module Padrino
       #   Padrino.logger.exception e
       #   Padrino.logger.exception(e, :short)
       def exception(boom, verbosity = :long, level = :error)
-        return unless Levels.has_key?(level)
+        return unless Levels.key?(level)
+
         text = ["#{boom.class} - #{boom.message}:"]
         trace = boom.backtrace
-        case verbosity
-        when :long
-          text += trace
-        when :short
-          text << trace.first
-        end if trace.kind_of?(Array)
+
+        if trace.is_a?(Array)
+          case verbosity
+          when :long then text += trace
+          when :short then text << trace.first
+          end
+        end
+
         send level, text.join("\n ")
       end
     end
 
     module Colorize
       # Colors for levels
-      ColoredLevels = {
-        :fatal => [:bold, :red],
-        :error => [:default, :red],
-        :warn  => [:default, :yellow],
-        :info  => [:default, :green],
-        :debug => [:default, :cyan],
-        :devel => [:default, :magenta]
-      } unless defined?(ColoredLevels)
+      unless defined?(ColoredLevels)
+        ColoredLevels = {
+          fatal: %i[bold red],
+          error: %i[default red],
+          warn: %i[default yellow],
+          info: %i[default green],
+          debug: %i[default cyan],
+          devel: %i[default magenta]
+        }
+      end
 
       ##
       # Colorize our level.
@@ -255,12 +261,12 @@ module Padrino
       # @see Padrino::Logging::ColorizedLogger::ColoredLevels
       #
       def colorize(string, *colors)
-        string.colorize(:color => colors[0], :mode => colors[1])
+        string.colorize(color: colors[0], mode: colors[1])
       end
 
       def stylized_level(level)
-        style = "\e[%d;%dm" % ColoredLevels[level].map{|color| String::Colorizer.modes[color] || String::Colorizer.colors[color] }
-        [style, super, "\e[0m"] * ''
+        colors = ColoredLevels[level].map { |color| String::Colorizer.modes[color] || String::Colorizer.colors[color] }
+        [Kernel.format("\e[%d;%dm", *colors), super, "\e[0m"].join
       end
     end
 
@@ -289,7 +295,7 @@ module Padrino
     # :colorize_logging:: Whether or not to colorize log messages. Defaults to: true
     #
     # @example
-    #   Padrino::Logger::Config[:development] = { :log_level => :debug, :stream => :to_file }
+    #   Padrino::Logger::Config[:development] = { log_level: :debug, stream: :to_file }
     #   # or you can edit our defaults
     #   Padrino::Logger::Config[:development][:log_level] = :error
     #   # or change log file path
@@ -301,34 +307,37 @@ module Padrino
     #
     # Defaults are:
     #
-    #   :production  => { :log_level => :warn, :stream => :to_file }
-    #   :development => { :log_level => :debug, :stream => :stdout }
-    #   :test        => { :log_level => :fatal, :stream => :null }
+    #   :production  => { log_level: :warn, stream: :to_file }
+    #   :development => { log_level: :debug, stream: :stdout }
+    #   :test        => { log_level: :fatal, stream: :null }
     #
     # In some cases, configuring the loggers before loading the framework is necessary.
     # You can do so by setting PADRINO_LOGGER:
     #
-    #   PADRINO_LOGGER = { :staging => { :log_level => :debug, :stream => :to_file }}
+    #   PADRINO_LOGGER = { staging: { log_level: :debug, stream: :to_file }}
     #
     Config = {
-      :production  => { :log_level => :warn,  :stream => :to_file },
-      :development => { :log_level => :debug, :stream => :stdout, :format_datetime => '' },
-      :test        => { :log_level => :debug, :stream => :null }
+      production: { log_level: :warn, stream: :to_file },
+      development: { log_level: :debug, stream: :stdout, format_datetime: '' },
+      test: { log_level: :debug, stream: :null }
     }
     Config.merge!(PADRINO_LOGGER) if PADRINO_LOGGER
 
-    @@mutex = Mutex.new
+    def self.mutex
+      @_mutex ||= Mutex.new
+    end
+
     def self.logger
       (@_logger ||= nil) || setup!
     end
 
     def self.logger=(logger)
       unless logger.class.ancestors.include?(Padrino::Logger::Extensions)
-        warn <<-EOT
-WARNING! `Padrino.logger = new_logger` no longer extends it with #colorize! and other features.
-          To do it with a custom logger you have to manually `new_logger.extend(Padrino::Logger::Extensions)`
-          before passing to `Padrino.logger = new_logger`.
-        EOT
+        warn <<~MESSAGE
+          WARNING! `Padrino.logger = new_logger` no longer extends it with #colorize! and other features.
+                    To do it with a custom logger you have to manually `new_logger.extend(Padrino::Logger::Extensions)`
+                    before passing to `Padrino.logger = new_logger`.
+        MESSAGE
       end
       @_logger = logger
     end
@@ -348,9 +357,10 @@ WARNING! `Padrino.logger = new_logger` no longer extends it with #colorize! and
         config = Config[:production]
       end
 
-      stream = case config[:stream]
+      stream =
+        case config[:stream]
         when :to_file
-          if filename = config[:log_path]
+          if (filename = config[:log_path])
             filename = Padrino.root(filename) unless Pathname.new(filename).absolute?
             if File.directory?(filename)
               filename = File.join(filename, "#{Padrino.env}.log")
@@ -366,9 +376,9 @@ WARNING! `Padrino.logger = new_logger` no longer extends it with #colorize! and
         when :stdout then $stdout
         when :stderr then $stderr
         else config[:stream] # return itself, probabilly is a custom stream.
-      end
+        end
 
-      new_logger = Padrino::Logger.new(config.merge(:stream => stream))
+      new_logger = Padrino::Logger.new(config.merge(stream: stream))
       new_logger.extend(Padrino::Logger::Extensions)
       self.logger = new_logger
     end
@@ -406,16 +416,16 @@ WARNING! `Padrino.logger = new_logger` no longer extends it with #colorize! and
     #   Can be an encoding, false or true.
     #   If it's true, logger sanitizes to Encoding.default_external.
     #
-    def initialize(options={})
+    def initialize(options = {})
       @buffer           = []
-      @auto_flush       = options.has_key?(:auto_flush) ? options[:auto_flush] : true
+      @auto_flush       = options.key?(:auto_flush) ? options[:auto_flush] : true
       @level            = options[:log_level] ? Padrino::Logger::Levels[options[:log_level]] : Padrino::Logger::Levels[:debug]
-      @log              = options[:stream]  || $stdout
+      @log              = options[:stream] || $stdout
       @log.sync         = true
-      @format_datetime  = options[:format_datetime] || "%d/%b/%Y %H:%M:%S"
-      @format_message   = options[:format_message]  || "%s - %s %s"
-      @log_static       = options.has_key?(:log_static) ? options[:log_static] : false
-      @colorize_logging = options.has_key?(:colorize_logging) ? options[:colorize_logging] : true
+      @format_datetime  = options[:format_datetime] || '%d/%b/%Y %H:%M:%S'
+      @format_message   = options[:format_message]  || '%s - %s %s'
+      @log_static       = options.key?(:log_static) ? options[:log_static] : false
+      @colorize_logging = options.key?(:colorize_logging) ? options[:colorize_logging] : true
       @source_location  = options[:source_location]
       @sanitize_encoding = options[:sanitize_encoding] || false
       @sanitize_encoding = Encoding.default_external if @sanitize_encoding == true
@@ -430,10 +440,10 @@ WARNING! `Padrino.logger = new_logger` no longer extends it with #colorize! and
     # Flush the entire buffer to the log object.
     #
     def flush
-      return unless @buffer.size > 0
-      @@mutex.synchronize do
+      return unless @buffer.size.positive?
+      self.class.mutex.synchronize do
         @buffer.each do |line|
-          line.encode!(@sanitize_encoding, :invalid => :replace, :undef => :replace) if @sanitize_encoding
+          line.encode!(@sanitize_encoding, invalid: :replace, undef: :replace) if @sanitize_encoding
           @log.write(line)
         end
         @buffer.clear
@@ -465,17 +475,15 @@ WARNING! `Padrino.logger = new_logger` no longer extends it with #colorize! and
     #   The message
     #
     def <<(message = nil)
-      message << "\n" unless message[-1] == ?\n
-      @@mutex.synchronize {
-        @buffer << message
-      }
+      message << "\n" unless message[-1] == "\n"
+      self.class.mutex.synchronize { @buffer << message }
       flush if @auto_flush
       message
     end
-    alias :write :<<
+    alias write <<
 
     def format(message, level)
-      @format_message % [stylized_level(level), colorize(Time.now.strftime(@format_datetime), :yellow), message.to_s.strip]
+      Kernel.format(@format_message, stylized_level(level), colorize(Time.now.strftime(@format_datetime), :yellow), message.to_s.strip)
     end
 
     ##
@@ -486,7 +494,7 @@ WARNING! `Padrino.logger = new_logger` no longer extends it with #colorize! and
     class Rack
       def initialize(app, uri_root)
         @app = app
-        @uri_root = uri_root.sub(/\/$/,"")
+        @uri_root = uri_root.chomp('/')
       end
 
       def call(env)
@@ -502,17 +510,17 @@ WARNING! `Padrino.logger = new_logger` no longer extends it with #colorize! and
       def log(env, status, header, began_at)
         return if env['sinatra.static_file'] && (!logger.respond_to?(:log_static) || !logger.log_static)
         logger.bench(
-          env["REQUEST_METHOD"],
+          env['REQUEST_METHOD'],
           began_at,
           [
             @uri_root.to_s,
-            env["PATH_INFO"],
-            env["QUERY_STRING"].empty? ? "" : "?" + env["QUERY_STRING"],
+            env['PATH_INFO'],
+            env['QUERY_STRING'].empty? ? '' : "?#{env['QUERY_STRING']}",
             ' - ',
             logger.colorize(status.to_s[0..3], :default, :bold),
             ' ',
             code_to_name(status)
-          ] * '',
+          ].join,
           :debug,
           :magenta
         )

data/lib/padrino-core/mounter/application_extension.rb

@@ -21,7 +21,7 @@ module Padrino
       end
 
       def public_folder
-        @public_folder ||= trace_method(:public_folder) { "" }
+        @public_folder ||= trace_method(:public_folder) { '' }
       end
 
       def app_name
@@ -39,7 +39,7 @@ module Padrino
       private
 
       def require_dependencies
-        Padrino.require_dependencies(dependencies, :force => true)
+        Padrino.require_dependencies(dependencies, force: true)
       end
 
       def trace_method(method_name)

data/lib/padrino-core/mounter.rb

@@ -6,8 +6,8 @@ module Padrino
   # Stores the name of the application (app folder name) and url mount path.
   #
   # @example
-  #   Mounter.new("blog_app", :app_class => "Blog").to("/blog")
-  #   Mounter.new("blog_app", :app_file => "/path/to/blog/app.rb").to("/blog")
+  #   Mounter.new('blog_app', app_class: 'Blog').to('/blog')
+  #   Mounter.new('blog_app', app_file: '/path/to/blog/app.rb').to('/blog')
   #
   class Mounter
     DEFAULT_CASCADE = [404, 405]
@@ -27,20 +27,24 @@ module Padrino
     # @option options [Symbol] :app_root (Directory of :app_file)
     # @option options [Symbol] :gem The gem to load the app from (Detected from name)
     #
-    def initialize(name, options={})
+    def initialize(name, options = {})
       @name      = name.to_s
       @app_class = options[:app_class] || Inflections.camelize(@name)
-      @gem       = options[:gem]       || Inflections.underscore(@app_class.split("::").first)
+      @gem       = options[:gem]       || Inflections.underscore(@app_class.split('::').first)
       @app_file  = options[:app_file]  || locate_app_file
       @app_obj   = options[:app_obj]   || app_constant || locate_app_object
+
       ensure_app_file! || ensure_app_object!
       unless padrino_application?
         @app_obj.extend ApplicationExtension
         @app_obj.mounter_options = options
       end
-      @app_root  = options[:app_root]  || (@app_obj.respond_to?(:root) && @app_obj.root || File.dirname(@app_file))
-      @uri_root  = "/"
-      @cascade   = options[:cascade] ? true == options[:cascade] ? DEFAULT_CASCADE.dup : Array(options[:cascade]) : []
+
+      @app_root  = options[:app_root] || (@app_obj.respond_to?(:root) && @app_obj.root || File.dirname(@app_file))
+      @uri_root  = '/'
+      @cascade   = DEFAULT_CASCADE.dup if options[:cascade] == true
+      @cascade ||= options[:cascade] ? Array(options[:cascade]) : []
+
       Padrino::Reloader.exclude_constants << @app_class
     end
 
@@ -60,7 +64,7 @@ module Padrino
     #   Mounter.new("blog_app").to("/blog")
     #
     def to(mount_url)
-      @uri_root  = mount_url
+      @uri_root = mount_url
       Padrino.insert_mounted_app(self)
       self
     end
@@ -113,7 +117,7 @@ module Padrino
         app_obj.public_folder = Padrino.root('public', uri_root) unless public_folder_exists
       end
       app_obj.setup_application! # Initializes the app here with above settings.
-      router.map(:to => app_obj, :path => uri_root, :host => app_data.app_host)
+      router.map(to: app_obj, path: uri_root, host: app_data.app_host)
     end
 
     ###
@@ -132,21 +136,21 @@ module Padrino
     def named_routes
       return [] unless app_obj.respond_to?(:routes)
 
-      app_obj.routes.map { |route|
+      app_obj.routes.map do |route|
         request_method = route.request_methods.first
         next if !route.name || request_method == 'HEAD'
         route_name = route.name.to_s
         route_name =
           if route.controller
-            route_name.split(" ", 2).map{|name| ":#{name}" }.join(", ")
+            route_name.split(' ', 2).map { |name| ":#{name}" }.join(', ')
           else
             ":#{route_name}"
           end
         name_array = "(#{route_name})"
         original_path = route.original_path.is_a?(Regexp) ? route.original_path.inspect : route.original_path
         full_path = File.join(uri_root, original_path)
-        OpenStruct.new(:verb => request_method, :identifier => route.name, :name => name_array, :path => full_path)
-      }.compact
+        OpenStruct.new(verb: request_method, identifier: route.name, name: name_array, path: full_path)
+      end.compact
     end
 
     ##
@@ -163,19 +167,16 @@ module Padrino
     #  the class object for the app if defined, nil otherwise.
     #
     def app_constant
-      klass = Object
-      for piece in app_class.split("::")
+      app_class.split('::').inject(Object) do |klass, piece|
         piece = piece.to_sym
-        if klass.const_defined?(piece, false)
-          klass = klass.const_get(piece)
-        else
-          return
-        end
+        break unless klass.const_defined?(piece, false)
+
+        klass.const_get(piece)
       end
-      klass
     end
 
     protected
+
     ##
     # Locates and requires the file to load the app constant.
     #
@@ -196,15 +197,13 @@ module Padrino
       candidates  = []
       candidates << app_const.app_file if app_const.respond_to?(:app_file)
       candidates << Padrino.first_caller if File.identical?(Padrino.first_caller.to_s, Padrino.called_from.to_s)
-      candidates << Padrino.mounted_root(name.downcase, "app.rb")
-      simple_name = name.split("::").last.downcase
-      mod_name = name.split("::")[0..-2].join("::")
-      Padrino.modules.each do |mod|
-        if mod.name == mod_name
-          candidates << mod.root(simple_name, "app.rb")
-        end
-      end
-      candidates << Padrino.root("app", "app.rb")
+      candidates << Padrino.mounted_root(name.downcase, 'app.rb')
+
+      simple_name = name.split('::').last.downcase
+      mod_name = name.split('::')[0..-2].join('::')
+
+      Padrino.modules.each { |mod| candidates << mod.root(simple_name, 'app.rb') if mod.name == mod_name }
+      candidates << Padrino.root('app', 'app.rb')
       candidates.find { |candidate| File.exist?(candidate) }
     end
 
@@ -212,7 +211,7 @@ module Padrino
     # Raises an exception unless app_file is located properly.
     #
     def ensure_app_file!
-      message = "Unable to locate source file for app '#{app_class}', try with :app_file => '/path/app.rb'"
+      message = "Unable to locate source file for app '#{app_class}', try with app_file: '/path/app.rb'"
       raise MounterException, message unless @app_file
     end
 
@@ -220,7 +219,7 @@ module Padrino
     # Raises an exception unless app_obj is defined properly.
     #
     def ensure_app_object!
-      message = "Unable to locate app for '#{app_class}', try with :app_class => 'MyAppClass'"
+      message = "Unable to locate app for '#{app_class}', try with app_class: 'MyAppClass'"
       raise MounterException, message unless @app_obj
     end
   end
@@ -235,7 +234,7 @@ module Padrino
     #   the root to the mounted apps base directory.
     #
     def mounted_root(*args)
-      Padrino.root(@mounted_root ||= "", *args)
+      Padrino.root(@mounted_root ||= '', *args)
     end
 
     ##
@@ -263,7 +262,7 @@ module Padrino
     # @example
     #   Padrino.mount("blog_app").to("/blog")
     #
-    def mount(name, options={})
+    def mount(name, options = {})
       Mounter.new(name, options)
     end
   end

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

@@ -12,7 +12,7 @@ module Padrino
       def initialize(routes)
         @routes = routes
       end
-  
+
       ##
       # Compiles all routes into regexps.
       #
@@ -37,7 +37,7 @@ module Padrino
       #
       def find_by(request_or_env)
         request = request_or_env.is_a?(Hash) ? Sinatra::Request.new(request_or_env) : request_or_env
-        pattern  = decode_pattern(request.path_info)
+        pattern = decode_pattern(request.path_info)
         verb    = request.request_method
         rotation { |offset| match?(offset, pattern) }.select { |route| route.verb == verb }
       end
@@ -47,8 +47,8 @@ module Padrino
       #
       def call_by_request(request)
         rotation do |offset|
-          pattern  = decode_pattern(request.path_info)
-          if route = match?(offset, pattern)
+          pattern = decode_pattern(request.path_info)
+          if (route = match?(offset, pattern))
             params = route.params_for(pattern, request.params)
             yield(route, params) if route.verb == request.request_method
             route
@@ -63,15 +63,15 @@ module Padrino
         pattern  = decode_pattern(pattern)
         rotation { |offset| match?(offset, pattern) }
       end
-  
+
       private
 
       ##
       # Returns a instance of PathRouter::Route if path is matched with current regexp
       #
       def match?(offset, path)
-        @routes[offset..-1].find do |route|
-          route.regexp === path || (path.end_with?("/") && route.regexp === path[0..-2])
+        @routes[offset..].find do |route|
+          route.regexp === path || (path.end_with?('/') && route.regexp === path[0..-2])
         end
       end
 
@@ -81,7 +81,7 @@ module Padrino
       def rotation(offset = 0)
         compile! unless compiled?
         loop.with_object([]) do |_, candidacies|
-          return candidacies unless route = yield(offset)
+          return candidacies unless (route = yield(offset))
           candidacies << route
           offset = route.index.next
         end

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

@@ -4,13 +4,13 @@ module Padrino
   module PathRouter
     class Matcher
       # To count group of regexp
-      GROUP_REGEXP = %r{\((?!\?:|\?!|\?<=|\?<!|\?=).+?\)}.freeze
+      GROUP_REGEXP = /\((?!\?:|\?!|\?<=|\?<!|\?=).+?\)/
 
       ##
       # Constructs an instance of PathRouter::Matcher.
       #
       def initialize(path, options = {})
-        @path = path.is_a?(String) && path.empty? ? "/" : path
+        @path = path.is_a?(String) && path.empty? ? '/' : path
         @capture = options[:capture]
         @default_values = options[:default_values]
       end
@@ -19,9 +19,9 @@ module Padrino
       # Matches a pattern with the route matcher.
       #
       def match(pattern)
-        if match_data = handler.match(pattern)
+        if (match_data = handler.match(pattern))
           match_data
-        elsif pattern != "/" && pattern.end_with?("/")
+        elsif pattern != '/' && pattern.end_with?('/')
           handler.match(pattern[0..-2])
         end
       end
@@ -42,7 +42,7 @@ module Padrino
           parts[handler.names.include?(key.to_s) ? 0 : 1][key] = val
         end
         expanded_path = handler.expand(:append, params)
-        expanded_path += ?? + Padrino::Utils.build_uri_query(query) unless query.empty?
+        expanded_path += "?#{Padrino::Utils.build_uri_query(query)}" unless query.empty?
         expanded_path
       end
 
@@ -60,15 +60,15 @@ module Padrino
         data = match(pattern)
         params = indifferent_hash
         if data.names.empty?
-          params.merge!(:captures => data.captures) unless data.captures.empty?
+          params.merge!(captures: data.captures) unless data.captures.empty?
         else
           if mustermann?
-            new_params = handler.params(pattern, :captures => data)
+            new_params = handler.params(pattern, captures: data)
             params.merge!(new_params) if new_params
           elsif data
             params.merge!(Hash[names.zip(data.captures)])
           end
-          params.merge!(others){ |_, old, new| old || new }
+          params.merge!(others) { |_, old, new| old || new }
         end
         params
       end
@@ -80,7 +80,7 @@ module Padrino
         @handler ||=
           case @path
           when String
-            Mustermann.new(@path, :capture => @capture, :uri_decode => false)
+            Mustermann.new(@path, capture: @capture, uri_decode: false)
           when Regexp
             /^(?:#{@path})$/
           else
@@ -108,7 +108,7 @@ module Padrino
       #
       def capture_length
         if mustermann?
-          handler.named_captures.inject(0) { |count, (_, capture)| count += capture.length }
+          handler.named_captures.inject(0) { |count, (_, capture)| count + capture.length }
         else
           handler.inspect.scan(GROUP_REGEXP).length
         end
@@ -120,7 +120,7 @@ module Padrino
       # Creates a hash with indifferent access.
       #
       def indifferent_hash
-        Hash.new{ |hash, key| hash[key.to_s] if key.instance_of?(Symbol) }
+        Hash.new { |hash, key| hash[key.to_s] if key.instance_of?(Symbol) }
       end
     end
   end