padrino-core 0.11.3 → 0.11.4

data/lib/padrino-core/application/rendering/extensions/erubis.rb

@@ -13,7 +13,7 @@ begin
           src << " #{@bufvar}.concat((" << code << ').to_s);'
         end
 
-        def add_expr_escaped(src, code)          
+        def add_expr_escaped(src, code)
           src << " #{@bufvar}.safe_concat " << code << ';'
         end
 
@@ -37,19 +37,28 @@ begin
       #
       # @api private
       class Template < Tilt::ErubisTemplate
+        def render(*args)
+          app       = args.first
+          app_class = app.class
+          @padrino_app = app.kind_of?(Padrino::Application) || 
+                         (app_class.respond_to?(:erb) && app_class.erb[:engine_class] == Padrino::Erubis::SafeBufferTemplate)
+          super
+        end
+
         def precompiled_preamble(locals)
+          buf = @padrino_app ? "ActiveSupport::SafeBuffer.new" : "''"
           old_postamble = super.split("\n")[0..-2]
-          [old_postamble, "#{@outvar} = _buf = (#{@outvar} || ActiveSupport::SafeBuffer.new)"].join("\n")
+          [old_postamble, "#{@outvar} = _buf = (#{@outvar} || #{buf})"].join("\n")
         end
       end
     end
   end
-  
-  Tilt.prefer Padrino::Erubis::Template, :erb
+
+  Tilt.prefer(Padrino::Erubis::Template, :erb)
 
   if defined? Padrino::Rendering
-    Padrino::Rendering.engine_configurations[:erb] = 
+    Padrino::Rendering.engine_configurations[:erb] =
       {:engine_class => Padrino::Erubis::SafeBufferTemplate}
   end
 rescue LoadError
-end
+end

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

@@ -4,7 +4,6 @@ require 'padrino-core/support_lite' unless defined?(SupportLite)
 ##
 # Adds to Sinatra +controller+ informations
 #
-# @private
 class Sinatra::Request
   attr_accessor :route_obj
 
@@ -16,10 +15,7 @@ class Sinatra::Request
   end
 end
 
-##
-# HttpRouter adapter
-#
-# @private
+
 class HttpRouter
   def rewrite_partial_path_info(env, request); end
   def rewrite_path_info(env, request); end
@@ -49,7 +45,7 @@ class HttpRouter
         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 } if @route.custom_conditions
+        @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
@@ -62,7 +58,6 @@ class HttpRouter
     end
   end
 
-  # @private
   class Route
     VALID_HTTP_VERBS.replace %w[GET POST PUT PATCH DELETE HEAD OPTIONS LINK UNLINK]
 
@@ -124,12 +119,30 @@ class HttpRouter
     @routes.sort!{ |a, b| a.order <=> b.order }
   end
 
