middleman-core 3.0.0.alpha.7

data/lib/middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/application/rendering.rb

@@ -0,0 +1,292 @@
+require 'padrino-core/support_lite' unless defined?(SupportLite)
+
+module Padrino
+  ##
+  # Padrino enhances the Sinatra 'render' method to have support for
+  # automatic template engine detection, enhanced layout functionality,
+  # locale enabled rendering, among other features.
+  #
+  module Rendering
+    ##
+    # Exception responsible for when an expected template did not exist.
+    #
+    class TemplateNotFound < RuntimeError
+    end
+
+    ##
+    # This is an array of file patterns to ignore. If your editor add a
+    # suffix during editing to your files please add it like:
+    #
+    # @example
+    #   Padrino::Rendering::IGNORE_FILE_PATTERN << /~$/
+    #
+    IGNORE_FILE_PATTERN = [
+      /~$/ # This is for Gedit
+    ] unless defined?(IGNORE_FILE_PATTERN)
+
+    ##
+    # Default rendering options used in the #render-method.
+    #
+    DEFAULT_RENDERING_OPTIONS = { :strict_format => false, :raise_exceptions => true } unless defined?(DEFAULT_RENDERING_OPTIONS)
+
+    class << self
+      ##
+      # Main class that register this extension.
+      #
+      def registered(app)
+        app.send(:include, InstanceMethods)
+        app.extend(ClassMethods)
+      end
+      alias :included :registered
+    end
+
+    ##
+    # Class methods responsible for rendering templates as part of a request.
+    #
+    module ClassMethods
+      ##
+      # Use layout like rails does or if a block given then like sinatra.
+      # If used without a block, sets the current layout for the route.
+      #
+      # By default, searches in your:
+      #
+      # +app+/+views+/+layouts+/+application+.(+haml+|+erb+|+xxx+)
+      # +app+/+views+/+layout_name+.(+haml+|+erb+|+xxx+)
+      #
+      # If you define +layout+ :+custom+ then searches for your layouts in
+      # +app+/+views+/+layouts+/+custom+.(+haml+|+erb+|+xxx+)
+      # +app+/+views+/+custom+.(+haml+|+erb+|+xxx+)
+      #
+      # @param [Symbol] name (:layout)
+      #   The layout to use.
+      #
+      # @yield []
+      #
+      def layout(name=:layout, &block)
+        return super(name, &block) if block_given?
+        @layout = name
+      end
+
+      ##
+      # Returns the cached template file to render for a given url, content_type and locale.
+      #
+      # @param [Array<template_path, content_type, locale>] render_options
+      #
+      def fetch_template_file(render_options)
+        (@_cached_templates ||= {})[render_options]
+      end
+
+      ##
+      # Caches the template file for the given rendering options
+      #
+      # @param [String] template_file
+      #   The path of the template file.
+      #
+      # @param [Array<template_path, content_type, locale>] render_options
+      #
+      def cache_template_file!(template_file, render_options)
+        (@_cached_templates ||= {})[render_options] = template_file || []
+      end
+
+      ##
+      # Returns the cached layout path.
+      #
+      # @param [Symbol, nil] given_layout
+      #   The requested layout.
+      #
+      def fetch_layout_path(given_layout=nil)
+        layout_name = given_layout || @layout || :application
+        @_cached_layout ||= {}
+        cached_layout_path = @_cached_layout[layout_name]
+        return cached_layout_path if cached_layout_path
+        has_layout_at_root = Dir["#{views}/#{layout_name}.*"].any?
+        layout_path = has_layout_at_root ? layout_name.to_sym : File.join('layouts', layout_name.to_s).to_sym
+        @_cached_layout[layout_name] = layout_path unless reload_templates?
+        layout_path
+      end
+    end
+
+    # Instance methods that allow enhanced rendering to function properly in Padrino.
+    module InstanceMethods
+      attr_reader :current_engine
+
+      ##
+      # Get/Set the content_type
+      #
+      # @param [String, nil] type
+      #   The Content-Type to use.
+      #
+      # @param [Symbol, nil] type.
+      #   Look and parse the given symbol to the matched Content-Type.
+      #
+      # @param [Hash] params
+      #   Additional params to append to the Content-Type.
+      #
+      # @example
+      #   case content_type
+      #     when :js then do_some
+      #     when :css then do_another
+      #   end
+      #
+      #   content_type :js
+      #   # => set the response with 'application/javascript' Content-Type
+      #   content_type 'text/html'
+      #
+      #   # => set directly the Content-Type to 'text/html'
+      #
+      def content_type(type=nil, params={})
+        unless type.nil?
+          super(type, params)
+          @_content_type = type
+        end
+        @_content_type
+      end
+
+      private
+        ##
+        # Enhancing Sinatra render functionality for:
+        #
+        # * Using layout similar to rails
+        # * Use render 'path/to/my/template'   (without symbols)
+        # * Use render 'path/to/my/template'   (with engine lookup)
+        # * Use render 'path/to/template.haml' (with explicit engine lookup)
+        # * Use render 'path/to/template', :layout => false
+        # * Use render 'path/to/template', :layout => false, :engine => 'haml'
+        # * Use render { :a => 1, :b => 2, :c => 3 } # => return a json string
+        #
+        def render(engine, data=nil, options={}, locals={}, &block)
+          # If engine is a hash then render data converted to json
+          content_type(:json, :charset => 'utf-8') and return engine.to_json if engine.is_a?(Hash)
+
+          # If engine is nil, ignore engine parameter and shift up all arguments
+          # render nil, "index", { :layout => true }, { :localvar => "foo" }
+          engine, data, options = data, options, locals if engine.nil? && data
+
+          # Data is a hash of options when no engine isn't explicit
+          # render "index", { :layout => true }, { :localvar => "foo" }
+          # Data is options, and options is locals in this case
+          data, options, locals = nil, data, options if data.is_a?(Hash)
+
+          # If data is unassigned then this is a likely a template to be resolved
+          # This means that no engine was explicitly defined
+          data, engine = *resolve_template(engine, options.dup) if data.nil?
+
+          # Setup root
+          root = settings.respond_to?(:root) ? settings.root : ""
+
+          # Use @layout if it exists
+          options[:layout] = @layout if options[:layout].nil?
+
+          # Resolve layouts similar to in Rails
+          if (options[:layout].nil? || options[:layout] == true) && !settings.templates.has_key?(:layout)
+            layout_path, layout_engine = *resolved_layout
+            options[:layout] = layout_path || false # We need to force layout false so sinatra don't try to render it
+            options[:layout] = false unless layout_engine == engine # TODO allow different layout engine
+            options[:layout_engine] = layout_engine || engine if options[:layout]
+          elsif options[:layout].present?
+            options[:layout] = settings.fetch_layout_path(options[:layout] || @layout)
+          end
+
+          # Cleanup the template
+          @current_engine, engine_was = engine, @current_engine
+          @_out_buf,  _buf_was = "", @_out_buf
+
+          # Pass arguments to Sinatra render method
+          super(engine, data, options.dup, locals, &block)
+        ensure
+          @current_engine = engine_was
+          @_out_buf = _buf_was
+        end
+
+        ##
+        # Returns the located layout tuple to be used for the rendered template
+        # (if available).
+        #
+        # @example
+        #   resolve_layout
+        #   # => ["/layouts/custom", :erb]
+        #   # => [nil, nil]
+        #
+        def resolved_layout
+          located_layout = resolve_template(settings.fetch_layout_path, :raise_exceptions => false, :strict_format => true)
+          located_layout ? located_layout : [nil, nil]
+        end
+
+        ##
+        # Returns the template path and engine that match content_type (if present),
+        # I18n.locale.
+        #
+        # @param [String] template_path
+        #   The path of the template.
+        #
+        # @param [Hash] options
+        #   Additional options.
+        #
+        # @option options [Boolean] :strict_format (false)
+        #   The resolved template must match the content_type of the request.
+        #
+        # @option options [Boolean] :raise_exceptions (false)
+        #   Raises a {TemplateNotFound} exception if the template cannot be located.
+        #
+        # @return [Array<Symbol, Symbol>]
+        #   The path and format of the template.
+        #
+        # @raise [TemplateNotFound]
+        #   The template could not be found.
+        #
+        # @example
+        #   get "/foo", :provides => [:html, :js] do; render 'path/to/foo'; end
+        #   # If you request "/foo.js" with I18n.locale == :ru => [:"/path/to/foo.ru.js", :erb]
+        #   # If you request "/foo" with I18n.locale == :de => [:"/path/to/foo.de.haml", :haml]
+        #
+        def resolve_template(template_path, options={})
+          began_at = Time.now
+          # Fetch cached template for rendering options
+          template_path = template_path.to_s[0] == ?/ ? template_path.to_s : "/#{template_path}"
+          rendering_options = [template_path, content_type, locale]
+          cached_template = settings.fetch_template_file(rendering_options)
+          if cached_template
+            logger.debug :cached, began_at, cached_template[0] if settings.logging? && defined?(logger)
+            return cached_template
+          end
+
+          # Resolve view path and options
+          options.reverse_merge!(DEFAULT_RENDERING_OPTIONS)
+          view_path = options.delete(:views) || settings.views || "./views"
+          target_extension = File.extname(template_path)[1..-1] || "none" # explicit template extension
+          template_path = template_path.chomp(".#{target_extension}")
+
+          # Generate potential template candidates
+          templates = Dir[File.join(view_path, template_path) + ".*"].map do |file|
+            template_engine = File.extname(file)[1..-1].to_sym # retrieves engine extension
+            template_file   = file.sub(view_path, '').chomp(".#{template_engine}").to_sym # retrieves template filename
+            [template_file, template_engine] unless IGNORE_FILE_PATTERN.any? { |pattern| template_engine.to_s =~ pattern }
+          end
+
+          # Check if we have a simple content type
+          simple_content_type = [:html, :plain].include?(content_type)
+
+          # Resolve final template to render
+          located_template =
+            templates.find { |file, e| file.to_s == "#{template_path}.#{locale}.#{content_type}" } ||
+            templates.find { |file, e| file.to_s == "#{template_path}.#{locale}" && simple_content_type } ||
+            templates.find { |file, e| File.extname(file.to_s) == ".#{target_extension}" or e.to_s == target_extension.to_s } ||
+            templates.find { |file, e| file.to_s == "#{template_path}.#{content_type}" } ||
+            templates.find { |file, e| file.to_s == "#{template_path}" && simple_content_type } ||
+            (!options[:strict_format] && templates.first) # If not strict, fall back to the first located template
+
+          raise TemplateNotFound, "Template '#{template_path}' not found in '#{view_path}'!"  if !located_template && options[:raise_exceptions]
+          settings.cache_template_file!(located_template, rendering_options) unless settings.reload_templates?
+          logger.debug :template, began_at, located_template[0] if located_template && settings.logging? && defined?(logger)
+          located_template
+        end
+
+        ##
+        # Return the I18n.locale if I18n is defined.
+        #
+        def locale
+          I18n.locale if defined?(I18n)
+        end
+    end # InstanceMethods
+  end # Rendering
+end # Padrino

