spec/public/controller/resource_spec.rb @@ -430,16 +430,8 @@ class Merb::AbstractController # ==== # TODO: Update this documentation def url(name, *args) - unless Symbol === name - args.unshift(name) - name = :default - end - - unless route = Merb::Router.named_routes[name] - raise Merb::Router::GenerationError, "Named route not found: #{name}" - end - - route.generate(args, params) + args << params + Merb::Router.url(name, *args) end alias_method :relative_url, :url @@ -472,6 +464,39 @@ class Merb::AbstractController (host || request.host) + url(name, rparams) end + + # Generates a URL for a single or nested resource. + # + # ==== Parameters + # resources<Symbol,Object>:: The resources for which the URL + # should be generated. These resources should be specified + # in the router.rb file using #resources and #resource. + # + # options<Hash>:: Any extra parameters that are needed to + # generate the URL. + # + # ==== Returns + # String:: The generated URL. + # + # ==== Examples + # + # Merb::Router.prepare do + # resources :users do + # resources :comments + # end + # end + # + # resource(:users) # => /users + # resource(@user) # => /users/10 + # resource(@user, :comments) # => /users/10/comments + # resource(@user, @comment) # => /users/10/comments/15 + # resource(:users, :new) # => /users/new + # resource(:@user, :edit) # => /users/10/edit + # + def resource(*args) + args << params + Merb::Router.resource(*args) + end # Calls the capture method for the selected template engine. # lib/merb-core/controller/abstract_controller.rb @@ -21,10 +21,11 @@ module Merb # # Compilation is synchronized by mutex. class Router - @routes = [] - @named_routes = {} - @compiler_mutex = Mutex.new - @root_behavior = Behavior.new.defaults(:action => "index") + @routes = [] + @named_routes = {} + @resource_routes = {} + @compiler_mutex = Mutex.new + @root_behavior = Behavior.new.defaults(:action => "index") # Raised when route lookup fails. class RouteNotFound < StandardError; end; @@ -35,7 +36,7 @@ module Merb class << self # @private - attr_accessor :routes, :named_routes, :root_behavior + attr_accessor :routes, :named_routes, :resource_routes, :root_behavior # Creates a route building context and evaluates the block in it. A # copy of +root_behavior+ (and instance of Behavior) is copied as @@ -111,6 +112,82 @@ module Merb end alias_method :match, :match_before_compilation + + # Generates a URL from the params + # + # ==== Parameters + # name<Symbol>:: + # The name of the route to generate + # + # anonymous_params<Object>:: + # An array of anonymous parameters to generate the route + # with. These parameters are assigned to the route parameters + # in the order that they are passed. + # + # params<Hash>:: + # Named parameters to generate the route with. + # + # defaults<Hash>:: + # A hash of default parameters to generate the route with. + # This is usually the request parameters. If there are any + # required params that are missing to generate the route, + # they are pulled from this hash. + # ==== Returns + # String:: The generated URL + # --- + # @private + def url(name, *args) + unless name.is_a?(Symbol) + args.unshift(name) + name = :default + end + + unless route = Merb::Router.named_routes[name] + raise Merb::Router::GenerationError, "Named route not found: #{name}" + end + + defaults = args.pop + + route.generate(args, defaults) + end + + # Generates a URL from the resource(s) + # + # ==== Parameters + # resources<Symbol,Object>:: + # The identifiers for the resource route to generate. These + # can either be symbols or objects. Symbols denote resource + # collection routes and objects denote the members. + # + # params<Hash>:: + # Any extra parameters needed to generate the route. + # ==== Returns + # String:: The generated URL + # --- + # @private + def resource(*args) + defaults = args.pop + options = extract_options_from_args!(args) || {} + key = [] + params = [] + + args.each do |arg| + if arg.is_a?(Symbol) || arg.is_a?(String) + key << arg.to_s + else + key << arg.class.to_s + params << arg + end + end + + params << options + + unless route = Merb::Router.resource_routes[key] + raise Merb::Router::GenerationError, "Resource route not found: #{args.inspect}" + end + + route.generate(params, defaults) + end private lib/merb-core/dispatch/router.rb @@ -32,8 +32,9 @@ module Merb # explicitly define the Behavior methods to proxy here (specifically namespace) # Rake's methods take precedence. %w( - match to with register default defaults options option namespace identify - default_routes defer_to name full_name fixatable redirect capture + match to with register default defaults options option namespace + identify default_routes defer_to name full_name fixatable redirect + capture resources resource ).each do |method| class_eval %{ def #{method}(*args, &block) @@ -335,6 +336,7 @@ module Merb # option keys could be nil opts[:controller_prefix] = name unless opts.has_key?(:controller_prefix) opts[:name_prefix] = name unless opts.has_key?(:name_prefix) + opts[:resource_prefix] = opts[:name_prefix] unless opts.has_key?(:resource_prefix) behavior = self behavior = behavior.match("/#{path}") unless path.nil? || path.empty? lib/merb-core/dispatch/router/behavior.rb @@ -65,47 +65,64 @@ module Merb # end #--- # @public - def resources(name, options = {}, &block) - singular = name.to_s.singularize - keys = options.delete(:keys) || [:id] - params = { :controller => options.delete(:controller) || name.to_s } + def resources(name, *args, &block) + name = name.to_s + options = extract_options_from_args!(args) || {} + singular = Extlib::Inflection.singularize(name) + klass = args.first ? args.first.to_s : Extlib::Inflection.classify(singular) + keys = [ options.delete(:keys) || :id ].flatten + params = { :controller => options.delete(:controller) || name } collection = options.delete(:collection) || {} member = { :edit => :get, :delete => :get }.merge(options.delete(:member) || {}) # Try pulling :namespace out of options for backwards compatibility options[:name_prefix] ||= nil # Don't use a name_prefix if not needed + options[:resource_prefix] ||= nil # Don't use a resource_prefix if not needed options[:controller_prefix] ||= options.delete(:namespace) self.namespace(name, options).to(params) do |resource| root_keys = keys.map { |k| ":#{k}" }.join("/") + # => index - resource.match("(/index)(.:format)", :method => :get).to(:action => "index").name(name) + resource.match("(/index)(.:format)", :method => :get).to(:action => "index"). + name(name).register_resource(name) + # => create resource.match("(.:format)", :method => :post).to(:action => "create") + # => new - resource.match("/new(.:format)", :method => :get).to(:action => "new").name(:new, singular) + resource.match("/new(.:format)", :method => :get).to(:action => "new"). + name("new", singular).register_resource(name, "new") # => user defined collection routes collection.each_pair do |action, method| - resource.match("/#{action}(.:format)", :method => method).to(:action => "#{action}").name(action, name) + action = action.to_s + resource.match("/#{action}(.:format)", :method => method).to(:action => "#{action}"). + name(action, name).register_resource(name, action) end # => show - resource.match("/#{root_keys}(.:format)", :method => :get).to(:action => "show").name(singular) + resource.match("/#{root_keys}(.:format)", :method => :get).to(:action => "show"). + name(singular).register_resource(klass) # => user defined member routes member.each_pair do |action, method| - resource.match("/#{root_keys}/#{action}(.:format)", :method => method).to(:action => "#{action}").name(action, singular) + action = action.to_s + resource.match("/#{root_keys}/#{action}(.:format)", :method => method). + to(:action => "#{action}").name(action, singular).register_resource(klass, action) end # => update - resource.match("/#{root_keys}(.:format)", :method => :put).to(:action => "update") + resource.match("/#{root_keys}(.:format)", :method => :put). + to(:action => "update") + # => destroy - resource.match("/#{root_keys}(.:format)", :method => :delete).to(:action => "destroy") + resource.match("/#{root_keys}(.:format)", :method => :delete). + to(:action => "destroy") if block_given? nested_keys = keys.map { |k| k.to_s == "id" ? ":#{singular}_id" : ":#{k}" }.join("/") - resource.options(:name_prefix => singular).match("/#{nested_keys}", &block) + resource.options(:name_prefix => singular, :resource_prefix => klass).match("/#{nested_keys}", &block) end end @@ -164,24 +181,35 @@ module Merb # end # --- # @public - def resource(name, options = {}, &block) - params = { :controller => options.delete(:controller) || name.to_s.pluralize } + def resource(name, *args, &block) + name = name.to_s + options = extract_options_from_args!(args) || {} + params = { :controller => options.delete(:controller) || name.pluralize } options[:name_prefix] ||= nil # Don't use a name_prefix if not needed + options[:resource_prefix] ||= nil # Don't use a resource_prefix if not needed options[:controller_prefix] ||= options.delete(:namespace) self.namespace(name, options).to(params) do |resource| - resource.match("(.:format)", :method => :get ).to(:action => "show" ).name(name) + resource.match("(.:format)", :method => :get ).to(:action => "show" ).name(name).register_resource(name) resource.match("(.:format)", :method => :post ).to(:action => "create" ) resource.match("(.:format)", :method => :put ).to(:action => "update" ) resource.match("(.:format)", :method => :delete).to(:action => "destroy") - resource.match("/new(.:format)", :method => :get ).to(:action => "new" ).name(:new, name) - resource.match("/edit(.:format)", :method => :get ).to(:action => "edit" ).name(:edit, name) - resource.match("/delete(.:format)", :method => :get ).to(:action => "delete" ).name(:delete, name) + resource.match("/new(.:format)", :method => :get ).to(:action => "new" ).name(:new, name).register_resource(name, "new") + resource.match("/edit(.:format)", :method => :get ).to(:action => "edit" ).name(:edit, name).register_resource(name, "edit") + resource.match("/delete(.:format)", :method => :get ).to(:action => "delete" ).name(:delete, name).register_resource(name, "delete") - resource.options(:name_prefix => name, &block) if block_given? + resource.options(:name_prefix => name, :resource_prefix => name, &block) if block_given? end end + + protected + + def register_resource(*key) + key = [@options[:resource_prefix], key].flatten.compact + @route.resource = key + self + end end lib/merb-core/dispatch/router/resources.rb @@ -61,6 +61,13 @@ module Merb self end + # Sets the route as a resource route with the given key as the + # lookup key. + def resource=(key) + Router.resource_routes[key] = self + key + end + def name=(name) @name = name.to_sym Router.named_routes[@name] = self @@ -75,10 +82,13 @@ module Merb # Support for anonymous params unless args.empty? - raise GenerationError, "The route has #{@variables.length} variables: #{@variables.inspect}" if args.length > @variables.length + # First, let's determine which variables are missing + variables = @variables - params.keys + + raise GenerationError, "The route has #{@variables.length} variables: #{@variables.inspect}" if args.length > variables.length args.each_with_index do |param, i| - params[@variables[i]] ||= param + params[variables[i]] ||= param end end lib/merb-core/dispatch/router/route.rb @@ -12,13 +12,21 @@ module Merb # ==== Returns # String:: The generated URL. def url(*args) - name = args.first.is_a?(Symbol) ? args.shift : :default - - unless route = Merb::Router.named_routes[name] - raise Merb::Router::GenerationError, "Named route not found: #{name}" - end - - route.generate(args, @request_params || {}) + args << @request_params || {} + Merb::Router.url(*args) + end + + # Mimics the resource method available to controllers + # + # ==== Paramaters + # resources<Object>:: The resources to generate URLs from + # params<Hash>:: Any extra parameters that are required. + # + # ==== Returns + # String:: The generated URL. + def resource(*args) + args << @request_params || {} + Merb::Router.resource(*args) end # ==== Parameters lib/merb-core/test/helpers/route_helper.rb @@ -31,7 +31,14 @@ describe "When generating URLs," do end it "should give precedence to the params hash" do - url(:ordered, "one", "two", "three", :second => "deux").should == "/one/deux/three" + url(:ordered, "one", "two", :first => "un").should == "/un/one/two" + url(:ordered, "one", :first => "un", :second => "deux").should == "/un/deux/one" + url(:ordered, "one", :first => "un", :third => "trois").should == "/un/one/trois" + url(:ordered, "one", "two", :second => "deux").should == "/one/deux/two" + end + + it "should raise an exception when there are two many anonymous params after the named params were placed" do + lambda { url(:ordered, "one", "two", :first => "un", :second => "deux") }.should raise_error(Merb::Router::GenerationError) end end spec/public/router/generation/params_spec.rb 21db301aa5d4277dd19d9b1b1a30e469de012298 Carl Lerche carllerche@mac.com http://github.com/wycats/merb-core/commit/36e76f35b62860bec3f63c30177115778586b618 36e76f35b62860bec3f63c30177115778586b618 2008-09-29T11:10:32-07:00 2008-09-29T11:10:32-07:00 Added the #resource controller helper for URL generation. The #resource controller helper is a convenience method for generating resource routes. It tracks the resource declarations in the router file and is able to generate URLs from only models passed as arguments. 7dce5b2c882ff9b16813f6f8a1db5465220eefe6 Carl Lerche carllerche@mac.com