-  #Monkey patching the Request class. Using Rack::Utils.unescape rather than
-  #URI.unescape which can't handle utf-8 chars
+  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 = Rack::Utils.unescape(path).split(/\//)
+      @path = path.split(/\//).map{|part| Rack::Utils.unescape(part) }
       @path.shift if @path.first == ''
       @path.push('') if path[-1] == ?/
       @extra_env = {}
@@ -170,7 +183,7 @@ class HttpRouter
 end
 
 module Padrino
-  class Filter # @private
+  class Filter
     attr_reader :block
 
     def initialize(mode, scoped_controller, options, args, &block)
@@ -211,7 +224,7 @@ module Padrino
   # which can be used to refer to the url throughout the application.
   #
   module Routing
-    # Defines common content-type alias mappings
+    # Defines common content-type alias mappings.
     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)
@@ -219,7 +232,7 @@ module Padrino
     # Raised when a route was invalid or cannot be processed.
     class UnrecognizedException < RuntimeError; end
 
-    class Parent < String # @private
+    class Parent < String
       attr_reader :map
       attr_reader :optional
       attr_reader :options
@@ -319,8 +332,10 @@ module Padrino
       #     get :index, :map => "/:lang" do; "params[:lang] == :de"; end
       #   end
       #
-      # In a controller, before and after filters are scoped and don't affect other controllers or the main app.
-      # In a controller, layouts are scoped and don't affect other controllers or the main app.
+      # In a controller, before and after filters are scoped and don't
+      #   affect other controllers or the main app.
+      # In a controller, layouts are scoped and don't affect other
+      #   controllers or the main app.
       #
       # @example
       #   controller :posts do
@@ -333,7 +348,7 @@ module Padrino
         if block_given?
           options = args.extract_options!
 
-          # Controller defaults
+          # Controller defaults.
           @_controller, original_controller = args,                        @_controller
           @_parents,    original_parent     = options.delete(:parent),     @_parents
           @_provides,   original_provides   = options.delete(:provides),   @_provides
@@ -343,17 +358,17 @@ module Padrino
           @_conditions, original_conditions = options.delete(:conditions), @_conditions
           @_defaults,   original_defaults   = options,                     @_defaults
 
-          # Application defaults
+          # Application defaults.
           @filters,     original_filters    = { :before => @filters[:before].dup, :after => @filters[:after].dup }, @filters
           @layout,      original_layout     = nil, @layout
 
           instance_eval(&block)
 
-          # Application defaults
+          # Application defaults.
           @filters        = original_filters
           @layout         = original_layout
 
-          # Controller defaults
+          # Controller defaults.
           @_controller, @_parents,  @_cache = original_controller, original_parent,   original_cache
           @_defaults,   @_provides, @_map   = original_defaults,   original_provides, original_map
           @_conditions, @_use_format        = original_conditions, original_use_format
@@ -364,7 +379,7 @@ module Padrino
       alias :controllers :controller
 
       ##
-      # Add a before filter hook
+      # Add a before filter hook.
       #
       # @see #construct_filter
       #
@@ -373,7 +388,7 @@ module Padrino
       end
 
       ##
-      # Add an after filter hook
+      # Add an after filter hook.
       #
       # @see #construct_filter
       #
@@ -384,7 +399,7 @@ module Padrino
       ##
       # Adds a filter hook to a request.
       #
-      def  add_filter(type, &block)
+      def add_filter(type, &block)
         filters[type] << block
       end
 
@@ -420,7 +435,7 @@ module Padrino
       #   before :index, /main/ do; ... end
       #   # => match only path that are  +/+ or contains +main+
       #
-      # @example filtering everything except an occurency
+      # @example filtering everything except an occurrence
       #   before :except => :index do; ...; end
       #
       # @example you can also filter using a request param
@@ -469,7 +484,7 @@ module Padrino
       end
 
       ##
-      # Using {HttpRouter}, for features and configurations.
+      # Using HttpRouter, for features and configurations.
       #
       # @example
       #   router.add('/greedy/:greed')
@@ -483,33 +498,26 @@ module Padrino
       end
       alias :urls :router
 
-      # Compiles the routes including deferred routes.
       def compiled_router
-        if deferred_routes.empty?
-          router
-        else
-          deferred_routes.each { |_, routes| routes.each { |(route, dest)| route.to(dest) } }
+        if @deferred_routes
+          deferred_routes.each { |routes| routes.each { |(route, dest)| route.to(dest) } }
           @deferred_routes = nil
           router.sort!
-          router
         end
+        router
       end
 
-      # Returns all routes that were deferred based on their priority.
       def deferred_routes
-        @deferred_routes ||= Hash[ROUTE_PRIORITY.values.sort.map{|p| [p, []]}]
+        @deferred_routes ||= ROUTE_PRIORITY.map{[]}
       end
 
-      ##
-      # Resets the http router and all deferred routes.
-      #
       def reset_router!
         @deferred_routes = nil
         router.reset!
       end
 
       ##
-      # Recognize a given path
+      # Recognize a given path.
       #
       # @param [String] path
       #   Path+Query to parse
@@ -570,7 +578,7 @@ module Padrino
       end
       alias :url_for :url
 
-      def get(path, *args, &block) # @private
+      def get(path, *args, &block)
         conditions = @conditions.dup
         route('GET', path, *args, &block)
 
@@ -579,334 +587,330 @@ module Padrino
       end
 
       private
-        # 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
-          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
         end
+      end
 
-        # Add prefix slash if its not present and remove trailing slashes.
-        def conform_uri(uri_string)
-          uri_string.gsub(/^(?!\/)(.*)/, '/\1').gsub(/[\/]+$/, '')
-        end
+      # Add prefix slash if its not present and remove trailing slashes.
+      def conform_uri(uri_string)
+        uri_string.gsub(/^(?!\/)(.*)/, '/\1').gsub(/[\/]+$/, '')
+      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
-        def route(verb, path, *args, &block)
-          options = case args.size
-            when 2
-              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
-              else
-                {:map => map || args.first}
-              end
-            when 0
-              {}
-            else raise
-          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
+      def route(verb, path, *args, &block)
+        options = case args.size
+          when 2
+            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
+            else
+              {:map => map || args.first}
+            end
+          when 0
+            {}
+          else raise
+        end
 
-          # Do padrino parsing. We dup options so we can build HEAD request correctly
-          route_options = options.dup
-          route_options[:provides] = @_provides if @_provides
+        # Do padrino parsing. We dup options so we can build HEAD request correctly.
+        route_options = options.dup
+        route_options[:provides] = @_provides if @_provides
 
-          # CSRF protection is always active except when explicitly switched off
-          if allow_disabled_csrf
-            unless route_options[:csrf_protection] == false
-              route_options[:csrf_protection] = true
-            end
+        # CSRF protection is always active except when explicitly switched off.
+        if allow_disabled_csrf
+          unless route_options[:csrf_protection] == false
+            route_options[:csrf_protection] = true
           end
+        end
 
-          path, *route_options[:with] = path if path.is_a?(Array)
-          action = path
-          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 }
-
-          invoke_hook(:route_added, verb, path, block)
-
-          # HTTPRouter route construction
-          route = router.add(path, route_options)
-          route.name = name if name
-          route.action = action
-          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.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)
-          route.user_agent = options.delete(:agent) if options.key?(:agent)
-          if options.key?(:default_values)
-            defaults = options.delete(:default_values)
-            route.add_default_values(defaults) if defaults
-          end
-          options.delete_if do |option, args|
-            if route.significant_variable_names.include?(option)
-              route.add_match_with(option => Array(args).first)
-              true
-            end
+        path, *route_options[:with] = path if path.is_a?(Array)
+        action = path
+        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 }
+
+        invoke_hook(:route_added, verb, path, block)
+
+        # HTTPRouter route construction
+        route = router.add(path, route_options)
+        route.name = name if name
+        route.action = action
+        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.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)
+        route.user_agent = options.delete(:agent) if options.key?(:agent)
+        if options.key?(:default_values)
+          defaults = options.delete(:default_values)
+          route.add_default_values(defaults) if defaults
+        end
+        options.delete_if do |option, _args|
+          if route.significant_variable_names.include?(option)
+            route.add_match_with(option => Array(_args).first)
+            true
           end
