1127 lines
39 KiB
Ruby
1127 lines
39 KiB
Ruby
require 'http_router' unless defined?(HttpRouter)
|
|
require 'padrino-core/support_lite' unless defined?(SupportLite)
|
|
|
|
##
|
|
# Adds to Sinatra +controller+ informations
|
|
#
|
|
class Sinatra::Request
|
|
attr_accessor :route_obj
|
|
|
|
def controller
|
|
route_obj && route_obj.controller
|
|
end
|
|
def action
|
|
route_obj && route_obj.action
|
|
end
|
|
end
|
|
|
|
##
|
|
# This patches Sinatra to accept UTF-8 urls on JRuby 1.7.6
|
|
#
|
|
if RUBY_ENGINE == 'jruby' && defined?(JRUBY_VERSION) && JRUBY_VERSION > '1.7.4'
|
|
class Sinatra::Base
|
|
class << self
|
|
alias_method :old_generate_method, :generate_method
|
|
def generate_method(method_name, &block)
|
|
old_generate_method(method_name.to_sym, &block)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
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 match_data = env['router.request'].extra_env['router.regex_match']
|
|
params_list = match_data.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 }
|
|
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
|
|
|
|
class Route
|
|
VALID_HTTP_VERBS.replace %w[GET POST PUT PATCH DELETE HEAD OPTIONS LINK UNLINK]
|
|
|
|
attr_accessor :use_layout, :controller, :action, :cache, :cache_key, :cache_expires, :parent
|
|
|
|
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
|
|
|
|
def significant_variable_names
|
|
@significant_variable_names ||= if @original_path.is_a?(String)
|
|
@original_path.scan(/(^|[^\\])[:\*]([a-zA-Z0-9_]+)/).map{|p| p.last.to_sym}
|
|
elsif @original_path.is_a?(Regexp) and @original_path.respond_to?(:named_captures)
|
|
@original_path.named_captures.keys.map(&:to_sym)
|
|
else
|
|
[]
|
|
end
|
|
end
|
|
|
|
def to(dest = nil, &dest_block)
|
|
@dest = dest || dest_block || raise("you didn't specify a destination")
|
|
|
|
@router.current_order ||= 0
|
|
@order = @router.current_order
|
|
@router.current_order += 1
|
|
|
|
if @dest.respond_to?(:url_mount=)
|
|
urlmount = UrlMount.new(@path_for_generation, @default_values || {}) # TODO url mount should accept nil here.
|
|
urlmount.url_mount = @router.url_mount if @router.url_mount
|
|
@dest.url_mount = urlmount
|
|
end
|
|
self
|
|
end
|
|
|
|
attr_accessor :order
|
|
|
|
end
|
|
|
|
attr_accessor :current_order
|
|
|
|
def sort!
|
|
@routes.sort!{ |a, b| a.order <=> b.order }
|
|
end
|
|
|
|
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 = path.split(/\//).map{|part| Rack::Utils.unescape(part) }
|
|
@path.shift if @path.first == ''
|
|
@path.push('') if path[-1] == ?/
|
|
@extra_env = {}
|
|
@params = []
|
|
@acceptable_methods = Set.new
|
|
end
|
|
end
|
|
|
|
class Node::Path
|
|
def to_code
|
|
path_ivar = inject_root_ivar(self)
|
|
"#{"if !callback && request.path.size == 1 && request.path.first == '' && (request.rack_request.head? || request.rack_request.get?) && request.rack_request.path_info[-1] == ?/
|
|
catch(:pass) do
|
|
response = ::Rack::Response.new
|
|
response.redirect(request.rack_request.path_info[0, request.rack_request.path_info.size - 1], 302)
|
|
return response.finish
|
|
end
|
|
end" if router.redirect_trailing_slash?}
|
|
|
|
#{"if request.#{router.ignore_trailing_slash? ? 'path_finished?' : 'path.empty?'}" unless route.match_partially}
|
|
catch(:pass) do
|
|
if callback
|
|
request.called = true
|
|
callback.call(Response.new(request, #{path_ivar}))
|
|
else
|
|
env = request.rack_request.dup.env
|
|
env['router.request'] = request
|
|
env['router.params'] ||= {}
|
|
#{"env['router.params'].merge!(Hash[#{param_names.inspect}.zip(request.params)])" if dynamic?}
|
|
env['router.params'] = env['router.params'].with_indifferent_access
|
|
@router.rewrite#{"_partial" if route.match_partially}_path_info(env, request)
|
|
response = @router.process_destination_path(#{path_ivar}, env)
|
|
return response unless router.pass_on_response(response)
|
|
end
|
|
end
|
|
#{"end" unless route.match_partially}"
|
|
end
|
|
end
|
|
end
|
|
|
|
module Padrino
|
|
class Filter
|
|
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.name == arg or request.route_obj.name == [@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
|
|
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 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 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?
|
|
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 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.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
|
|
|
|
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
|
|
router.sort!
|
|
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(Rack::MockRequest.env_for(path))
|
|
responses = responses[0] if responses[0].is_a?(Array)
|
|
[responses[0].path.route.name, 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[0, 2].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.symbolize_keys)
|
|
end
|
|
url =
|
|
if params_array.empty?
|
|
compiled_router.path(name, params)
|
|
else
|
|
compiled_router.path(name, *(params_array << params))
|
|
end
|
|
rebase_url(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)
|
|
conditions = @conditions.dup
|
|
route('GET', path, *args, &block)
|
|
|
|
@conditions = conditions
|
|
route('HEAD', path, *args, &block)
|
|
end
|
|
|
|
def rebase_url(url)
|
|
if url.start_with?('/')
|
|
new_url = ''
|
|
new_url << conform_uri(uri_root) if defined?(uri_root)
|
|
new_url << conform_uri(ENV['RACK_BASE_URI']) if ENV['RACK_BASE_URI']
|
|
new_url << url
|
|
else
|
|
url.blank? ? '/' : url
|
|
end
|
|
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
|
|
# 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
|
|
|
|
# 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
|
|
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 << @filters[:before]
|
|
route.after_filters << @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)
|
|
route_options = {}
|
|
|
|
# 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?
|
|
|
|
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
|
|
|
|
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) || @_parents
|
|
parent_params = (Array(@_parents) + 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(&: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) }.compact
|
|
url_format = params[:format].to_sym if params[:format]
|
|
accepts = request.accept.map(&:to_str)
|
|
accepts.clear if accepts == ["*/*"]
|
|
|
|
# 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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
if @_content_type != :json
|
|
content_type(@_content_type, :charset => 'utf-8')
|
|
else
|
|
content_type(@_content_type)
|
|
end
|
|
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
|
|
|
|
##
|
|
# 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 Padrino::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 Padrino 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 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!
|
|
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['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
|
|
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
|
|
end
|
|
end
|