diff options
Diffstat (limited to 'actionpack/lib/action_dispatch/routing/mapper.rb')
-rw-r--r-- | actionpack/lib/action_dispatch/routing/mapper.rb | 624 |
1 files changed, 417 insertions, 207 deletions
diff --git a/actionpack/lib/action_dispatch/routing/mapper.rb b/actionpack/lib/action_dispatch/routing/mapper.rb index 7d770dedd0..8f33346a4f 100644 --- a/actionpack/lib/action_dispatch/routing/mapper.rb +++ b/actionpack/lib/action_dispatch/routing/mapper.rb @@ -1,143 +1,261 @@ module ActionDispatch module Routing class Mapper - module Resources - def resource(*resources, &block) - options = resources.last.is_a?(Hash) ? resources.pop : {} - - if resources.length > 1 - raise ArgumentError if block_given? - resources.each { |r| resource(r, options) } - return self + class Constraints + def self.new(app, constraints = []) + if constraints.any? + super(app, constraints) + else + app end + end - resource = resources.pop + def initialize(app, constraints = []) + @app, @constraints = app, constraints + end - if @scope[:scope_level] == :resources - member do - resource(resource, options, &block) + def call(env) + req = Rack::Request.new(env) + + @constraints.each { |constraint| + if constraint.respond_to?(:matches?) && !constraint.matches?(req) + return [ 404, {'X-Cascade' => 'pass'}, [] ] + elsif constraint.respond_to?(:call) && !constraint.call(req) + return [ 404, {'X-Cascade' => 'pass'}, [] ] end - return self - end + } - singular = resource.to_s - plural = singular.pluralize + @app.call(env) + end + end - controller(plural) do - namespace(resource) do - with_scope_level(:resource) do - yield if block_given? + class Mapping + def initialize(set, scope, args) + @set, @scope = set, scope + @path, @options = extract_path_and_options(args) + end - get "", :to => :show, :as => "#{singular}" - post "", :to => :create - put "", :to => :update - delete "", :to => :destroy - get "new", :to => :new, :as => "new_#{singular}" - get "edit", :to => :edit, :as => "edit_#{singular}" - end + def to_route + [ app, conditions, requirements, defaults, @options[:as] ] + end + + private + def extract_path_and_options(args) + options = args.extract_options! + + case + when using_to_shorthand?(args, options) + path, to = options.find { |name, value| name.is_a?(String) } + options.merge!(:to => to).delete(path) if path + when using_match_shorthand?(args, options) + path = args.first + options = { :to => path.gsub("/", "#"), :as => path.gsub("/", "_") } + else + path = args.first end + + [ normalize_path(path), options ] end - self - end + # match "account" => "account#index" + def using_to_shorthand?(args, options) + args.empty? && options.present? + end - def resources(*resources, &block) - options = resources.last.is_a?(Hash) ? resources.pop : {} + # match "account/overview" + def using_match_shorthand?(args, options) + args.present? && options.except(:via).empty? && !args.first.include?(':') + end - if resources.length > 1 - raise ArgumentError if block_given? - resources.each { |r| resources(r, options) } - return self + def normalize_path(path) + path = nil if path == "" + path = "#{@scope[:path]}#{path}" if @scope[:path] + path = Rack::Mount::Utils.normalize_path(path) if path + + raise ArgumentError, "path is required" unless path + + path end - resource = resources.pop - if @scope[:scope_level] == :resources - member do - resources(resource, options, &block) - end - return self + def app + Constraints.new( + to.respond_to?(:call) ? to : Routing::RouteSet::Dispatcher.new(:defaults => defaults), + blocks + ) end - plural = resource.to_s - singular = plural.singularize + def conditions + { :path_info => @path }.merge(constraints).merge(request_method_condition) + end - controller(resource) do - namespace(resource) do - with_scope_level(:resources) do - yield if block_given? + def requirements + @requirements ||= returning(@options[:constraints] || {}) do |requirements| + requirements.reverse_merge!(@scope[:constraints]) if @scope[:constraints] + @options.each { |k, v| requirements[k] = v if v.is_a?(Regexp) } + requirements[:controller] ||= @set.controller_constraints + end + end - member do - get "", :to => :show, :as => "#{singular}" - put "", :to => :update - delete "", :to => :destroy - get "edit", :to => :edit, :as => "edit_#{singular}" - end + def defaults + @defaults ||= if to.respond_to?(:call) + { } + else + defaults = case to + when String + controller, action = to.split('#') + { :controller => controller, :action => action } + when Symbol + { :action => to.to_s }.merge(default_controller ? { :controller => default_controller } : {}) + else + default_controller ? { :controller => default_controller } : {} + end - collection do - get "", :to => :index, :as => "#{plural}" - post "", :to => :create - get "new", :to => :new, :as => "new_#{singular}" - end + if defaults[:controller].blank? && segment_keys.exclude?("controller") + raise ArgumentError, "missing :controller" end + + if defaults[:action].blank? && segment_keys.exclude?("action") + raise ArgumentError, "missing :action" + end + + defaults end end - self - end - def collection - unless @scope[:scope_level] == :resources - raise ArgumentError, "can't use collection outside resources scope" - end + def blocks + if @options[:constraints].present? && !@options[:constraints].is_a?(Hash) + block = @options[:constraints] + else + block = nil + end - with_scope_level(:collection) do - yield + ((@scope[:blocks] || []) + [ block ]).compact end - end - def member - unless @scope[:scope_level] == :resources - raise ArgumentError, "can't use member outside resources scope" + def constraints + @constraints ||= requirements.reject { |k, v| segment_keys.include?(k.to_s) || k == :controller } end - with_scope_level(:member) do - scope(":id") do - yield + def request_method_condition + if via = @options[:via] + via = Array(via).map { |m| m.to_s.upcase } + { :request_method => Regexp.union(*via) } + else + { } end end + + def segment_keys + @segment_keys ||= Rack::Mount::RegexpWithNamedGroups.new( + Rack::Mount::Strexp.compile(@path, requirements, SEPARATORS) + ).names + end + + def to + @options[:to] + end + + def default_controller + @scope[:controller].to_s if @scope[:controller] + end + end + + module Base + def initialize(set) + @set = set + end + + def root(options = {}) + match '/', options.reverse_merge(:as => :root) end def match(*args) + @set.add_route(*Mapping.new(@set, @scope, args).to_route) + self + end + end + + module HttpHelpers + def get(*args, &block) + map_method(:get, *args, &block) + end + + def post(*args, &block) + map_method(:post, *args, &block) + end + + def put(*args, &block) + map_method(:put, *args, &block) + end + + def delete(*args, &block) + map_method(:delete, *args, &block) + end + + def redirect(*args, &block) options = args.last.is_a?(Hash) ? args.pop : {} - args.push(options) - case options.delete(:on) - when :collection - return collection { match(*args) } - when :member - return member { match(*args) } - end + path = args.shift || block + path_proc = path.is_a?(Proc) ? path : proc { |params| path % params } + status = options[:status] || 301 - if @scope[:scope_level] == :resources - raise ArgumentError, "can't define route directly in resources scope" - end + lambda do |env| + req = Rack::Request.new(env) + params = path_proc.call(env["action_dispatch.request.path_parameters"]) + url = req.scheme + '://' + req.host + params - super + [ status, {'Location' => url, 'Content-Type' => 'text/html'}, ['Moved Permanently'] ] + end end private - def with_scope_level(kind) - old, @scope[:scope_level] = @scope[:scope_level], kind - yield - ensure - @scope[:scope_level] = old + def map_method(method, *args, &block) + options = args.extract_options! + options[:via] = method + args.push(options) + match(*args, &block) + self end end module Scoping + def initialize(*args) + @scope = {} + super + end + def scope(*args) - options = args.last.is_a?(Hash) ? args.pop : {} + options = args.extract_options! + + case args.first + when String + options[:path] = args.first + when Symbol + options[:controller] = args.first + end + + if path = options.delete(:path) + path_set = true + path, @scope[:path] = @scope[:path], Rack::Mount::Utils.normalize_path(@scope[:path].to_s + path.to_s) + else + path_set = false + end + + if name_prefix = options.delete(:name_prefix) + name_prefix_set = true + name_prefix, @scope[:name_prefix] = @scope[:name_prefix], (@scope[:name_prefix] ? "#{@scope[:name_prefix]}_#{name_prefix}" : name_prefix) + else + name_prefix_set = false + end + + if controller = options.delete(:controller) + controller_set = true + controller, @scope[:controller] = @scope[:controller], controller + else + controller_set = false + end constraints = options.delete(:constraints) || {} unless constraints.is_a?(Hash) @@ -148,27 +266,15 @@ module ActionDispatch options, @scope[:options] = @scope[:options], (@scope[:options] || {}).merge(options) - path_set = controller_set = false - - case args.first - when String - path_set = true - path = args.first - path, @scope[:path] = @scope[:path], "#{@scope[:path]}#{Rack::Mount::Utils.normalize_path(path)}" - when Symbol - controller_set = true - controller = args.first - controller, @scope[:controller] = @scope[:controller], controller - end - yield self ensure - @scope[:path] = path if path_set - @scope[:controller] = controller if controller_set - @scope[:options] = options - @scope[:blocks] = blocks + @scope[:path] = path if path_set + @scope[:name_prefix] = name_prefix if name_prefix_set + @scope[:controller] = controller if controller_set + @scope[:options] = options + @scope[:blocks] = blocks @scope[:constraints] = constraints end @@ -177,151 +283,255 @@ module ActionDispatch end def namespace(path) - scope(path.to_s) { yield } + scope("/#{path}") { yield } end def constraints(constraints = {}) scope(:constraints => constraints) { yield } end - end - class Constraints - def initialize(app, constraints = []) - @app, @constraints = app, constraints - end + def match(*args) + options = args.extract_options! - def call(env) - req = Rack::Request.new(env) + options = (@scope[:options] || {}).merge(options) - @constraints.each { |constraint| - if constraint.respond_to?(:matches?) && !constraint.matches?(req) - return [417, {}, []] - elsif constraint.respond_to?(:call) && !constraint.call(req) - return [417, {}, []] - end - } + if @scope[:name_prefix] && !options[:as].blank? + options[:as] = "#{@scope[:name_prefix]}_#{options[:as]}" + elsif @scope[:name_prefix] && options[:as] == "" + options[:as] = @scope[:name_prefix].to_s + end - @app.call(env) + args.push(options) + super(*args) end end - def initialize(set) - @set = set - @scope = {} - - extend Scoping - extend Resources - end + module Resources + class Resource #:nodoc: + attr_reader :plural, :singular - def get(*args, &block) - map_method(:get, *args, &block) - end + def initialize(entities, options = {}) + entities = entities.to_s - def post(*args, &block) - map_method(:post, *args, &block) - end + @plural = entities.pluralize + @singular = entities.singularize + end - def put(*args, &block) - map_method(:put, *args, &block) - end + def name + plural + end - def delete(*args, &block) - map_method(:delete, *args, &block) - end + def controller + plural + end - def root(options = {}) - match '/', options.merge(:as => :root) - end + def member_name + singular + end - def match(*args) - options = args.last.is_a?(Hash) ? args.pop : {} + def collection_name + plural + end - if args.length > 1 - args.each { |path| match(path, options) } - return self + def id_segment + ":#{singular}_id" + end end - if args.first.is_a?(Symbol) - return match(args.first.to_s, options.merge(:to => args.first.to_sym)) + class SingletonResource < Resource #:nodoc: + def initialize(entity, options = {}) + super + end + + def name + singular + end end - path = args.first + def resource(*resources, &block) + options = resources.extract_options! - options = (@scope[:options] || {}).merge(options) - conditions, defaults = {}, {} + if resources.length > 1 + raise ArgumentError if block_given? + resources.each { |r| resource(r, options) } + return self + end + + resource = SingletonResource.new(resources.pop) - path = nil if path == "" - path = Rack::Mount::Utils.normalize_path(path) if path - path = "#{@scope[:path]}#{path}" if @scope[:path] + if @scope[:scope_level] == :resources + nested do + resource(resource.name, options, &block) + end + return self + end - raise ArgumentError, "path is required" unless path + scope(:path => "/#{resource.name}", :controller => resource.controller) do + with_scope_level(:resource, resource) do + yield if block_given? - constraints = options[:constraints] || {} - unless constraints.is_a?(Hash) - block, constraints = constraints, {} + get "(.:format)", :to => :show, :as => resource.member_name + post "(.:format)", :to => :create + put "(.:format)", :to => :update + delete "(.:format)", :to => :destroy + get "/new(.:format)", :to => :new, :as => "new_#{resource.singular}" + get "/edit(.:format)", :to => :edit, :as => "edit_#{resource.singular}" + end + end + + self end - blocks = ((@scope[:blocks] || []) + [block]).compact - constraints = (@scope[:constraints] || {}).merge(constraints) - options.each { |k, v| constraints[k] = v if v.is_a?(Regexp) } - conditions[:path_info] = path - requirements = constraints.dup + def resources(*resources, &block) + options = resources.extract_options! + + if resources.length > 1 + raise ArgumentError if block_given? + resources.each { |r| resources(r, options) } + return self + end + + resource = Resource.new(resources.pop) + + if @scope[:scope_level] == :resources + nested do + resources(resource.name, options, &block) + end + return self + end + + scope(:path => "/#{resource.name}", :controller => resource.controller) do + with_scope_level(:resources, resource) do + yield if block_given? + + with_scope_level(:collection) do + get "(.:format)", :to => :index, :as => resource.collection_name + post "(.:format)", :to => :create + + with_exclusive_name_prefix :new do + get "/new(.:format)", :to => :new, :as => resource.singular + end + end + + with_scope_level(:member) do + scope("/:id") do + get "(.:format)", :to => :show, :as => resource.member_name + put "(.:format)", :to => :update + delete "(.:format)", :to => :destroy + + with_exclusive_name_prefix :edit do + get "/edit(.:format)", :to => :edit, :as => resource.singular + end + end + end + end + end - path_regexp = Rack::Mount::Strexp.compile(path, constraints, SEPARATORS) - segment_keys = Rack::Mount::RegexpWithNamedGroups.new(path_regexp).names - constraints.reject! { |k, v| segment_keys.include?(k.to_s) } - conditions.merge!(constraints) + self + end - if via = options[:via] - via = Array(via).map { |m| m.to_s.upcase } - conditions[:request_method] = Regexp.union(*via) + def collection + unless @scope[:scope_level] == :resources + raise ArgumentError, "can't use collection outside resources scope" + end + + with_scope_level(:collection) do + scope(:name_prefix => parent_resource.collection_name, :as => "") do + yield + end + end end - defaults[:controller] = @scope[:controller].to_s if @scope[:controller] + def member + unless @scope[:scope_level] == :resources + raise ArgumentError, "can't use member outside resources scope" + end - if options[:to].respond_to?(:call) - app = options[:to] - defaults.delete(:controller) - defaults.delete(:action) - elsif options[:to].is_a?(String) - defaults[:controller], defaults[:action] = options[:to].split('#') - elsif options[:to].is_a?(Symbol) - defaults[:action] = options[:to].to_s + with_scope_level(:member) do + scope("/:id", :name_prefix => parent_resource.member_name, :as => "") do + yield + end + end end - app ||= Routing::RouteSet::Dispatcher.new(:defaults => defaults) - if app.is_a?(Routing::RouteSet::Dispatcher) - unless defaults.include?(:controller) || segment_keys.include?("controller") - raise ArgumentError, "missing :controller" + def nested + unless @scope[:scope_level] == :resources + raise ArgumentError, "can't use nested outside resources scope" end - unless defaults.include?(:action) || segment_keys.include?("action") - raise ArgumentError, "missing :action" + + with_scope_level(:nested) do + scope("/#{parent_resource.id_segment}", :name_prefix => parent_resource.member_name) do + yield + end end end - app = Constraints.new(app, blocks) if blocks.any? - @set.add_route(app, conditions, requirements, defaults, options[:as]) + def match(*args) + options = args.extract_options! - self - end + if args.length > 1 + args.each { |path| match(path, options) } + return self + end - def redirect(path, options = {}) - status = options[:status] || 301 - lambda { |env| - req = Rack::Request.new(env) - url = req.scheme + '://' + req.host + path - [status, {'Location' => url, 'Content-Type' => 'text/html'}, ['Moved Permanently']] - } - end + if args.first.is_a?(Symbol) + with_exclusive_name_prefix(args.first) do + return match("/#{args.first}(.:format)", options.merge(:to => args.first.to_sym)) + end + end - private - def map_method(method, *args, &block) - options = args.last.is_a?(Hash) ? args.pop : {} - options[:via] = method args.push(options) - match(*args, &block) - self + + case options.delete(:on) + when :collection + return collection { match(*args) } + when :member + return member { match(*args) } + end + + if @scope[:scope_level] == :resources + raise ArgumentError, "can't define route directly in resources scope" + end + + super end + + protected + def parent_resource + @scope[:scope_level_resource] + end + + private + def with_exclusive_name_prefix(prefix) + begin + old_name_prefix = @scope[:name_prefix] + + if !old_name_prefix.blank? + @scope[:name_prefix] = "#{prefix}_#{@scope[:name_prefix]}" + else + @scope[:name_prefix] = prefix.to_s + end + + yield + ensure + @scope[:name_prefix] = old_name_prefix + end + end + + def with_scope_level(kind, resource = parent_resource) + old, @scope[:scope_level] = @scope[:scope_level], kind + old_resource, @scope[:scope_level_resource] = @scope[:scope_level_resource], resource + yield + ensure + @scope[:scope_level] = old + @scope[:scope_level_resource] = old_resource + end + end + + include Base + include HttpHelpers + include Scoping + include Resources end end end |