+        end
 
-          # Add Sinatra conditions
-          options.each { |o, a| route.respond_to?(o) ? route.send(o, *a) : send(o, *a) }
-          conditions, @conditions = @conditions, []
-          route.custom_conditions.concat(conditions)
-
-          invoke_hook(:padrino_route_added, route, verb, path, args, options, block)
+        # Add Sinatra conditions.
+        options.each { |o, a| route.respond_to?(o) ? route.send(o, *a) : send(o, *a) }
+        conditions, @conditions = @conditions, []
+        route.custom_conditions.concat(conditions)
 
-          # Add Application defaults
-          route.before_filters.concat(@filters[:before])
-          route.after_filters.concat(@filters[:after])
-          if @_controller
-            route.use_layout = @layout
-            route.controller = Array(@_controller)[0].to_s
-          end
+        invoke_hook(:padrino_route_added, route, verb, path, args, options, block)
 
-          deferred_routes[priority] << [route, block]
-
-          route
+        # Add Application defaults.
+        route.before_filters.concat(@filters[:before])
+        route.after_filters.concat(@filters[:after])
+        if @_controller
+          route.use_layout = @layout
+          route.controller = Array(@_controller)[0].to_s
         end
 
-        ##
-        # Returns the final parsed route details (modified to reflect all
-        # Padrino options) given the raw route. Raw route passed in could be
-        # a named alias or a string and is parsed to reflect provides formats,
-        # controllers, parents, 'with' parameters, and other options.
-        #
-        def parse_route(path, options, verb)
-          # We need save our originals path/options so we can perform correctly cache.
-          original = [path, options.dup]
-
-          # options for the route directly
-          route_options = {}
-
-          # We need check if path is a symbol, if that it's a named route
-          map = options.delete(:map)
-
-          if path.kind_of?(Symbol) # path i.e :index or :show
-            name = path                                                # The route name
-            path = map ? map.dup : (path == :index ? '/' : path.to_s)  # The route path
-          end
+        deferred_routes[priority] << [route, block]
 
