tennpipes-base 3.6.6

data/lib/tennpipes-base/application/params_protection.rb

@@ -0,0 +1,129 @@
+begin
+  require 'active_support/core_ext/object/deep_dup' # AS 4.1
+rescue LoadError
+  require 'active_support/core_ext/hash/deep_dup' # AS >= 3.1
+end
+
+module Tennpipes
+  ##
+  # Tennpipes application module providing means for mass-assignment protection.
+  #
+  module ParamsProtection
+    class << self
+      def registered(app)
+        included(app)
+      end
+
+      def included(base)
+        base.send(:include, InstanceMethods)
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      ##
+      # Implements filtering of url query params. Can prevent mass-assignment.
+      #
+      # @example
+      #   post :update, :params => [:name, :email]
+      #   post :update, :params => [:name, :id => Integer]
+      #   post :update, :params => [:name => proc{ |v| v.reverse }]
+      #   post :update, :params => [:name, :parent => [:name, :position]]
+      #   post :update, :params => false
+      #   post :update, :params => true
+      # @example
+      #   params :name, :email, :password => prox{ |v| v.reverse }
+      #   post :update
+      # @example
+      #   App.controller :accounts, :params => [:name, :position] do
+      #     post :create
+      #     post :update, :with => [ :id ], :params => [:name, :position, :addition]
+      #     get :show, :with => :id, :params => false
+      #     get :search, :params => true
+      #   end
+      #
+      def params(*allowed_params)
+        allowed_params = prepare_allowed_params(allowed_params)
+        condition do
+          @original_params = params.deep_dup
+          filter_params!(params, allowed_params)
+        end
+      end
+
+      private
+
+      def prepare_allowed_params(allowed_params)
+        param_filter = {}
+        allowed_params.each do |key,value|
+          case
+          when key.kind_of?(Hash) && !value
+            param_filter.update(prepare_allowed_params(key))
+          when value.kind_of?(Hash) || value.kind_of?(Array)
+            param_filter[key.to_s] = prepare_allowed_params(value)
+          else
+            param_filter[key.to_s] = value == false ? false : (value || true)
+          end
+        end
+        param_filter.freeze
+      end
+    end
+
+    module InstanceMethods
+      ##
+      # Filters a hash of parameters leaving only allowed ones and possibly
+      # typecasting and processing the others.
+      #
+      # @param [Hash] params
+      #   Parameters to filter.
+      #   Warning: this hash will be changed by deleting or replacing its values.
+      # @param [Hash] allowed_params
+      #   A hash of allowed keys and value classes or processing procs. Supported
+      #   scalar classes are: Integer (empty string is cast to nil).
+      #
+      # @example
+      #   filter_params!( { "a" => "1", "b" => "abc", "d" => "drop" },
+      #                   { "a" => Integer, "b" => true } )
+      #   # => { "a" => 1, "b" => "abc" }
+      #   filter_params!( { "id" => "", "child" => { "name" => "manny" } },
+      #                   { "id" => Integer, "child" => { "name" => proc{ |v| v.camelize } } } )
+      #   # => { "id" => nil, "child" => { "name" => "Manny" } }
+      #   filter_params!( { "a" => ["1", "2", "3"] },
+      #                   { "a" => true } )
+      #   # => { "a" => ["1", "2", "3"] }
+      #   filter_params!( { "persons" => {"p-1" => { "name" => "manny", "age" => "50" }, "p-2" => { "name" => "richard", "age" => "50" } } },
+      #                   { "persons" => { "name" => true } } )
+      #   # => { "persons" => {"p-1" => { "name" => "manny" }, "p-2" => { "name" => "richard" } } }
+      #
+      def filter_params!(params, allowed_params)
+        params.each do |key,value|
+          type = allowed_params[key]
+          next if value.kind_of?(Array) && type
+          case
+          when type.kind_of?(Hash) && value.kind_of?(Hash)
+            if key == key.pluralize && value.values.first.kind_of?(Hash)
+              value.each do |array_index,array_value|
+                value[array_index] = filter_params!(array_value, type)
+              end
+            else
+              params[key] = filter_params!(value, type)
+            end
+          when type == Integer
+            params[key] = value.empty? ? nil : value.to_i
+          when type.kind_of?(Proc)
+            params[key] = type.call(value)
+          when type == true
+          else
+            params.delete(key)
+          end
+        end
+      end
+
+      ##
+      # Returns the original unfiltered query parameters hash.
+      #
+      def original_params
+        @original_params || params
+      end
+    end
+  end
+end

