spec/specs/load_enclosing_resources_spec.rb spec/specs/route_enclosing_names_spec.rb @@ -1,3 +1,21 @@ +* - :polymorphic => true is back: + resources_controller_for :tags + nested_in :taggable, :polymorphic => true + + This will load the enclosing resource (which can be a mapped resource) as + @taggable as well as its default name + + The following syntax is equivalent to the above two lines: + resources_controller_for :tags, :in => '?taggable' + + And you can specify a single wildcard '?' as well as expanding wildcards '*': + resources_controller_for :images, :in => '?', :load_enclosing => false + # this will work for routes like /users/1/images, /forums/2/images, /featured/images + + - test coverage is up + + - moved some of the 'friend' functionality out of Specification, as it smelt bad + * added specs for when you want to find_by_(something other than id) (users, addresses, interests) CHANGELOG @@ -30,7 +30,7 @@ namespace :spec do namespace :rcov do desc "Verify RCov threshold for #{plugin_name}" RCov::VerifyTask.new(:verify => "spec:rcov") do |t| - t.threshold = 94.1 + t.threshold = 98.5 t.index_html = File.join(File.dirname(__FILE__), 'doc/coverage/index.html') end end Rakefile @@ -7,6 +7,7 @@ AccountController#resource_service - .new should call :new on User - .find should call :current_user - .find should call whatever is in resource_specification @find +- .find should raise CantFindSingleton when no custom finder (and no enclosing resource) Routing shortcuts for Admin::Forums should map - resources_path to /admin/forums @@ -35,7 +36,7 @@ Routing shortcuts for Admin::Forums should map - edit_resource_interest_path(5) to /admin/forums/2/interests/5/edit - edit_resource_interest_path(9,5) to /admin/forums/9/interests/5/edit - respond_to?(:edit_resource_interest_path) should == true -- resource_users_path should raise informative NoMethodError +- resource_users_path should raise informative CantMapRoute - enclosing_resource_path should raise informative NoMethodError - any_old_missing_method should raise NoMethodError - respond_to?(:resource_users_path) should == false @@ -272,6 +273,11 @@ Routing shortcuts for ForumPosts (forums/2/posts/1) should map - enclosing_resource_tag_path(9) to /forums/2/tags/9 - enclosing_resource_tag_path(8,9) to /forums/8/tags/9 +ForumPostsController errors +- should raise ResourceMismatch for /posts +- should raise MissingSegment, when route does not contain the resource segment +- should raise NoRecognizedRoute when no route is recognized + resource_service in ForumPostsController - should build new post with @forum foreign key with new - should find @post with find(@post.id) @@ -523,6 +529,7 @@ Requesting /forums/2/owner using POST - should build a new owner - should set the flash notice - should redirect to the new owner +- should render new when post unsuccesful Requesting /forums/2/owner using PUT - should find the owner from forum.owner @@ -743,6 +750,7 @@ ActionView with resources_controller Helper - should forward #resource to controller - should forward #resources to controller - should forward #enclosing_resource to controller +- should forward #enclosing_resource_name to controller - should not forward unknown url helper to controller Helper#form_for_resource (when resource is new record) @@ -754,10 +762,51 @@ Helper#form_for_resource (when resource is existing record) Helper#remote_form_for_resource (when resource is existing record) - should call remote_form_for with update form options +#load_enclosing_resources for resources_controller_for :tags (when route_enclosing_names is [['users', false]]) +- should call load_wildcard once +- should call Specification.new('user', :singleton => false) + +#load_enclosing_resources for resources_controller_for :tags, with :account mapping (when route_enclosing_names is [['account', true]]) +- should call load_wildcard once +- should call load_enclosing_resource_from_specification with account specification +- should not call Specification.new + +#load_enclosing_resources for resources_controller_for :tags (when route_enclosing_names is [['users', false], ['forums', false]]) +- should call load_wildcard twice +- should call Specification.new with ('user', :singleton => false), then ('forum', :singleton => false) + +#load_enclosing_resources for resources_controller_for :tags, :in => ['*', :comment] (when route_enclosing_names is [['comments', false]]) +- should not call load_wildcard +- should not call Specification.new + +#load_enclosing_resources for resources_controller_for :tags, :in => ['*', :comment] (when route_enclosing_names is [['users', false], ['forums', false], ['comments', false]]) +- should call load_wildcard twice +- should call Specification.new with ('user', :singleton => false), then ('forum', :singleton => false) + +#load_enclosing_resources for resources_controller_for :tags, :in => ['*', :comment] (when route_enclosing_names is [['users', false], ['forums', false], ['special', true], ['comments', false]]) +- should call load_wildcard three times +- should call Specification.new with ('user', :singleton => false), ('forum', :singleton => false), then ('special', :singleton => true) + +#load_enclosing_resources for resources_controller_for :tags, :in => ['*', '?commentable', :comment] (when route_enclosing_names is [['users', false], ['comments', false]]) +- should call load_wildcard once with 'commentable' +- should call Specification.new with ('user', :singleton => false) + +#load_enclosing_resources for resources_controller_for :tags, :in => ['*', '?commentable', :comment] (when route_enclosing_names is [['users', false], ['forums', false], ['comments', false]]) +- should call load_wildcard once, then once with 'commentable' +- should call Specification.new with ('user', :singleton => false), ('forum', :singleton => false) + +#load_enclosing_resources for resources_controller_for :tags, :in => ['*', '?commentable', :comment] (when route_enclosing_names is [['users', false], ['forums', false], ['posts', false], ['comments', false]]) +- should call load_wildcard twice, then once with 'commentable' +- should call Specification.new with ('user', :singleton => false), ('forum', :singleton => false), then ('post', :singleton => false) + +#load_enclosing_resources for resources_controller_for :tags, :in => ['user', '*', '?taggable'] (when route_enclosing_names is [['users', false], ['comments', false]]) +- should call load_enclosing_resource_from_specification with user spec, then load_wildcard once with 'taggable' +- should call Specification.new with ('comment', :singleton => false) + A controller's resource_service - may be explicitly set with #resource_service= -ResourcesController#route_resource_names (route_name:tag, :singleton:false) +#route_enclosing_names (route_name:tag, :singleton:false) for named_route: - :tags should be [] - :new_tag should be [] - :edit_tag should be [] @@ -768,6 +817,6 @@ ResourcesController#route_resource_names (route_name:tag, :singleton:false) - :account_info_tags should be [["account", true], ["info", true]] - :new_account_info_tag should be [["account", true], ["info", true]] -Finished in 4.40074 seconds +Finished in 5.243358 seconds -539 examples, 0 failures +566 examples, 0 failures SPECDOC @@ -1,7 +1,5 @@ +* allow option to override namespace name_prefix, or add arbitrary name_prefix + and path_prefix +* enclosing_resource_service for easier creating of custom enclosing resources * end-to-end tests -* re-introduce :polymorphic option (it can be simulated now - but it's a common use-case for many people) -* add '?' wildcard (which can be used to implement the :polymorphic option) -* write some docs on how RC could be improved by having the resources passed to the controller -* rationalise test suite - make a better app * stories -* when :in specified, then don't add the load_enclosing wildcard? TODO @@ -425,6 +425,7 @@ module Ardes#:nodoc: before_filter :load_enclosing_resources unless find_filter(:load_enclosing_resources) write_inheritable_attribute(:specifications, []) + specifications << '*' unless options.delete(:load_enclosing) == false if actions = options.delete(:actions) include actions @@ -436,19 +437,16 @@ module Ardes#:nodoc: name = options[:singleton] ? name.to_s : name.to_s.singularize write_inheritable_attribute :route_name, options[:singleton] ? route : route.singularize - specifications << '*' unless options.delete(:load_enclosing) == false - if nested = options.delete(:in) - nested_in(*nested) - end + nested_in(*options.delete(:in)) if options[:in] - write_inheritable_attribute(:resource_specification, Specification.new(name, options, &block).freeze) + write_inheritable_attribute(:resource_specification, Specification.new(name, options, &block)) end def deprecated_resources_controller_for(options) - options[:class] ||= options[:class_name] && options[:class_name].constantize - options[:source] ||= options[:collection_name] - options[:actions] = options[:actions_include] if options[:actions].nil? - options[:route] ||= options[:route_name] + options[:class_name] and options[:class] ||= options[:class_name].constantize + options[:collection_name] and options[:source] ||= options[:collection_name] + options[:actions_include] and options[:actions] = options[:actions_include] if options[:actions].nil? + options[:route_name] and options[:route] ||= options[:route_name] [:class_name, :collection_name, :actions_include, :route_name].each do |k| if options.key?(k) ActiveSupport::Deprecation.warn("option :#{k} has been deprecated for resources_controller_for and will be removed soon") @@ -477,16 +475,27 @@ module Ardes#:nodoc: options = names.last.is_a?(Hash) ? names.pop : {} raise ArgumentError, "when giving more than one nesting, you may not specify options or a block" if names.length > 1 and (block_given? or options.length > 0) deprecated_nested_in(options) + + # convert :polymorphic option to '?' + if options.delete(:polymorphic) + raise ArgumentError, "when specifying :polymorphic => true, no block or other options may be given" if block_given? or options.length > 0 + names = ["?#{names.first}"] + end + + # ignore first '*' if it has already been specified by :load_enclosing == true + names.shift if specifications == ['*'] && names.first == '*' + names.each do |name| - specifications << (name.to_s == '*' ? '*' : Specification.new(name, options, &block)) + ensure_sane_wildcard if name == '*' + specifications << (name.to_s =~ /^(\*|\?(.*))$/ ? name.to_s : Specification.new(name, options, &block)) end end def deprecated_nested_in(options) - options[:class] ||= options[:class_name] && options[:class_name].constantize - options[:source] ||= options[:collection_name] - options[:key] ||= options[:foreign_key] - [:class_name, :collection_name, :load_enclosing, :polymorphic, :foreign_key].each do |k| + options[:class_name] and options[:class] ||= options[:class_name].constantize + options[:collection_name] and options[:source] ||= options[:collection_name] + options[:foreign_key] and options[:key] ||= options[:foreign_key] + [:class_name, :collection_name, :load_enclosing, :anonymous, :foreign_key].each do |k| if options.key?(k) ActiveSupport::Deprecation.warn("option :#{k} has been deprecated for nested_in and will be removed soon") options.delete(k) @@ -498,6 +507,20 @@ module Ardes#:nodoc: def resource_specification read_inheritable_attribute(:resource_specification) end + + private + # ensure that specifications array is determinate w.r.t route matching + def ensure_sane_wildcard + idx = specifications.length + while (idx -= 1) >= 0 + if specifications[idx] == '*' + raise ArgumentError, "Can only specify one wildcard '*' in between resource specifications" + elsif specifications[idx].is_a?(Specification) + break + end + end + true + end end module InstanceMethods @@ -578,31 +601,28 @@ module Ardes#:nodoc: # returns the name of the immediately enclosing resource def enclosing_resource_name - enclosing_resource && @enclosing_resource_name ||= enclosing_resource.class.name.underscore + enclosing_resource.class.name.underscore end # returns the resource service for the controller - this will be lazilly created - # to a ResourceService, or a SingletonResourceService (if :singelton => true) + # to a ResourceService, or a SingletonResourceService (if :singleton => true) def resource_service @resource_service ||= resource_specification.singleton? ? SingletonResourceService.new(self) : ResourceService.new(self) end # returns the instance resource_specification def resource_specification - @resource_specification ||= returning self.class.resource_specification.dup do |specification| - specification.controller = self - end + self.class.resource_specification end - protected # returns an array of the controller's enclosing (nested in) resources def enclosing_resources @enclosing_resources ||= [] end - # returns an array of the non singleton enclosing resources, this is used for generating routes. - def non_singleton_resources - @non_singleton_resources ||= [] + # returns an array of the collection (non singleton) enclosing resources, this is used for generating routes. + def enclosing_collection_resources + @enclosing_collection_resources ||= [] end private @@ -615,21 +635,8 @@ module Ardes#:nodoc: # returns the all route segments except for the ones corresponding to the current resource and action. # Also remove any route segments from the front which correspond to modules (namespaces) - def enclosing_route_segments - segments = recognized_route.segments.dup - - # shift namespaces from segments, update the name_prefix accordingly for outgoing routes. - namespaces = self.class.name.underscore.split('/') - [controller_name] - - while namespaces.size > 0 - if segments[0].is_a?(ActionController::Routing::DividerSegment) && segments[1].is_a?(ActionController::Routing::StaticSegment) && segments[1].value == namespaces.first - segments.shift; segments.shift # remove the '/' & 'namespace' segments from the front - update_name_prefix("#{namespaces.shift}_") - else - break - end - end - + def enclosing_segments + segments = remove_namespaces_from_segments(recognized_route.segments.dup) if segments.select{|s| s.is_a?(ActionController::Routing::DynamicSegment)}.collect(&:key) == [:controller, :action, :id] logger.warn "WARNING: resources_controller: #{controller_name} has recognized the default route: #{recognized_route}" end @@ -637,16 +644,30 @@ module Ardes#:nodoc: segment = segments.pop return segments if segment.is_a?(::ActionController::Routing::StaticSegment) && segment.value == resource_specification.segment end - ResourcesController.raise_missing_route_segment(self) + ResourcesController.raise_missing_segment(self) + end + + # shift namespaces from segments, update the name_prefix accordingly for outgoing routes. + def remove_namespaces_from_segments(segments) + namespaces = controller_path.sub(controller_name,'').sub(/\/$/,'').split('/') + while namespaces.size > 0 + if segments[0].is_a?(ActionController::Routing::DividerSegment) && segments[1].is_a?(ActionController::Routing::StaticSegment) && segments[1].value == namespaces.first + segments.shift; segments.shift # shift the '/' & 'namespace' segments + update_name_prefix("#{namespaces.shift}_") + else + break + end + end + segments end # Returns an array of pairs [<name>, <singleton?>] e.g. [[users, false], [blog, true], [posts, false]] - # corresponding to the enclosing resources. + # corresponding to the enclosing resource route segments # # This is used to map resources and automatically load resources. - def route_resource_names - @route_resource_names ||= returning(Array.new) do |req| - enclosing_route_segments.each do |segment| + def route_enclosing_names + @route_enclosing_names ||= returning(Array.new) do |req| + enclosing_segments.each do |segment| unless segment.is_optional or segment.is_a?(::ActionController::Routing::DividerSegment) req << [segment.value, true] if segment.is_a?(::ActionController::Routing::StaticSegment) req.last[1] = false if segment.is_a?(::ActionController::Routing::DynamicSegment) @@ -655,33 +676,60 @@ module Ardes#:nodoc: end end - # this is the before_filter that - # * loads all specified and wilcard resources - # * sets the controller instance to the current resource specification + # this is the before_filter that loads all specified and wildcard resources def load_enclosing_resources specifications.each_with_index do |spec, idx| - spec == '*' ? load_wildcards(specifications[idx+1]) : spec.load_into(self) - end - end - - # loads resoources from the route segments, using the segment names to either - # * map to a specification, or - # * create a specification using the segment name - def load_wildcards(to_spec) - return if to_spec == '*' - route_resource_names.slice(enclosing_resources.size..-1).each do |segment, singleton| - return if to_spec && to_spec.segment == segment - if resource_specification_map[segment] - resource_specification_map[segment].load_into(self) - else - name = singleton ? segment : segment.singularize - Specification.new(name, :singleton => singleton).load_into(self) + case spec + when '*' then load_wildcards_from(idx) + when /^\?(.*)/ then load_wildcard($1) + else load_enclosing_resource_from_specification(spec) end end end - # The name prefix is used for forwarding urls. This is different dependning on - # which route the controller was invoked by. The resource spcifications build + # load a wildcard resource by either + # * matching the segment to mapped resource specification, or + # * creating one using the segment name + # Optionally takes a variable name to set the instance variable as (for polymorphic use) + def load_wildcard(as = nil) + route_enclosing_names[enclosing_resources.size] or ResourcesController.raise_resource_mismatch(self) + segment, singleton = *route_enclosing_names[enclosing_resources.size] + spec = resource_specification_map[segment] || Specification.new(singleton ? segment : segment.singularize, :singleton => singleton) + load_enclosing_resource_from_specification(spec, as) + end + + # loads a series of wildcard resources, from the specified specification idx + # + # To do this, we need to figure out where the next specified resource is + # and how many single wildcards are prior to that. What is left over from + # the current route enclosing names will be the number of wildcards we need to load + def load_wildcards_from(start) + specs = specifications.slice(start..-1) + encls = route_enclosing_names.slice(enclosing_resources.size..-1) + + if spec = specs.find {|s| s.is_a?(Specification)} + spec_seg = encls.index([spec.segment, spec.singleton?]) or ResourcesController.raise_resource_mismatch(self) + number_of_wildcards = spec_seg - (specs.index(spec) -1) + else + number_of_wildcards = encls.length - (specs.length - 1) + end + + number_of_wildcards.times { load_wildcard } + end + + def load_enclosing_resource_from_specification(spec, as = nil) + spec.segment == route_enclosing_names[enclosing_resources.size].first or ResourcesController.raise_resource_mismatch(self) + returning spec.find_from(self) do |resource| + update_name_prefix(spec.name_prefix) + enclosing_resources << resource + enclosing_collection_resources << resource unless spec.singleton? + instance_variable_set("@#{spec.name}", resource) + instance_variable_set("@#{as}", resource) if as + end + end + + # The name prefix is used for forwarding urls and will be different depending on + # which route the controller was invoked by. The resource specifications build # up the name prefix as the resources are loaded. def update_name_prefix(name_prefix) @name_prefix = "#{@name_prefix}#{name_prefix}" @@ -703,7 +751,7 @@ module Ardes#:nodoc: end def find(*args, &block) - resource_specification.find ? resource_specification.find_custom : super + resource_specification.find ? resource_specification.find_custom(controller) : super end def respond_to?(method) @@ -718,7 +766,7 @@ module Ardes#:nodoc: class SingletonResourceService < ResourceService def find(*args) if resource_specification.find - resource_specification.find_custom + resource_specification.find_custom(controller) elsif enclosing_resource enclosing_resource.send(resource_specification.source) else @@ -739,11 +787,14 @@ module Ardes#:nodoc: class CantFindSingleton < RuntimeError #:nodoc: end - class MissingRouteSegment < RuntimeError #:nodoc: + class MissingSegment < RuntimeError #:nodoc: end class NoRecognizedRoute < RuntimeError #:nodoc: end + + class ResourceMismatch < RuntimeError #:nodoc: + end class << self def raise_cant_find_singleton(name, klass) #:nodoc: @@ -768,8 +819,8 @@ help. Do this by mapping the route segment to a resource in the controller, or end_str end - def raise_missing_route_segment(controller) #:nodoc: - raise MissingRouteSegment, <<-end_str + def raise_missing_segment(controller) #:nodoc: + raise MissingSegment, <<-end_str Could not recognize segment '#{controller.resource_specification.segment}' in route: #{controller.send(:recognized_route)} @@ -795,7 +846,16 @@ Possible reasons for this: - the test can't figure out which route corresponds to the params, in this case you may need to stub the recognized_route. (rspec example:) @controller.stub!(:recognized_route).and_return(ActionController::Routing::Routes.named_routes[:the_route]) + end_str + end + + def raise_resource_mismatch(controller) #:nodoc: + raise ResourceMismatch, <<-end_str +resources_controller can't match the route to the resource specification + route: #{controller.send(:recognized_route)} + specification: enclosing: [#{controller.specifications.collect{|s| s.is_a?(Specification) ? ":#{s.segment}" : s}.join(', ')}], resource :#{controller.resource_specification.segment} +the successfully loaded enclosing resources are: #{controller.enclosing_resources.join(', ')} end_str end end lib/ardes/resources_controller.rb @@ -127,7 +127,7 @@ Currently: self.class.send :module_eval, <<-end_eval, __FILE__, __LINE__ def #{method}(*args) options = args.last.is_a?(Hash) ? args.pop : {} - args = args.size < #{required_args} ? non_singleton_resources + args : non_singleton_resources - [enclosing_resource] + args + args = args.size < #{required_args} ? enclosing_collection_resources + args : enclosing_collection_resources - [enclosing_resource] + args args = args + [options] if options.size > 0 send :#{route_method}, *args end @@ -140,9 +140,9 @@ Currently: self.class.send :module_eval, <<-end_eval, __FILE__, __LINE__ def #{method}(*args) options = args.last.is_a?(Hash) ? args.pop : {} - #{"args = [resource] + args if non_singleton_resources.size + args.size < #{required_args}" if required_args > 0} + #{"args = [resource] + args if enclosing_collection_resources.size + args.size < #{required_args}" if required_args > 0} args = args + [options] if options.size > 0 - send :#{route_method}, *(non_singleton_resources + args) + send :#{route_method}, *(enclosing_collection_resources + args) end end_eval end lib/ardes/resources_controller/named_route_helper.rb @@ -3,16 +3,17 @@ module Ardes#:nodoc: # This class holds all the info that is required to find a resource, or determine a name prefix, based on a route segment # or segment pair (e.g. /blog or /users/3). # - # You don't need to instatiate this class directly - it is created by ResourcesController::ClassMethods#nested_in, - # ResourcesController#map_resource (and ResourcesController::InstanceMethods#load_wildcards) + # You don't need to instantiate this class directly - it is created by ResourcesController::ClassMethods#nested_in, + # ResourcesController#map_resource (and ResourcesController::InstanceMethods#load_wildcard) + # + # This is primarily a container class. A summary of its behaviour: + # 1. setting defaults for its own variables on initialize, and + # 2. finding an enclosing resource, given a controller object # - # This class is 'friendly' with controller, see load_into class Specification attr_reader :name, :source, :klass, :key, :name_prefix, :segment, :find - attr_accessor :controller - delegate :enclosing_resource, :to => :controller - - # acts as a factory for Specification and SingletonSpecification + + # factory for Specification and SingletonSpecification # # you can call Specification.new 'name', :singleton => true def self.new(name, options = {}, &block) @@ -54,29 +55,21 @@ module Ardes#:nodoc: def singleton? false end - - # This method loads the resource into the passed controller, accessing some of the controller's - # internals to do so. - # - # This is the 'friend' functionality - def load_into(controller) - self.controller = controller - resource = find ? find_custom : find_resource - controller.send(:update_name_prefix, name_prefix) - controller.send(:enclosing_resources) << resource - controller.send(:non_singleton_resources) << resource unless singleton? - controller.send(:instance_variable_set, "@#{name}", resource) - end + # given a controller object, returns the resource according to this specification + def find_from(controller) + find ? find_custom(controller) : find_resource(controller) + end + # finds the resource using the custom :find Proc or symbol - def find_custom + def find_custom(controller) raise "This specification has no custom :find attribute" unless find find.is_a?(Proc) ? controller.instance_eval(&find) : controller.send(find) end - # finds the resource using enclosing resources or resource class - def find_resource - (enclosing_resource ? enclosing_resource.send(source) : klass).find controller.params[key] + # finds the resource on a controller using enclosing resources or resource class + def find_resource(controller) + (controller.enclosing_resource ? controller.enclosing_resource.send(source) : klass).find controller.params[key] end end @@ -100,9 +93,9 @@ module Ardes#:nodoc: end # finds the resource from the enclosing resource. Raise CantFindSingleton if there is no enclosing resource - def find_resource - ResourcesController.raise_cant_find_singleton(name, klass) unless enclosing_resource - enclosing_resource.send(source) + def find_resource(controller) + ResourcesController.raise_cant_find_singleton(name, klass) unless controller.enclosing_resource + controller.enclosing_resource.send(source) end end end lib/ardes/resources_controller/specification.rb @@ -45,6 +45,12 @@ ActionController::Routing::Routes.draw do |map| map.resources :tags + # the following routes are for testing errors + map.resources :posts, :controller => 'forum_posts' + map.resources :foos do |foo| + foo.resources :bars, :controller => 'forum_posts' + end + map.connect ':controller/:action/:id.:format' map.connect ':controller/:action/:id' end @@ -248,8 +254,9 @@ class ForumPostsController < PostsController # for testing filter load order before_filter {|controller| controller.filter_trace ||= []; controller.filter_trace << :forum_posts} - # test inherited resources_controller_for use + # test override resources_controller_for use resources_controller_for :posts + # example of providing a custom finder for the nesting resource nested_in :forum do Forum.find(params[:forum_id]) @@ -257,14 +264,13 @@ class ForumPostsController < PostsController end class CommentsController < ApplicationController - resources_controller_for :comments, :in => [:forum, :post] + resources_controller_for :comments, :in => [:forum, :post], :load_enclosing => false end class InterestsController < ApplicationController resources_controller_for :interests - before_filter :set_interested_in + nested_in :interested_in, :polymorphic => true - def set_interested_in - @interested_in = enclosing_resource - end + # the above two lines are the same as: + # resources_controller_for :interests, :in => '?interested_in' end \ No newline at end of file spec/app.rb @@ -26,7 +26,7 @@ describe "Routing shortcuts for Account should map" do it "resource_info_tags_path to /account/info/tags" do controller.resource_info_tags_path.should == "/account/info/tags" - end + end end describe AccountController, "#resource_service" do @@ -52,7 +52,12 @@ describe AccountController, "#resource_service" do it ".find should call whatever is in resource_specification @find" do @controller.should_receive(:lambda_called).once.and_return(@current_user) - @controller.send(:resource_specification).instance_variable_set "@find", lambda { lambda_called } + @controller.send(:resource_specification).stub!(:find).and_return(lambda { lambda_called }) @resource_service.find end + + it ".find should raise CantFindSingleton when no custom finder (and no enclosing resource)" do + @controller.send(:resource_specification).stub!(:find).and_return nil + lambda{ @resource_service.find }.should raise_error(Ardes::ResourcesController::CantFindSingleton) + end end \ No newline at end of file spec/controllers/account_controller_spec.rb @@ -115,7 +115,7 @@ describe "Routing shortcuts for Admin::Forums should map" do controller.should respond_to(:edit_resource_interest_path) end - it "resource_users_path should raise informative NoMethodError" do + it "resource_users_path should raise informative CantMapRoute" do lambda{ controller.resource_users_path }.should raise_error(Ardes::ResourcesController::CantMapRoute, <<-end_str Tried to map :resource_users_path to :admin_forum_users_path, which doesn't exist. You may not have defined the route in config/routes.rb. spec/controllers/admin_forums_controller_spec.rb @@ -94,6 +94,23 @@ describe "Routing shortcuts for ForumPosts (forums/2/posts/1) should map" do end end +describe ForumPostsController, " errors" do + controller_name :forum_posts + + it "should raise ResourceMismatch for /posts" do + lambda{ get :index }.should raise_error(Ardes::ResourcesController::ResourceMismatch) + end + + it "should raise MissingSegment, when route does not contain the resource segment" do + lambda{ get :index, :foo_id => 1}.should raise_error(Ardes::ResourcesController::MissingSegment) + end + + it "should raise NoRecognizedRoute when no route is recognized" do + ::ActionController::Routing::Routes.stub!(:routes_for_controller_and_action).and_return([]) + lambda{ get :index }.should raise_error(Ardes::ResourcesController::NoRecognizedRoute) + end +end + describe "resource_service in ForumPostsController" do controller_name :forum_posts spec/controllers/forum_posts_controller_spec.rb @@ -211,6 +211,12 @@ describe "Requesting /forums/2/owner using POST" do response.should be_redirect response.redirect_url.should == "http://test.host/forums/2/owner" end + + it "should render new when post unsuccesful" do + @owner.stub!(:save).and_return(false) + do_post + response.should render_template('new') + end end spec/controllers/owner_controller_spec.rb @@ -24,6 +24,7 @@ describe "ActionView with resources_controller Helper" do it_should_forward_to_controller :resource it_should_forward_to_controller :resources it_should_forward_to_controller :enclosing_resource + it_should_forward_to_controller :enclosing_resource_name it 'should not forward unknown url helper to controller' do @controller.stub!(:resource_named_route_helper_method?).and_return(false) spec/specs/action_view_helper_spec.rb spec/specs/resources_controller_spec.rb e8fc191094b3a333c9b5fd501cb7b2e81078a2bc ian ian@845bbffb-5c18-0410-91b3-f25c072b94c1 http://github.com/ianwhite/resources_controller/commit/44316d0a6734bb3953abf1349f401d6f6bce51df 44316d0a6734bb3953abf1349f401d6f6bce51df 2007-10-24T08:14:37-07:00 2007-10-24T08:14:37-07:00 resources_controller: - :polymorphic => true is back: resources_controller_for :tags nested_in :taggable, :polymorphic => true This will load the enclosing resource (which can be a mapped resource) as @taggable as well as its default name The following syntax is equivalent to the above two lines: resources_controller_for :tags, :in => '?taggable' And you can specify a single wildcard '?' as well as expanding wildcards '*': resources_controller_for :images, :in => '?', :load_enclosing => false # this will work for routes like /users/1/images, /forums/2/images, /featured/images - test coverage is up - moved some of the 'friend' functionality out of Specification, as it smelt bad git-svn-id: https://svn.ardes.com/rails_plugins/resources_controller@464 845bbffb-5c18-0410-91b3-f25c072b94c1 79858f0841e8d70e62e87f6f3919418f6a77e49b ian ian@845bbffb-5c18-0410-91b3-f25c072b94c1