-          # Build our controller
-          controller = Array(@_controller).map { |c| c.to_s }
+        route
+      end
 
-          case path
-          when String # path i.e "/index" or "/show"
-            # Now we need to parse our 'with' params
-            if with_params = options.delete(:with)
-              path = process_path_for_with_params(path, with_params)
-            end
+      ##
+      # Returns the final parsed route details (modified to reflect all
+      # Padrino options) given the raw route. Raw route passed in could be
+      # a named alias or a string and is parsed to reflect provides formats,
+      # controllers, parents, 'with' parameters, and other options.
+      #
+      def parse_route(path, options, verb)
+        route_options = {}
 
-            # Now we need to parse our provides
-            options.delete(:provides) if options[:provides].nil?
+        # We need check if path is a symbol, if that it's a named route.
+        map = options.delete(:map)
 
-            if @_use_format or format_params = options[:provides]
-              process_path_for_provides(path, format_params)
-              # options[:add_match_with] ||= {}
-              # options[:add_match_with][:format] = /[^\.]+/
-            end
+        # path i.e :index or :show
+        if path.kind_of?(Symbol)
+          name = path
+          path = map ? map.dup : (path == :index ? '/' : path.to_s)
+        end
 
-            absolute_map = map && map[0] == ?/
+        # Build our controller
+        controller = Array(@_controller).map(&:to_s)
 
-            unless controller.empty?
-              # Now we need to add our controller path only if not mapped directly
-              if map.blank? and !absolute_map
-                controller_path = controller.join("/")
-                path.gsub!(%r{^\(/\)|/\?}, "")
-                path = File.join(controller_path, path)  unless @_map
-              end
-              # Here we build the correct name route
-            end
+        case path
+        when String # path i.e "/index" or "/show"
+          # Now we need to parse our 'with' params
+          if with_params = options.delete(:with)
+            path = process_path_for_with_params(path, with_params)
+          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
-              path = process_path_for_parent_params(path, parent_params)
-            end
+          # Now we need to parse our provides
+          options.delete(:provides) if options[:provides].nil?
 
-            # Add any controller level map to the front of the path
-            path = "#{@_map}/#{path}".squeeze('/') unless absolute_map or @_map.blank?
-
-            # 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.squeeze!('/')
-          when Regexp
-            route_options[:path_for_generation] = options.delete(:generate_with) if options.key?(:generate_with)
+          if @_use_format or format_params = options[:provides]
+            process_path_for_provides(path, format_params)
+            # options[:add_match_with] ||= {}
+            # options[:add_match_with][:format] = /[^\.]+/
           end
 
-          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("_")
-            name = "#{controller_name}_#{name}".to_sym unless controller_name.blank?
+          absolute_map = map && map[0] == ?/
+
+          unless controller.empty?
+            # Now we need to add our controller path only if not mapped directly
+            if map.blank? and !absolute_map
+              controller_path = controller.join("/")
+              path.gsub!(%r{^\(/\)|/\?}, "")
+              path = File.join(controller_path, path)  unless @_map
+            end
           end
 
-          # Merge in option defaults
-          options.reverse_merge!(:default_values => @_defaults)
+          # 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
+            path = process_path_for_parent_params(path, parent_params)
+          end
 
-          [path, name, parent_params, options, route_options]
+          # Add any controller level map to the front of the path.
+          path = "#{@_map}/#{path}".squeeze('/') unless absolute_map or @_map.blank?
+
+          # 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.squeeze!('/')
+        when Regexp
+          route_options[:path_for_generation] = options.delete(:generate_with) if options.key?(:generate_with)
         end
 