data/lib/middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/application/routing.rb

@@ -0,0 +1,934 @@
+require 'http_router' unless defined?(HttpRouter)
+require 'padrino-core/support_lite' unless defined?(SupportLite)
+
+##
+# Adds to Sinatra +controller+ informations
+#
+# @private
+class Sinatra::Request
+  attr_accessor :route_obj
+
+  def controller
+    route_obj && route_obj.controller
+  end
+end
+
+##
+# HttpRouter adapter
+#
+# @private
+class HttpRouter
+  def rewrite_partial_path_info(env, request); end
+  def rewrite_path_info(env, request); end
+
+  def process_destination_path(path, env)
+    Thread.current['padrino.instance'].instance_eval do
+      request.route_obj = path.route
+      @_response_buffer = nil
+      @route    = path.route
+      @params ||= {}
+      @params.update(env['router.params'])
+      @block_params = if path.route.is_a?(HttpRouter::RegexRoute)
+        params_list = env['router.request'].extra_env['router.regex_match'].to_a
+        params_list.shift
+        @params[:captures] = params_list
+        params_list
+      else
+        env['router.request'].params
+      end
+      # Provide access to the current controller to the request
+      # Now we can eval route, but because we have "throw halt" we need to be
+      # (en)sure to reset old layout and run controller after filters.
+      original_params = @params
+      parent_layout   = @layout
+      successful      = false
+      begin
+        filter! :before
+        (@route.before_filters - settings.filters[:before]).each { |block| instance_eval(&block) }
+        @layout = path.route.use_layout if path.route.use_layout
+        @route.custom_conditions.each { |block| pass if block.bind(self).call == false } if @route.custom_conditions
+        @block_params     = @block_params[0, @route.dest.arity] if @route.dest.arity > 0
+        halt_response     = catch(:halt) { route_eval { @route.dest[self, @block_params] } }
+        @_response_buffer = halt_response.is_a?(Array) ? halt_response.last : halt_response
+        successful        = true
+        halt halt_response
+      ensure
+        (@route.after_filters - settings.filters[:after]).each { |block| instance_eval(&block) } if successful
+        @layout = parent_layout
+        @params = original_params
+      end
+    end
+  end
+
+  # @private
+  class Route
+    attr_accessor :use_layout, :controller, :cache, :cache_key, :cache_expires_in
+
+    def before_filters(&block)
+      @_before_filters ||= []
+      @_before_filters << block if block_given?
+
+      @_before_filters
+    end
+
+    def after_filters(&block)
+      @_after_filters ||= []
+      @_after_filters << block if block_given?
+
+      @_after_filters
+    end
+
+    def custom_conditions(&block)
+      @_custom_conditions ||= []
+      @_custom_conditions << block if block_given?
+
+      @_custom_conditions
+    end
+  end
+end
+
+module Padrino
+  class Filter # @private
+    attr_reader :block
+
+    def initialize(mode, scoped_controller, options, args, &block)
+      @mode, @scoped_controller, @options, @args, @block = mode, scoped_controller, options, args, block
+    end
+
+    def apply?(request)
+      detect = @args.any? do |arg|
+        case arg
+        when Symbol then request.route_obj && (request.route_obj.named == arg or request.route_obj.named == [@scoped_controller, arg].flatten.join("_").to_sym)
+        else             arg === request.path_info
+        end
+      end || @options.any? do |name, val|
+        case name
+        when :agent then val === request.user_agent
+        else             val === request.send(name)
+        end
+      end
+      detect ^ !@mode
+    end
+
+    def to_proc
+      if @args.empty? && @options.empty?
+        block
+      else
+        filter = self
+        proc { instance_eval(&filter.block) if filter.apply?(request) }
+      end
+    end
+  end
+
+  ##
+  # Padrino provides advanced routing definition support to make routes and
+  # url generation much easier. This routing system supports named route
+  # aliases and easy access to url paths. The benefits of this is that instead
+  # of having to hard-code route urls into every area of your application, now
+  # we can just define the urls in a single spot and then attach an alias
+  # which can be used to refer to the url throughout the application.
+  #
+  module Routing
+    # 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)
+
+    # Raised when a route was invalid or cannot be processed.
+    class UnrecognizedException < RuntimeError; end
+
+    class Parent < String # @private
+      attr_reader :map
+      attr_reader :optional
+      attr_reader :options
+
+      alias_method :optional?, :optional
+
+      def initialize(value, options={})
+        super(value.to_s)
+        @map      = options.delete(:map)
+        @optional = options.delete(:optional)
+        @options  = options
+      end
+    end
+
+    class << self
+      ##
+      # Main class that register this extension.
+      #
+      def registered(app)
+        app.send(:include, InstanceMethods)
+        app.extend(ClassMethods)
+      end
+      alias :included :registered
+    end
+
+    # Class methods responsible for enhanced routing for controllers.
+    module ClassMethods
+      ##
+      # Method for organize in a better way our routes.
+      #
+      # @param [Array] args
+      #   Controller arguments.
+      #
+      # @yield []
+      #   The given block will be used to define the routes within the
+      #   Controller.
+      #
+      # @example
+      #   controller :admin do
+      #     get :index do; ...; end
+      #     get :show, :with => :id  do; ...; end
+      #   end
+      #
+      #   url(:admin_index) # => "/admin"
+      #   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
+      #   end
+      #
+      # @example Supply +:provides+ to all controller routes:
+      #   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
+      #   end
+      #
+      # @example Specify parent resources in padrino with the +:parent+ option on the controller:
+      #   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"
+      #     end
+      #     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"
+      #     end
+      #   end
+      #
+      # @example Specify conditions to run for all routes:
+      #   controller :conditions => {:protect => true} do
+      #     def self.protect(protected)
+      #       condition do
+      #         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" }
+      #
+      #     # And this one, too!
+      #     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!"
+      #     end
+      #   end
+      #
+      # @example Supply default values:
+      #   controller :lang => :de do
+      #     get :index, :map => "/:lang" do; "params[:lang] == :de"; end
+      #   end
+      #
+      # In a controller before and after filters are scoped and didn't affect other controllers or main app.
+      # In a controller layout are scoped and didn't affect others controllers and main app.
+      #
+      # @example
+      #   controller :posts do
+      #     layout :post
+      #     before { foo }
+      #     after  { bar }
+      #   end
+      #
+      def controller(*args, &block)
+        if block_given?
+          options = args.extract_options!
+
+          # Controller defaults
+          @_controller, original_controller = args,                        @_controller
+          @_parents,    original_parent     = options.delete(:parent),     @_parents
+          @_provides,   original_provides   = options.delete(:provides),   @_provides
+          @_use_format, original_use_format = options.delete(:use_format), @_use_format
+          @_cache,      original_cache      = options.delete(:cache),      @_cache
+          @_map,        original_map        = options.delete(:map),        @_map
+          @_conditions, original_conditions = options.delete(:conditions), @_conditions
+          @_defaults,   original_defaults   = options,                     @_defaults
+
+          # Application defaults
+          @filters,     original_filters    = { :before => @filters[:before].dup, :after => @filters[:after].dup }, @filters
+          @layout,      original_layout     = nil, @layout
+
+          instance_eval(&block)
+
+          # Application defaults
+          @filters        = original_filters
+          @layout         = original_layout
+
+          # Controller defaults
+          @_controller, @_parents,  @_cache = original_controller, original_parent,   original_cache
+          @_defaults,   @_provides, @_map   = original_defaults,   original_provides, original_map
+          @_conditions, @_use_format        = original_conditions, original_use_format
+        else
+          include(*args) if extensions.any?
+        end
+      end
+      alias :controllers :controller
+
+      ##
+      # Add a before filter hook
+      #
+      # @see #construct_filter
+      #
+      def before(*args, &block)
+        add_filter :before, &(args.empty? ? block : construct_filter(*args, &block))
+      end
+
+      ##
+      # Add an after filter hook
+      #
+      # @see #construct_filter
+      #
+      def after(*args, &block)
+        add_filter :after, &(args.empty? ? block : construct_filter(*args, &block))
+      end
+
+      ##
+      # Adds a filter hook to a request.
+      #
+      def  add_filter(type, &block)
+        filters[type] << block
+      end
+
+      ##
+      # Creates a filter to process before/after the matching route.
+      #
+      # @param [Array] args
+      #
+      # @example We are be able to filter with String path
+      #   before('/') { 'only to :index' }
+      #   get(:index} { 'foo' } # => filter match only before this.
+      #   get(:main) { 'bar' }
+      #
+      # @example is the same of
+      #   before(:index) { 'only to :index' }
+      #   get(:index} { 'foo' } # => filter match only before this.
+      #   get(:main) { 'bar' }
+      #
+      # @example it works only for the given controller
+      #   controller :foo do
+      #     before(:index) { 'only to for :foo_index' }
+      #     get(:index} { 'foo' } # => filter match only before this.
+      #     get(:main) { 'bar' }
+      #   end
+      #
+      #   controller :bar do
+      #     before(:index) { 'only to for :bar_index' }
+      #     get(:index} { 'foo' } # => filter match only before this.
+      #     get(:main) { 'bar' }
+      #   end
+      #
+      # @example if filters based on a symbol or regexp
+      #   before :index, /main/ do; ... end
+      #   # => match oly path that are  +/+ or contains +main+
+      #
+      # @example filtering everything except an occurency
+      #   before :except => :index do; ...; end
+      #
+      # @example you can also filter using a request param
+      #   before :agent => /IE/ do; ...; end
+      #   # => match +HTTP_USER_AGENT+ containing +IE+
+      #
+      # @see http://www.padrinorb.com/guides/controllers#route-filters
+      #
+      def construct_filter(*args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        except = options.key?(:except) && Array(options.delete(:except))
+        raise("You cannot use except with other options specified") if except && (!args.empty? || !options.empty?)
+        options = except.last.is_a?(Hash) ? except.pop : {} if except
+        Filter.new(!except, @_controller, options, Array(except || args), &block)
+      end
+
+      ##
+      # Provides many parents with shallowing.
+      #
+      # @param [Symbol] name
+      #   The parent name.
+      #
+      # @param [Hash] options
+      #   Additional options.
+      #
+      # @example
+      #   controllers :product 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"
+      #     end
+      #   end
+      #
+      def parent(name, options={})
+        defaults = { :optional => false, :map => name.to_s }
+        options = defaults.merge(options)
+        @_parents = Array(@_parents) unless @_parents.is_a?(Array)
+        @_parents << Parent.new(name, options)
+      end
+
+      ##
+      # Using {HttpRouter}, for features and configurations.
+      #
+      # @example
+      #   router.add('/greedy/:greed')
+      #   router.recognize('/simple')
+      #
+      # @see http://github.com/joshbuddy/http_router
+      #
+      def router
+        @router ||= HttpRouter.new
+        block_given? ? yield(@router) : @router
+      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) } }
+          @deferred_routes = nil
+          router
+        end
+      end
+
+      # Returns all routes that were deferred based on their priority.
+      def deferred_routes
+        @deferred_routes ||= Hash[ROUTE_PRIORITY.values.sort.map{|p| [p, []]}]
+      end
+
+      ##
+      # Resets the http router and all deferred routes.
+      #
+      def reset_router!
+        @deferred_routes = nil
+        router.reset!
+      end
+
+      ##
+      # Recognize a given path
+      #
+      # @param [String] path
+      #   Path+Query to parse
+      #
+      # @return [Symbol, Hash]
+      #   Returns controller and query params.
+      #
+      # @example Giving a controller like:
+      #   controller :foo do
+      #     get :bar, :map => 'foo-bar-:id'; ...; end
+      #   end
+      #
+      # @example You should be able to reverse:
+      #   MyApp.url(:foo_bar, :id => :mine)
+      #   # => /foo-bar-mine
+      #
+      # @example Into this:
+      #   MyApp.recognize_path('foo-bar-mine')
+      #   # => [:foo_bar, :id => :mine]
+      #
+      def recognize_path(path)
+        responses = @router.recognize(Rack::MockRequest.env_for(path))
+        [responses[0].path.route.named, responses[0].params]
+      end
+
+      ##
+      # Instance method for url generation.
+      #
+      # @example
+      #   url(:show, :id => 1)
+      #   url(:show, :name => 'test', :id => 24)
+      #   url(:show, 1)
+      #   url(:controller_name, :show, :id => 21)
+      #   url(:controller_show, :id => 29)
+      #
+      def url(*args)
+        params = args.extract_options!  # parameters is hash at end
+        names, params_array = args.partition{|a| a.is_a?(Symbol)}
+        name = names.join("_").to_sym    # route name is concatenated with underscores
+        if params.is_a?(Hash)
+          params[:format] = params[:format].to_s unless params[:format].nil?
+          params = value_to_param(params)
+        end
+        url = if params_array.empty?
+          compiled_router.url(name, params)
+        else
+          compiled_router.url(name, *(params_array << params))
+        end
+        url[0,0] = conform_uri(uri_root) if defined?(uri_root)
+        url[0,0] = conform_uri(ENV['RACK_BASE_URI']) if ENV['RACK_BASE_URI']
+        url = "/" if url.blank?
+        url
+      rescue HttpRouter::InvalidRouteException
+        route_error = "route mapping for url(#{name.inspect}) could not be found!"
+        raise Padrino::Routing::UnrecognizedException.new(route_error)
+      end
+      alias :url_for :url
+
+      def get(path, *args, &block) # @private
+        conditions = @conditions.dup
+        route('GET', path, *args, &block)
+
+        @conditions = conditions
+        route('HEAD', path, *args, &block)
+      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
+        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
+        #
+        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
+          path, *route_options[:with] = path if path.is_a?(Array)
+          path, name, 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.name(name) if name
+          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.send(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.default(defaults) if defaults
+          end
+          options.delete_if do |option, args|
+            if route.send(:significant_variable_names).include?(option)
+              route.matching(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 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
+
+          deferred_routes[priority] << [route, block]
+
+          route
+        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]
+
+          # 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
+
+          if path.kind_of?(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 provides
+            options.delete(:provides) if options[:provides].nil?
+
+            if @_use_format or format_params = options[:provides]
+              process_path_for_provides(path, format_params)
+              options[:matching] ||= {}
+              options[:matching][:format] = /[^\.]+/
+            end
+
+            # Build our controller
+            controller = Array(@_controller).map { |c| c.to_s }
+
+            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)
+              end
+              # Here we build the correct name route
+              if name
+                controller_name = controller.join("_")
+                name = "#{controller_name}_#{name}".to_sym unless controller_name.blank?
+              end
+            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)
+              path = process_path_for_parent_params(path, parent_params)
+            end
+
+            # 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!('/')
+          end
+
+          # Merge in option defaults
+          options.reverse_merge!(:default_values => @_defaults)
+
+          [path, name, 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 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
+
+          [parent_prefix, path].flatten.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)'
+        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) }
+            url_format        = params[:format].to_sym if params[:format]
+            accepts           = request.accept.map { |a| a.split(";")[0].strip }
+
+            # 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 !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
+              type = types.first
+              accept_format = CONTENT_TYPE_ALIASES[type] || type
+            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
+
+            matched_format
+          end
+        end
+    end
+
+    ##
+    # Instance methods related to recognizing and processing routes and serving static files.
+    #
+    module InstanceMethods
+      ##
+      # Instance method for url generation.
+      #
+      # @example
+      #   url(:show, :id => 1)
+      #   url(:show, :name => :test)
+      #   url(:show, 1)
+      #   url("/foo")
+      #
+      # @see Padrino::Routing::ClassMethods#url
+      #
+      def url(*args)
+        # Delegate to Sinatra 1.2 for simple url("/foo")
+        # 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
+        settings.url(*args)
+      end
+      alias :url_for :url
+
+      ##
+      # Returns the recognized path for a route.
+      #
+      def recognize_path(path)
+        settings.recognize_path(path)
+      end
+
+      ##
+      # Returns the current path within a route from specified +path_params+.
+      #
+      def current_path(*path_params)
+        if path_params.last.is_a?(Hash)
+          path_params[-1] = params.merge(path_params[-1])
+        else
+          path_params << params
+        end
+        @route.url(*path_params)
+      end
+
+      ##
+      # Returns the current route
+      #
+      # @example
+      #   -if route.controller == :press
+      #     %li=show_article
+      #
+      def route
+        @route
+      end
+
+      ##
+      # This is mostly just a helper so request.path_info isn't changed when
+      # serving files from the public directory.
+      #
+      def static_file?(path_info)
+        return if (public_dir = settings.public_folder).nil?
+        public_dir = File.expand_path(public_dir)
+        path = File.expand_path(public_dir + unescape(path_info))
+        return if path[0, public_dir.length] != public_dir
+        return unless File.file?(path)
+        return path
+      end
+
+      #
+      # Method for deliver static files.
+      #
+      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?
+          send_file(path, :disposition => nil)
+        end
+      end
+
+      ##
+      # Return the request format, this is useful when we need to respond to
+      # a given Content-Type.
+      #
+      # @param [Symbol, nil] type
+      #
+      # @param [Hash] params
+      #
+      # @example
+      #   get :index, :provides => :any do
+      #     case content_type
+      #       when :js    then ...
+      #       when :json  then ...
+      #       when :html  then ...
+      #     end
+      #   end
+      #
+      def content_type(type=nil, params={})
+        unless type.nil?
+          super(type, params)
+          @_content_type = type
+        end
+        @_content_type
+      end
+
+      private
+        def filter!(type, base=settings)
+          base.filters[type].each { |block| instance_eval(&block) }
+        end
+
+        def dispatch!
+          static! if settings.static? && (request.get? || request.head?)
+          route!
+        rescue ::Exception => boom
+          filter! :before
+          handle_exception!(boom)
+        ensure
+          filter! :after unless env['sinatra.static_file']
+        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
+              end
+            end
+          else
+            filter! :before
+          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_missing
+        end
+    end # InstanceMethods
+  end # Routing
+end # Padrino