data/lib/tennpipes-base/application/routing.rb

@@ -0,0 +1,1002 @@
+require 'tennpipes-assist'
+require 'tennpipes-base/path_router' unless defined?(PathRouter)
+require 'tennpipes-base/ext/sinatra'
+require 'tennpipes-base/filter'
+
+module Tennpipes
+  ##
+  # Tennpipes 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
+
+    # Raised when block arity was nonzero and was not same with
+    # captured parameter length.
+    class BlockArityError < ArgumentError
+      def initialize(path, block_arity, required_arity)
+        super "route block arity does not match path '#{path}' (#{block_arity} for #{required_arity})"
+      end
+    end
+
+    class Parent < String
+      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 to organize our routes in a better way.
+      #
+      # @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 tennpipes 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 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
+      #     layout :post
+      #     before { foo }
+      #     after  { bar }
+      #   end
+      #
+      def controller(*args, &block)
+        if block_given?
+          with_new_options(*args) { instance_eval(&block) }
+        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 only path that are  +/+ or contains +main+
+      #
+      # @example filtering everything except an occurrence
+      #   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.tennpipesrb.com/guides/controllers#route-filters
+      #
+      def construct_filter(*args, &block)
+        options = args.extract_options!
+        if except = options.delete(:except)
+          fail "You cannot use :except with other options specified" unless args.empty? && options.empty?
+          options = Array(except).extract_options!
+        end
+        Filter.new(!except, @_controller, options, Array(except || args), &block)
+      end
+
+      ##
+      # 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 = nil, options={})
+        return super() unless name
+        defaults = { :optional => false, :map => name.to_s }
+        options = defaults.merge(options)
+        @_parent = Array(@_parent) unless @_parent.is_a?(Array)
+        @_parent << Parent.new(name, options)
+      end
+
+      ##
+      # Using PathRouter, for features and configurations.
+      #
+      # @example
+      #   router.add('/greedy/:greed')
+      #   router.recognize('/simple')
+      #
+      def router
+        @router ||= PathRouter.new
+        block_given? ? yield(@router) : @router
+      end
+      alias :urls :router
+
+      def compiled_router
+        if @deferred_routes
+          deferred_routes.each do |routes|
+            routes.each do |(route, dest)|
+              route.to(&dest)
+              route.before_filters.flatten!
+              route.after_filters.flatten!
+            end
+          end
+          @deferred_routes = nil
+        end
+        router
+      end
+
+      def deferred_routes
+        @deferred_routes ||= ROUTE_PRIORITY.map{[]}
+      end
+
+      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_path(path)
+        [responses[0], responses[1]]
+      end
+
+      ##
+      # Instance method for url generation.
+      #
+      # @option options [String] :fragment
+      #   An addition to url to identify a portion of requested resource (i.e #something).
+      # @option options [String] :anchor
+      #   Synonym for fragment.
+      #
+      # @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)
+      #   url(:index, :fragment => 'comments')
+      #
+      def url(*args)
+        params = args.extract_options!
+        fragment = params.delete(:fragment) || params.delete(:anchor)
+        path = make_path_with_params(args, value_to_param(params.symbolize_keys))
+        rebase_url(fragment ? path << '#' << fragment.to_s : path)
+      end
+      alias :url_for :url
+
+      def get(path, *args, &block)
+        conditions = @conditions.dup
+        route('GET', path, *args, &block)
+
+        @conditions = conditions
+        route('HEAD', path, *args, &block)
+      end
+
+      def put(path, *args, &block)     route 'PUT',     path, *args, &block end
+      def post(path, *args, &block)    route 'POST',    path, *args, &block end
+      def delete(path, *args, &block)  route 'DELETE',  path, *args, &block end
+      def head(path, *args, &block)    route 'HEAD',    path, *args, &block end
+      def options(path, *args, &block) route 'OPTIONS', path, *args, &block end
+      def patch(path, *args, &block)   route 'PATCH',   path, *args, &block end
+      def link(path, *args, &block)    route 'LINK',    path, *args, &block end
+      def unlink(path, *args, &block)  route 'UNLINK',  path, *args, &block end
+
+      def rebase_url(url)
+        if url.start_with?('/')
+          new_url = ''
+          new_url << conform_uri(ENV['RACK_BASE_URI']) if ENV['RACK_BASE_URI']
+          new_url << conform_uri(uri_root) if defined?(uri_root)
+          new_url << url
+        else
+          url.blank? ? '/' : url
+        end
+      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
+
+      private
+
+      CONTROLLER_OPTIONS = [ :parent, :provides, :use_format, :cache, :expires, :map, :conditions, :accepts, :params ].freeze
+
+      # Saves controller options, yields the block, restores controller options.
+      def with_new_options(*args)
+        options = args.extract_options!
+
+        CONTROLLER_OPTIONS.each{ |key| replace_instance_variable("@_#{key}", options.delete(key)) }
+        replace_instance_variable(:@_controller, args)
+        replace_instance_variable(:@_defaults, options)
+        replace_instance_variable(:@filters, :before => @filters[:before].dup, :after => @filters[:after].dup)
+        replace_instance_variable(:@layout, nil)
+
+        yield
+
+        @original_instance.each do |key, value|
+          instance_variable_set(key, value)
+        end
+      end
+
+      # Sets instance variable by name and saves the original value in @original_instance hash
+      def replace_instance_variable(name, value)
+        @original_instance ||= {}
+        @original_instance[name] = instance_variable_get(name)
+        instance_variable_set(name, value)
+      end
+
+      # Searches compiled router for a path responding to args and makes a path with params.
+      def make_path_with_params(args, params)
+        names, params_array = args.partition{ |arg| arg.is_a?(Symbol) }
+        name = names[0, 2].join(" ").to_sym
+        compiled_router.path(name, *(params_array << params))
+      rescue PathRouter::InvalidRouteException
+        raise Tennpipes::Routing::UnrecognizedException, "Route mapping for url(#{name.inspect}) could not be found"
+      end
+
+      # Parse params from the url method
+      def value_to_param(object)
+        case object
+        when Array
+          object.map { |item| value_to_param(item) }.compact
+        when Hash
+          object.inject({}) do |all, (key, value)|
+            next all if value.nil?
+            all[key] = value_to_param(value)
+            all
+          end
+        when nil
+        else
+          object.respond_to?(:to_param) ? object.to_param : object
+        end
+      end
+
+      # 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
+
+        route_options = options.dup
+        route_options[:provides] = @_provides if @_provides
+        route_options[:accepts]  = @_accepts if @_accepts
+        route_options[:params] = @_params unless @_params.nil? || route_options.include?(:params)
+
+        # Add Sinatra condition to check rack-protection failure.
+        if protect_from_csrf && (report_csrf_failure || allow_disabled_csrf)
+          unless route_options.has_key?(:csrf_protection)
+            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
+
+        method_name = "#{verb} #{path}"
+        unbound_method = generate_method(method_name, &block)
+
+        block_arity = block.arity
+        block = if block_arity == 0
+                  proc{ |request, _| unbound_method.bind(request).call }
+                else
+                  proc{ |request, block_params| unbound_method.bind(request).call(*block_params) }
+                end
+
+        invoke_hook(:route_added, verb, path, block)
+
+        path[0, 0] = "/" if path == "(.:format)?"
+        route = router.add(verb, 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.cache_expires = options.key?(:expires) ? options.delete(:expires) : @_expires
+        route.parent = route_parents ? (route_parents.count == 1 ? route_parents.first : route_parents) : route_parents
+        route.host = options.delete(:host) if options.key?(:host)
+        route.user_agent = options.delete(:agent) if options.key?(:agent)
+        if options.key?(:default_values)
+          defaults = options.delete(:default_values)
+          #route.options[:default_values] = defaults if defaults
+          route.default_values = defaults if defaults
+        end
+        options.delete_if do |option, captures|
+          if route.significant_variable_names.include?(option)
+            route.capture[option] = Array(captures).first
+            true
+          end
+        end
+
+        # Add Sinatra conditions.
+        options.each do |option, _args|
+          option = :provides_format if option == :provides
+          route.respond_to?(option) ? route.send(option, *_args) : send(option, *_args)
+        end
+        conditions, @conditions = @conditions, []
+        route.custom_conditions.concat(conditions)
+
+        invoke_hook(:tennpipes_route_added, route, verb, path, args, options, block)
+
+        block_parameter_length = route.block_parameter_length
+        if block_arity > 0 && block_parameter_length != block_arity
+          fail BlockArityError.new(route.path, block_arity, block_parameter_length)
+        end
+
+        # Add Application defaults.
+        route.before_filters << @filters[:before]
+        route.after_filters << @filters[:after]
+        if @_controller
+          route.use_layout = @layout
+          route.controller = Array(@_controller).join('/')
+        end
+
+        deferred_routes[priority] << [route, block]
+
+        route
+      end
+
+      ##
+      # Returns the final parsed route details (modified to reflect all
+      # Tennpipes 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 = {}
+
+        if options[:params] == true
+          options.delete(:params)
+        elsif options.include?(:params)
+          options[:params] ||= []
+          options[:params] |= Array(options[:with]) if options[:with]
+        end
+
+        # We need check if path is a symbol, if that it's a named route.
+        map = options.delete(:map)
+
+        # path i.e :index or :show
+        if path.kind_of?(Symbol)
+          name = path
+          path = map ? map.dup : (path == :index ? '/' : path.to_s)
+        end
+
+        # Build our controller
+        controller = Array(@_controller).map(&:to_s)
+
+        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 provides
+          options.delete(:provides) if options[:provides].nil?
+        
+          options.delete(:accepts) if options[:accepts].nil?
+
+          if @_use_format || options[:provides]
+            process_path_for_provides(path)
+            # options[:add_match_with] ||= {}
+            # options[:add_match_with][:format] = /[^\.]+/
+          end
+
+          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
+
+          # Now we need to parse our 'parent' params and parent scope.
+          if !absolute_map and parent_params = options.delete(:parent) || @_parent
+            parent_params = (Array(@_parent) + Array(parent_params)).uniq
+            path = process_path_for_parent_params(path, parent_params)
+          end
+
+          # 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
+
+        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
+
+        # Merge in option defaults.
+        options.reverse_merge!(:default_values => @_defaults)
+
+        [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 do |step|
+          step.kind_of?(String) ? step : step.inspect
+        end.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)
+        path << "(.:format)?" unless path[-11, 11] == '(.: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
+        provides_format(*types)
+      end
+
+      def provides_format(*types)
+        mime_types = types.map{ |type| mime_type(CONTENT_TYPE_ALIASES[type] || type) }
+        condition do
+          return provides_format?(types, params[:format].to_sym) if params[:format]
+
+          accepts = request.accept.map(&:to_str)
+          # Per rfc2616-sec14:
+          # Assume */* if no ACCEPT header is given.
+          catch_all = accepts.delete("*/*")
+
+          return provides_any?(accepts) if types.include?(:any)
+
+          accepts = accepts.empty? ? mime_types.slice(0,1) : (accepts & mime_types)
+
+          type = accepts.first && mime_symbol(accepts.first)
+          type ||= catch_all && types.first
+
+          accept_format = CONTENT_TYPE_ALIASES[type] || type
+          if types.include?(accept_format)
+            content_type(accept_format || :html, :charset => 'utf-8')
+          else
+            halt 406 unless catch_all
+            false
+          end
+        end
+      end
+
+      ##
+      # Allows routing by Media type.
+      #
+      # @example
+      #   get "/a", :accepts => [:html, :js]
+      #   # => GET /a CONTENT_TYPE text/html => :html
+      #   # => GET /a CONTENT_TYPE application/javascript => :js
+      #   # => GET /a CONTENT_TYPE application/xml => 406
+      #
+      def accepts(*types)
+        mime_types = types.map{ |type| mime_type(CONTENT_TYPE_ALIASES[type] || type) }
+        condition do
+          halt 406 unless mime_types.include?(request.media_type)
+          content_type(mime_symbol(request.media_type), :charset => 'utf-8')
+        end
+      end
+
+      ##
+      # Implements checking for rack-protection failure flag when
+      # `report_csrf_failure` is enabled.
+      #
+      # @example
+      #   post("/", :csrf_protection => false)
+      #
+      def csrf_protection(enabled)
+        return unless enabled
+        condition do
+          if request.env['protection.csrf.failed']
+            message = settings.protect_from_csrf.kind_of?(Hash) && settings.protect_from_csrf[:message] || 'Forbidden'
+            halt(403, message)
+          end
+        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", false, false)
+      #
+      # @see Tennpipes::Routing::ClassMethods#url
+      #
+      def url(*args)
+        if args.first.is_a?(String)
+          url_path = settings.rebase_url(args.shift)
+          if args.empty?
+            url_path
+          else
+            # Delegate sinatra-style urls to Sinatra. Ex: url("/foo", false, false)
+            # http://www.sinatrarb.com/intro#Generating%20URLs
+            super url_path, *args
+          end
+        else
+          # Delegate to Tennpipes named route URL generation.
+          settings.url(*args)
+        end
+      end
+      alias :url_for :url
+
+      ##
+      # Returns absolute url. Calls Sinatra::Helpers#uri to generate protocol version, hostname and port.
+      #
+      # @example
+      #   absolute_url(:show, :id => 1)  # => http://example.com/show?id=1
+      #   absolute_url(:show, 24)        # => https://example.com/admin/show/24
+      #   absolute_url('/foo/bar')       # => https://example.com/admin/foo/bar
+      #   absolute_url('baz')            # => https://example.com/admin/foo/baz
+      #
+      def absolute_url(*args)
+        url_path = args.shift
+        if url_path.is_a?(String) && !url_path.start_with?('/')
+          url_path = request.env['PATH_INFO'].rpartition('/').first << '/' << url_path
+        end
+        uri url(url_path, *args), true, false
+      end
+
+      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].with_indifferent_access)
+        else
+          path_params << params
+        end
+
+        path_params[-1] = path_params[-1].symbolize_keys
+        @route.path(*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 unless public_dir = settings.public_folder
+        public_dir = File.expand_path(public_dir)
+        path = File.expand_path(public_dir + unescape(path_info))
+        return unless path.start_with?(public_dir)
+        return unless File.file?(path)
+        return path
+      end
+
+      #
+      # Method for deliver static files.
+      #
+      def static!(options = {})
+        if path = static_file?(request.path_info)
+          env['sinatra.static_file'] = path
+          cache_control(*settings.static_cache_control) if settings.static_cache_control?
+          send_file(path, options)
+        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={})
+        return @_content_type unless type
+        params.delete(:charset) if type == :json
+        super(type, params)
+        @_content_type = type
+      end
+
+      private
+
+      def provides_any?(formats)
+        accepted_format = formats.first
+        type = accepted_format ? mime_symbol(accepted_format) : :html
+        content_type(CONTENT_TYPE_ALIASES[type] || type, :charset => 'utf-8')
+      end
+
+      def provides_format?(types, format)
+        if ([:any, format] & types).empty?
+          # Per rfc2616-sec14:
+          # Answer with 406 if accept is given but types to not match any provided type.
+          halt 406 if settings.respond_to?(:treat_format_as_accept) && settings.treat_format_as_accept
+          false
+        else
+          content_type(format || :html, :charset => 'utf-8')
+        end
+      end
+
+      def mime_symbol(media_type)
+        ::Rack::Mime::MIME_TYPES.key(media_type).sub(/\./,'').to_sym
+      end
+
+      def filter!(type, base=settings)
+        base.filters[type].each { |block| instance_eval(&block) }
+      end
+
+      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
+          invoke { handle_exception!(boom) } unless @env['sinatra.error']
+        end
+      end
+
+      def route!(base = settings, pass_block = nil)
+        Thread.current['tennpipes.instance'] = self
+        first_time = true
+
+        routes = base.compiled_router.call(@request) do |route, params|
+          next if route.user_agent && !(route.user_agent =~ @request.user_agent)
+          original_params, parent_layout = @params.dup, @layout
+          returned_pass_block = invoke_route(route, params, first_time)
+          pass_block = returned_pass_block if returned_pass_block
+          first_time = false if first_time
+          @params, @layout = original_params, parent_layout
+        end
+
+        if routes.present?
+          verb = request.request_method
+          candidacies, allows = routes.partition{|route| route.verb == verb }
+          if candidacies.empty?
+            response["Allows"] = allows.map(&:verb).join(", ")
+            halt 405
+          end
+        end
+
+        if base.superclass.respond_to?(:router)
+          route!(base.superclass, pass_block)
+          return
+        end
+
+        route_eval(&pass_block) if pass_block
+        route_missing
+      end
+
+      def invoke_route(route, params, first_time)
+        @_response_buffer = nil
+        @route = request.route_obj = route
+        captured_params = captures_from_params(params)
+
+        @params.merge!(params) if params.kind_of?(Hash)
+        @params.merge!(:captures => captured_params) if !captured_params.empty? && route.path.is_a?(Regexp)
+
+        filter! :before if first_time
+
+        catch(:pass) do
+          begin
+              (route.before_filters - settings.filters[:before]).each{|block| instance_eval(&block) }
+              @layout = route.use_layout if route.use_layout
+              route.custom_conditions.each {|block| pass if block.bind(self).call == false }
+              route_response = route.block[self, captured_params]
+              @_response_buffer = route_response.instance_of?(Array) ? route_response.last : route_response
+              halt(route_response)
+          ensure
+            (route.after_filters - settings.filters[:after]).each {|block| instance_eval(&block) }
+          end
+        end
+      end
+
+      def captures_from_params(params)
+        if params[:captures].instance_of?(Array) && params[:captures].present?
+          params.delete(:captures)
+        else
+          params.values_at(*route.matcher.names).flatten
+        end
+      end
+    end
+  end
+end