-        ##
-        # Processes the existing path and appends the 'with' parameters onto the route
-        # 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("/"))
+        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("_")
+          name = "#{controller_name}_#{name}".to_sym unless controller_name.blank?
         end
 
-        ##
-        # Processes the existing path and prepends the 'parent' parameters onto the route
-        # Used for calculating path in route method.
-        #
-        def process_path_for_parent_params(path, parent_params)
-          parent_prefix = parent_params.flatten.compact.uniq.map do |param|
-            map  = (param.respond_to?(:map) && param.map ? param.map : param.to_s)
-            part = "#{map}/:#{param.to_s.singularize}_id/"
-            part = "(#{part})" if param.respond_to?(:optional) && param.optional?
-            part
-          end
+        # Merge in option defaults.
+        options.reverse_merge!(:default_values => @_defaults)
 
-          [parent_prefix, path].flatten.join("")
-        end
+        [path, name, parent_params, options, route_options]
+      end
+
+      ##
+      # Processes the existing path and appends the 'with' parameters onto the route
+      # 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("/"))
+      end
 
-        ##
-        # Processes the existing path and appends the 'format' suffix onto the route
-        # Used for calculating path in route method.
-        #
-        def process_path_for_provides(path, format_params)
-          path << "(.:format)" unless path[-10, 10] == '(.:format)'
+      ##
+      # Processes the existing path and prepends the 'parent' parameters onto the route
+      # Used for calculating path in route method.
+      #
+      def process_path_for_parent_params(path, parent_params)
+        parent_prefix = parent_params.flatten.compact.uniq.map do |param|
+          map  = (param.respond_to?(:map) && param.map ? param.map : param.to_s)
+          part = "#{map}/:#{param.to_s.singularize}_id/"
+          part = "(#{part})" if param.respond_to?(:optional) && param.optional?
+          part
         end
 
-        ##
-        # Allows routing by MIME-types specified in the URL or ACCEPT header.
-        #
-        # By default, if a non-provided mime-type is specified in a URL, the
-        # route will not match an thus return a 404.
-        #
-        # Setting the :treat_format_as_accept option to true allows treating
-        # missing mime types specified in the URL as if they were specified
-        # in the ACCEPT header and thus return 406.
-        #
-        # If no type is specified, the first in the provides-list will be
-        # returned.
-        #
-        # @example
-        #   get "/a", :provides => [:html, :js]
-        #   # => GET /a      => :html
-        #   # => GET /a.js   => :js
-        #   # => GET /a.xml  => 404
-        #
-        #   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.xml => 406
-        #
-        def provides(*types)
-          @_use_format = true
-          condition do
-            mime_types        = types.map { |t| mime_type(t) }.compact
-            url_format        = params[:format].to_sym if params[:format]
-            accepts           = request.accept.map { |a| a.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
+        [parent_prefix, path].flatten.join("")
+      end
 
-            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
+      ##
+      # Processes the existing path and appends the 'format' suffix onto the route.
+      # Used for calculating path in route method.
+      #
+      def process_path_for_provides(path, format_params)
+        path << "(.:format)" unless path[-10, 10] == '(.:format)'
+      end
 
-            matched_format = types.include?(:any)            ||
-                             types.include?(accept_format)   ||
-                             types.include?(url_format)      ||
-                             ((!url_format) && request.accept.empty? && types.include?(:html))
-
-            # 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)
-
-            if matched_format
-              @_content_type = url_format || accept_format || :html
-              content_type(@_content_type, :charset => 'utf-8')
-            end
+      ##
+      # Allows routing by MIME-types specified in the URL or ACCEPT header.
+      #
+      # By default, if a non-provided mime-type is specified in a URL, the
+      # route will not match an thus return a 404.
+      #
+      # Setting the :treat_format_as_accept option to true allows treating
+      # missing mime types specified in the URL as if they were specified
+      # in the ACCEPT header and thus return 406.
+      #
+      # If no type is specified, the first in the provides-list will be
+      # returned.
+      #
+      # @example
+      #   get "/a", :provides => [:html, :js]
+      #   # => GET /a      => :html
+      #   # => GET /a.js   => :js
+      #   # => GET /a.xml  => 404
+      #
+      #   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.xml => 406
+      #
+      def provides(*types)
+        @_use_format = true
+        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)
+
+          # 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
 
-            matched_format
+          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
-        end
 
-        ##
-        # Implements CSRF checking when `allow_disabled_csrf` is set to true.
-        #
-        # This condition is always on, except when it is explicitly switched
-        # off.
-        #
-        # @example
-        #   post("/", :csrf_protection => false)
-        #
-        def csrf_protection(on = true)
-          if on
-            condition { halt 403 if request.env['protection.csrf.failed'] }
+          matched_format = types.include?(:any)            ||
+                           types.include?(accept_format)   ||
+                           types.include?(url_format)      ||
+                           ((!url_format) && request.accept.empty? && types.include?(:html))
+
+          # 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)
+
+          if matched_format
+            @_content_type = url_format || accept_format || :html
+            content_type(@_content_type, :charset => 'utf-8')
           end
+
+          matched_format
         end
+      end
+
+      ##
+      # Implements CSRF checking when `allow_disabled_csrf` is set to true.
+      #
+      # This condition is always on, except when it is explicitly switched
+      # off.
+      #
+      # @example
+      #   post("/", :csrf_protection => false)
+      #
+      def csrf_protection(on = true)
+        if on
+          condition { halt 403 if request.env['protection.csrf.failed'] }
+        end
+      end
     end
 
     ##
@@ -914,7 +918,7 @@ module Padrino
     #
     module InstanceMethods
       ##
-      # Instance method for url generation.
+      # Instance method for URL generation.
       #
       # @example
       #   url(:show, :id => 1)
@@ -929,7 +933,7 @@ module Padrino
         # http://www.sinatrarb.com/intro#Generating%20URLs
         return super if args.first.is_a?(String) && !args[1].is_a?(Hash)
 
-        # Delegate to Padrino named route url generation
+        # Delegate to Padrino named route URL generation.
         settings.url(*args)
       end
       alias :url_for :url
@@ -945,9 +949,6 @@ module Padrino
         uri url(*args), true, false
       end
 
-      ##
-      # Returns the recognized path for a route.
-      #
       def recognize_path(path)
         settings.recognize_path(path)
       end
@@ -994,7 +995,7 @@ module Padrino
       def static!
         if path = static_file?(request.path_info)
           env['sinatra.static_file'] = path
-          cache_control *settings.static_cache_control if settings.static_cache_control?
+          cache_control(*settings.static_cache_control) if settings.static_cache_control?
           send_file(path, :disposition => nil)
         end
       end
@@ -1025,51 +1026,52 @@ module Padrino
       end
 
       private
-        def filter!(type, base=settings)
-          base.filters[type].each { |block| instance_eval(&block) }
-        end
 
-        def dispatch!
-          invoke do
-            static! if settings.static? && (request.get? || request.head?)
-            route!
-          end
+      def filter!(type, base=settings)
+        base.filters[type].each { |block| instance_eval(&block) }
+      end
+
+      def dispatch!
+        invoke do
+          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) }
+      ensure
+        @boom_handled or begin
+          filter! :after  unless env['sinatra.static_file']
         rescue ::Exception => boom
-          filter! :before  if boom.kind_of? ::Sinatra::NotFound
-          invoke { @boom_handled = handle_exception!(boom) }
-        ensure
-          @boom_handled  or begin
-            filter! :after  unless env['sinatra.static_file']
-          rescue ::Exception => boom
-            invoke { handle_exception!(boom) } unless @env['sinatra.error']
-          end
+          invoke { handle_exception!(boom) } unless @env['sinatra.error']
         end
+      end
 
-        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)
-              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'])
-              end
+      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)
+            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'])
             end
-          else
-            filter! :before
           end
+        else
+          filter! :before
+        end
 
-          # Run routes defined in superclass.
-          if base.superclass.respond_to?(:router)
-            route!(base.superclass, pass_block)
-            return
-          end
+        # Run routes defined in superclass.
+        if base.superclass.respond_to?(:router)
+          route!(base.superclass, pass_block)
+          return
+        end
 
-          route_eval(&pass_block) if pass_block
+        route_eval(&pass_block) if pass_block
 
-          route_missing
-        end
-    end # InstanceMethods
-  end # Routing
-end # Padrino
+        route_missing
+      end
+    end
+  end
+end