From 605063b974d4e10c601585bb178e9aba7b6092c5 Mon Sep 17 00:00:00 2001 From: Logan Raarup Date: Tue, 11 May 2010 19:30:28 +0800 Subject: [PATCH 1/5] Make sure conditions on associations are pluralized --- lib/cancan/ability.rb | 4 ++-- lib/cancan/active_record_additions.rb | 2 +- lib/cancan/can_definition.rb | 16 +++++++++++++++- spec/cancan/active_record_additions_spec.rb | 4 ++-- spec/cancan/can_definition_spec.rb | 6 ++++++ 5 files changed, 26 insertions(+), 6 deletions(-) diff --git a/lib/cancan/ability.rb b/lib/cancan/ability.rb index 535663e..b20c0f1 100644 --- a/lib/cancan/ability.rb +++ b/lib/cancan/ability.rb @@ -190,11 +190,11 @@ module CanCan # If the ability is not defined then false is returned so be sure to take that into consideration. # If the ability is defined using a block then this will raise an exception since a hash of conditions cannot be # determined from that. - def conditions(action, subject) + def conditions(action, subject, options = {}) can_definition = matching_can_definition(action, subject) if can_definition raise Error, "Cannot determine ability conditions from block for #{action.inspect} #{subject.inspect}" if can_definition.block - can_definition.conditions || {} + can_definition.conditions(options) || {} else false end diff --git a/lib/cancan/active_record_additions.rb b/lib/cancan/active_record_additions.rb index 2afa33d..e5bda3b 100644 --- a/lib/cancan/active_record_additions.rb +++ b/lib/cancan/active_record_additions.rb @@ -20,7 +20,7 @@ module CanCan # Here only the articles which the user can update are returned. This # internally uses Ability#conditions method, see that for more information. def accessible_by(ability, action = :read) - conditions = ability.conditions(action, self) || {:id => nil} + conditions = ability.conditions(action, self, :tableize => true) || {:id => nil} joins = ability.association_joins(action, self) if respond_to? :where where(conditions).joins(joins) diff --git a/lib/cancan/can_definition.rb b/lib/cancan/can_definition.rb index 9b3b945..c1dce1e 100644 --- a/lib/cancan/can_definition.rb +++ b/lib/cancan/can_definition.rb @@ -1,7 +1,8 @@ module CanCan # This class is used internally and should only be called through Ability. class CanDefinition # :nodoc: - attr_reader :conditions, :block + include ActiveSupport::Inflector + attr_reader :block def initialize(base_behavior, action, subject, conditions, block) @base_behavior = base_behavior @@ -25,6 +26,19 @@ module CanCan result = can_without_base_behavior?(action, subject, extra_args) @base_behavior ? result : !result end + + def conditions(options = {}) + if options[:tableize] and @conditions.kind_of? Hash + @conditions.inject({}) do |tableized_conditions, (name, value)| + name = tableize(name).to_sym if value.kind_of? Hash + + tableized_conditions[name] = value + tableized_conditions + end + else + @conditions + end + end def association_joins(conditions = @conditions) joins = [] diff --git a/spec/cancan/active_record_additions_spec.rb b/spec/cancan/active_record_additions_spec.rb index 640f44a..41aaf3c 100644 --- a/spec/cancan/active_record_additions_spec.rb +++ b/spec/cancan/active_record_additions_spec.rb @@ -16,13 +16,13 @@ describe CanCan::ActiveRecordAdditions do it "should call where with matching ability conditions" do @ability.can :read, @model_class, :foo => {:bar => 1} - stub(@model_class).where(:foo => { :bar => 1 }).stub!.joins([:foo]) { :found_records } + stub(@model_class).where(:foos => { :bar => 1 }).stub!.joins([:foo]) { :found_records } @model_class.accessible_by(@ability, :read).should == :found_records end it "should default to :read ability and use scoped when where isn't available" do @ability.can :read, @model_class, :foo => {:bar => 1} - stub(@model_class).scoped(:conditions => {:foo => {:bar => 1}}, :joins => [:foo]) { :found_records } + stub(@model_class).scoped(:conditions => {:foos => {:bar => 1}}, :joins => [:foo]) { :found_records } @model_class.accessible_by(@ability).should == :found_records end end diff --git a/spec/cancan/can_definition_spec.rb b/spec/cancan/can_definition_spec.rb index 697dc74..c9f7633 100644 --- a/spec/cancan/can_definition_spec.rb +++ b/spec/cancan/can_definition_spec.rb @@ -30,4 +30,10 @@ describe CanCan::CanDefinition do @conditions[:foo] = {:bar => {1 => 2}} @can.association_joins.should == [{:foo => [:bar]}] end + + it "should return table names in conditions for association joins" do + @conditions[:foo] = {:bar => 1} + @conditions[:test] = 1 + @can.conditions(:tableize => true).should == { :foos => { :bar => 1}, :test => 1 } + end end From 7543eedd6aa35ef14e66b5614eb38e015f4b4091 Mon Sep 17 00:00:00 2001 From: John Allison Date: Thu, 20 May 2010 17:06:10 -0700 Subject: [PATCH 2/5] fixing issue when using accessible_by with nil can conditions - closes #66 --- CHANGELOG.rdoc | 4 ++++ lib/cancan/can_definition.rb | 2 +- spec/cancan/can_definition_spec.rb | 5 +++++ 3 files changed, 10 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.rdoc b/CHANGELOG.rdoc index 6e1738c..65dcf67 100644 --- a/CHANGELOG.rdoc +++ b/CHANGELOG.rdoc @@ -1,3 +1,7 @@ +* Fix issue when using accessible_by with nil can conditions (thanks jrallison) - see issue #66 + +* Pluralize table name for belongs_to associations in can conditions hash (thanks logandk) - see issue #62 + * Support has_many association or arrays in can conditions hash * Adding joins clause to accessible_by when conditions are across associations diff --git a/lib/cancan/can_definition.rb b/lib/cancan/can_definition.rb index c1dce1e..fc1cb0b 100644 --- a/lib/cancan/can_definition.rb +++ b/lib/cancan/can_definition.rb @@ -8,7 +8,7 @@ module CanCan @base_behavior = base_behavior @actions = [action].flatten @subjects = [subject].flatten - @conditions = conditions + @conditions = conditions || {} @block = block end diff --git a/spec/cancan/can_definition_spec.rb b/spec/cancan/can_definition_spec.rb index c9f7633..1b5f534 100644 --- a/spec/cancan/can_definition_spec.rb +++ b/spec/cancan/can_definition_spec.rb @@ -36,4 +36,9 @@ describe CanCan::CanDefinition do @conditions[:test] = 1 @can.conditions(:tableize => true).should == { :foos => { :bar => 1}, :test => 1 } end + + it "should return no association joins if conditions is nil" do + can = CanCan::CanDefinition.new(true, :read, Integer, nil, nil) + can.association_joins.should be_nil + end end From dfd84a10ed03bab73de3a79428afe7fdf2f81127 Mon Sep 17 00:00:00 2001 From: Ryan Bates Date: Fri, 21 May 2010 13:41:24 -0700 Subject: [PATCH 3/5] improving inline documentation --- CHANGELOG.rdoc | 2 +- lib/cancan/ability.rb | 131 ++++++++++---------- lib/cancan/active_record_additions.rb | 12 +- lib/cancan/can_definition.rb | 34 +++-- lib/cancan/controller_additions.rb | 102 +++++++-------- lib/cancan/controller_resource.rb | 17 ++- lib/cancan/exceptions.rb | 22 ++-- lib/cancan/resource_authorization.rb | 20 +-- spec/cancan/ability_spec.rb | 60 ++++----- spec/cancan/active_record_additions_spec.rb | 6 +- spec/cancan/can_definition_spec.rb | 6 +- spec/cancan/controller_additions_spec.rb | 18 +-- spec/cancan/controller_resource_spec.rb | 18 +-- spec/cancan/exceptions_spec.rb | 10 +- spec/cancan/resource_authorization_spec.rb | 32 ++--- spec/spec_helper.rb | 2 +- 16 files changed, 254 insertions(+), 238 deletions(-) diff --git a/CHANGELOG.rdoc b/CHANGELOG.rdoc index 65dcf67..828453c 100644 --- a/CHANGELOG.rdoc +++ b/CHANGELOG.rdoc @@ -1,4 +1,4 @@ -* Fix issue when using accessible_by with nil can conditions (thanks jrallison) - see issue #66 +* Fixing issue when using accessible_by with nil can conditions (thanks jrallison) - see issue #66 * Pluralize table name for belongs_to associations in can conditions hash (thanks logandk) - see issue #62 diff --git a/lib/cancan/ability.rb b/lib/cancan/ability.rb index b20c0f1..d5c7002 100644 --- a/lib/cancan/ability.rb +++ b/lib/cancan/ability.rb @@ -1,8 +1,8 @@ module CanCan - + # This module is designed to be included into an Ability class. This will # provide the "can" methods for defining and checking abilities. - # + # # class Ability # include CanCan::Ability # @@ -14,179 +14,180 @@ module CanCan # end # end # end - # + # module Ability - # Use to check the user's permission for a given action and object. - # + # Use to check if the user has permission to perform a given action on an object. + # # can? :destroy, @project - # + # # You can also pass the class instead of an instance (if you don't have one handy). - # + # # can? :create, Project - # + # # Any additional arguments will be passed into the "can" block definition. This # can be used to pass more information about the user's request for example. - # + # # can? :create, Project, request.remote_ip - # + # # can :create Project do |project, remote_ip| # # ... # end - # - # Not only can you use the can? method in the controller and view (see ControllerAdditions), + # + # Not only can you use the can? method in the controller and view (see ControllerAdditions), # but you can also call it directly on an ability instance. - # + # # ability.can? :destroy, @project - # + # # This makes testing a user's abilities very easy. - # + # # def test "user can only destroy projects which he owns" # user = User.new # ability = Ability.new(user) # assert ability.can?(:destroy, Project.new(:user => user)) # assert ability.cannot?(:destroy, Project.new) # end - # + # + # Also see the RSpec Matchers to aid in testing. def can?(action, subject, *extra_args) raise Error, "Nom nom nom. I eated it." if action == :has && subject == :cheezburger can_definition = matching_can_definition(action, subject) can_definition && can_definition.can?(action, subject, extra_args) end - + # Convenience method which works the same as "can?" but returns the opposite value. - # + # # cannot? :destroy, @project - # + # def cannot?(*args) !can?(*args) end - + # Defines which abilities are allowed using two arguments. The first one is the action # you're setting the permission for, the second one is the class of object you're setting it on. - # + # # can :update, Article - # + # # You can pass an array for either of these parameters to match any one. # # can [:update, :destroy], [Article, Comment] # # In this case the user has the ability to update or destroy both articles and comments. - # + # # You can pass a hash of conditions as the third argument. # # can :read, Project, :active => true, :user_id => user.id - # - # Here the user can only see active projects which he owns. See ControllerAdditions#conditions for a way to - # use this in database queries. - # + # + # Here the user can only see active projects which he owns. See ActiveRecordAdditions#accessible_by + # for how to use this in database queries. + # # If the conditions hash does not give you enough control over defining abilities, you can use a block to # write any Ruby code you want. # # can :update, Project do |project| # project && project.groups.include?(user.group) # end - # + # # If the block returns true then the user has that :update ability for that project, otherwise he # will be denied access. It's possible for the passed in model to be nil if one isn't specified, # so be sure to take that into consideration. - # + # # The downside to using a block is that it cannot be used to generate conditions for database queries. - # + # # You can pass :all to reference every type of object. In this case the object type will be passed # into the block as well (just in case object is nil). - # + # # can :read, :all do |object_class, object| # object_class != Order # end - # + # # Here the user has permission to read all objects except orders. - # - # You can also pass :manage as the action which will match any action. In this case the action is + # + # You can also pass :manage as the action which will match any action. In this case the action is # passed to the block. - # + # # can :manage, Comment do |action, comment| # action != :destroy # end - # + # # You can pass custom objects into this "can" method, this is usually done through a symbol # and is useful if a class isn't available to define permissions on. - # + # # can :read, :stats # can? :read, :stats # => true - # + # def can(action, subject, conditions = nil, &block) can_definitions << CanDefinition.new(true, action, subject, conditions, block) end - - # Define an ability which cannot be done. Accepts the same arguments as "can". - # + + # Defines an ability which cannot be done. Accepts the same arguments as "can". + # # can :read, :all # cannot :read, Comment - # + # # A block can be passed just like "can", however if the logic is complex it is recommended # to use the "can" method. - # + # # cannot :read, Product do |product| # product.invisible? # end - # + # def cannot(action, subject, conditions = nil, &block) can_definitions << CanDefinition.new(false, action, subject, conditions, block) end - + # Alias one or more actions into another one. - # + # # alias_action :update, :destroy, :to => :modify # can :modify, Comment - # + # # Then :modify permission will apply to both :update and :destroy requests. - # + # # can? :update, Comment # => true # can? :destroy, Comment # => true - # + # # This only works in one direction. Passing the aliased action into the "can?" call # will not work because aliases are meant to generate more generic actions. - # + # # alias_action :update, :destroy, :to => :modify # can :update, Comment # can? :modify, Comment # => false - # + # # Unless that exact alias is used. - # + # # can :modify, Comment # can? :modify, Comment # => true - # + # # The following aliases are added by default for conveniently mapping common controller actions. - # + # # alias_action :index, :show, :to => :read # alias_action :new, :to => :create # alias_action :edit, :to => :update - # + # # This way one can use params[:action] in the controller to determine the permission. def alias_action(*args) target = args.pop[:to] aliased_actions[target] ||= [] aliased_actions[target] += args end - + # Returns a hash of aliased actions. The key is the target and the value is an array of actions aliasing the key. def aliased_actions @aliased_actions ||= default_alias_actions end - + # Removes previously aliased actions including the defaults. def clear_aliased_actions @aliased_actions = {} end - + # Returns a hash of conditions which match the given ability. This is useful if you need to generate a database # query based on the current ability. - # + # # can :read, Article, :visible => true # conditions :read, Article # returns { :visible => true } - # + # # Normally you will not call this method directly, but instead go through ActiveRecordAdditions#accessible_by method. - # + # # If the ability is not defined then false is returned so be sure to take that into consideration. # If the ability is defined using a block then this will raise an exception since a hash of conditions cannot be # determined from that. @@ -199,7 +200,7 @@ module CanCan false end end - + # Returns the associations used in conditions. This is usually used in the :joins option for a search. # See ActiveRecordAdditions#accessible_by for use in Active Record. def association_joins(action, subject) @@ -211,18 +212,18 @@ module CanCan end private - + def can_definitions @can_definitions ||= [] end - + def matching_can_definition(action, subject) can_definitions.reverse.detect do |can_definition| can_definition.expand_actions(aliased_actions) can_definition.matches? action, subject end end - + def default_alias_actions { :read => [:index, :show], diff --git a/lib/cancan/active_record_additions.rb b/lib/cancan/active_record_additions.rb index e5bda3b..54eb369 100644 --- a/lib/cancan/active_record_additions.rb +++ b/lib/cancan/active_record_additions.rb @@ -1,5 +1,5 @@ module CanCan - # This module is automatically included into all Active Record. + # This module is automatically included into all Active Record models. module ActiveRecordAdditions module ClassMethods # Returns a scope which fetches only the records that the passed ability @@ -7,16 +7,16 @@ module CanCan # is usually called from a controller and passed the +current_ability+. # # @articles = Article.accessible_by(current_ability) - # + # # Here only the articles which the user is able to read will be returned. # If the user does not have permission to read any articles then an empty # result is returned. Since this is a scope it can be combined with any # other scopes or pagination. - # + # # An alternative action can optionally be passed as a second argument. - # + # # @articles = Article.accessible_by(current_ability, :update) - # + # # Here only the articles which the user can update are returned. This # internally uses Ability#conditions method, see that for more information. def accessible_by(ability, action = :read) @@ -29,7 +29,7 @@ module CanCan end end end - + def self.included(base) base.extend ClassMethods end diff --git a/lib/cancan/can_definition.rb b/lib/cancan/can_definition.rb index fc1cb0b..bd0b007 100644 --- a/lib/cancan/can_definition.rb +++ b/lib/cancan/can_definition.rb @@ -1,9 +1,15 @@ module CanCan # This class is used internally and should only be called through Ability. + # it holds the information about a "can" call made on Ability and provides + # helpful methods to determine permission checking and conditions hash generation. class CanDefinition # :nodoc: include ActiveSupport::Inflector attr_reader :block + # The first argument when initializing is the base_behavior which is a true/false + # value. True for "can" and false for "cannot". The next two arguments are the action + # and subject respectively (such as :read, @project). The third argument is a hash + # of conditions and the last one is the block passed to the "can" call. def initialize(base_behavior, action, subject, conditions, block) @base_behavior = base_behavior @actions = [action].flatten @@ -11,27 +17,31 @@ module CanCan @conditions = conditions || {} @block = block end - + + # Accepts a hash of aliased actions and returns an array of actions which match. + # This should be called before "matches?" and other checking methods since they + # rely on the actions to be expanded. def expand_actions(aliased_actions) @expanded_actions = @actions.map do |action| aliased_actions[action] ? [action, *aliased_actions[action]] : action end.flatten end - + def matches?(action, subject) matches_action?(action) && matches_subject?(subject) end - + def can?(action, subject, extra_args) result = can_without_base_behavior?(action, subject, extra_args) @base_behavior ? result : !result end - + + # Returns a hash of conditions. If the ":tableize => true" option is passed + # it will pluralize the association conditions to match the table name. def conditions(options = {}) - if options[:tableize] and @conditions.kind_of? Hash + if options[:tableize] && @conditions.kind_of?(Hash) @conditions.inject({}) do |tableized_conditions, (name, value)| name = tableize(name).to_sym if value.kind_of? Hash - tableized_conditions[name] = value tableized_conditions end @@ -54,17 +64,17 @@ module CanCan end joins unless joins.empty? end - + private - + def matches_action?(action) @expanded_actions.include?(:manage) || @expanded_actions.include?(action) end - + def matches_subject?(subject) @subjects.include?(:all) || @subjects.include?(subject) || @subjects.any? { |sub| sub.kind_of?(Class) && subject.kind_of?(sub) } end - + def can_without_base_behavior?(action, subject, extra_args) if @block call_block(action, subject, extra_args) @@ -74,7 +84,7 @@ module CanCan true end end - + def matches_conditions?(subject, conditions = @conditions) conditions.all? do |name, value| attribute = subject.send(name) @@ -91,7 +101,7 @@ module CanCan end end end - + def call_block(action, subject, extra_args) block_args = [] block_args << action if @expanded_actions.include?(:manage) diff --git a/lib/cancan/controller_additions.rb b/lib/cancan/controller_additions.rb index 863780d..4b78b25 100644 --- a/lib/cancan/controller_additions.rb +++ b/lib/cancan/controller_additions.rb @@ -1,35 +1,35 @@ module CanCan - + # This module is automatically included into all controllers. # It also makes the "can?" and "cannot?" methods available to all views. module ControllerAdditions module ClassMethods # Sets up a before filter which loads and authorizes the current resource. This performs both # load_resource and authorize_resource and accepts the same arguments. See those methods for details. - # + # # class BooksController < ApplicationController # load_and_authorize_resource # end - # + # def load_and_authorize_resource(options = {}) ResourceAuthorization.add_before_filter(self, :load_and_authorize_resource, options) end - + # Sets up a before filter which loads the appropriate model resource into an instance variable. # For example, given an ArticlesController it will load the current article into the @article # instance variable. It does this by either calling Article.find(params[:id]) or # Article.new(params[:article]) depending upon the action. It does nothing for the "index" # action. - # + # # Call this method directly on the controller class. - # + # # class BooksController < ApplicationController # load_resource # end - # + # # A resource is not loaded if the instance variable is already set. This makes it easy to override # the behavior through a before_filter on certain actions. - # + # # class BooksController < ApplicationController # before_filter :find_book_by_permalink, :only => :show # load_resource @@ -40,107 +40,107 @@ module CanCan # @book = Book.find_by_permalink!(params[:id) # end # end - # + # # See load_and_authorize_resource to automatically authorize the resource too. - # + # # Options: # [:+only+] # Only applies before filter to given actions. - # + # # [:+except+] # Does not apply before filter to given actions. - # + # # [:+nested+] # Specify which resource this is nested under. - # + # # load_resource :nested => :author - # + # # Deep nesting can be defined in an array. - # + # # load_resource :nested => [:publisher, :author] - # + # # [:+resource+] # The class to use for the model (string or constant). - # + # # [:+collection+] # Specify which actions are resource collection actions in addition to :+index+. This # is usually not necessary because it will try to guess depending on if an :+id+ # is present in +params+. - # + # # load_resource :collection => [:sort, :list] - # + # # [:+new+] # Specify which actions are new resource actions in addition to :+new+ and :+create+. # Pass an action name into here if you would like to build a new resource instead of # fetch one. - # + # # load_resource :new => :build - # + # def load_resource(options = {}) ResourceAuthorization.add_before_filter(self, :load_resource, options) end - + # Sets up a before filter which authorizes the current resource using the instance variable. # For example, if you have an ArticlesController it will check the @article instance variable # and ensure the user can perform the current action on it. Under the hood it is doing # something like the following. - # + # # authorize!(params[:action].to_sym, @article || Article) - # + # # Call this method directly on the controller class. - # + # # class BooksController < ApplicationController # authorize_resource # end - # + # # See load_and_authorize_resource to automatically load the resource too. - # + # # Options: # [:+only+] # Only applies before filter to given actions. - # + # # [:+except+] # Does not apply before filter to given actions. - # + # # [:+resource+] # The class to use for the model (string or constant). Alternatively pass a symbol # to represent a resource which does not have a class. - # + # def authorize_resource(options = {}) ResourceAuthorization.add_before_filter(self, :authorize_resource, options) end end - + def self.included(base) base.extend ClassMethods base.helper_method :can?, :cannot? end - + # Raises a CanCan::AccessDenied exception if the current_ability cannot # perform the given action. This is usually called in a controller action or # before filter to perform the authorization. - # + # # def show # @article = Article.find(params[:id]) # authorize! :read, @article # end - # + # # A :message option can be passed to specify a different message. - # + # # authorize! :read, @article, :message => "Not authorized to read #{@article.name}" - # + # # You can rescue from the exception in the controller to customize how unauthorized # access is displayed to the user. - # + # # class ApplicationController < ActionController::Base # rescue_from CanCan::AccessDenied do |exception| # flash[:error] = exception.message # redirect_to root_url # end # end - # + # # See the CanCan::AccessDenied exception for more details on working with the exception. - # + # # See the load_and_authorize_resource method to automatically add the authorize! behavior # to the default RESTful actions. def authorize!(action, subject, *args) @@ -150,46 +150,46 @@ module CanCan end raise AccessDenied.new(message, action, subject) if cannot?(action, subject, *args) end - + def unauthorized!(message = nil) raise ImplementationRemoved, "The unauthorized! method has been removed from CanCan, use authorize! instead." end - + # Creates and returns the current user's ability and caches it. If you # want to override how the Ability is defined then this is the place. # Just define the method in the controller to change behavior. - # + # # def current_ability # # instead of Ability.new(current_user) # @current_ability ||= UserAbility.new(current_account) # end - # + # # Notice it is important to cache the ability object so it is not # recreated every time. def current_ability @current_ability ||= ::Ability.new(current_user) end - + # Use in the controller or view to check the user's permission for a given action # and object. - # + # # can? :destroy, @project - # + # # You can also pass the class instead of an instance (if you don't have one handy). - # + # # <% if can? :create, Project %> # <%= link_to "New Project", new_project_path %> # <% end %> - # + # # This simply calls "can?" on the current_ability. See Ability#can?. def can?(*args) current_ability.can?(*args) end - + # Convenience method which works the same as "can?" but returns the opposite value. - # + # # cannot? :destroy, @project - # + # def cannot?(*args) current_ability.cannot?(*args) end diff --git a/lib/cancan/controller_resource.rb b/lib/cancan/controller_resource.rb index d2f18cb..36d77bc 100644 --- a/lib/cancan/controller_resource.rb +++ b/lib/cancan/controller_resource.rb @@ -1,5 +1,7 @@ module CanCan # Used internally to load and authorize a given controller resource. + # This manages finding or building an instance of the resource. If a + # parent is given it will go through the association. class ControllerResource # :nodoc: def initialize(controller, name, parent = nil, options = {}) raise ImplementationRemoved, "The :class option has been renamed to :resource for specifying the class in CanCan." if options.has_key? :class @@ -9,6 +11,9 @@ module CanCan @options = options end + # Returns the class used for this resource. This can be overriden by the :resource option. + # Sometimes one will use a symbol as the resource if a class does not exist for it. In that + # case "find" and "build" should not be called on it. def model_class resource_class = @options[:resource] if resource_class.nil? @@ -16,7 +21,7 @@ module CanCan elsif resource_class.kind_of? String resource_class.constantize else - resource_class # likely a symbol + resource_class # could be a symbol end end @@ -24,12 +29,10 @@ module CanCan self.model_instance ||= base.find(id) end + # Build a new instance of this resource. If it is a class we just call "new" otherwise + # it's an associaiton and "build" is used. def build(attributes) - if base.kind_of? Class - self.model_instance ||= base.new(attributes) - else - self.model_instance ||= base.build(attributes) - end + self.model_instance ||= (base.kind_of?(Class) ? base.new(attributes) : base.build(attributes)) end def model_instance @@ -42,6 +45,8 @@ module CanCan private + # The object that methods (such as "find", "new" or "build") are called on. + # If there is a parent it will be the association, otherwise it will be the model's class. def base @parent ? @parent.model_instance.send(@name.to_s.pluralize) : model_class end diff --git a/lib/cancan/exceptions.rb b/lib/cancan/exceptions.rb index 33e5bee..177584f 100644 --- a/lib/cancan/exceptions.rb +++ b/lib/cancan/exceptions.rb @@ -1,41 +1,41 @@ module CanCan # A general CanCan exception class Error < StandardError; end - + # Raised when removed code is called, an alternative solution is provided in message. class ImplementationRemoved < Error; end - + # This error is raised when a user isn't allowed to access a given controller action. # This usually happens within a call to ControllerAdditions#authorize! but can be # raised manually. - # + # # raise CanCan::AccessDenied.new("Not authorized!", :read, Article) - # + # # The passed message, action, and subject are optional and can later be retrieved when # rescuing from the exception. - # + # # exception.message # => "Not authorized!" # exception.action # => :read # exception.subject # => Article - # - # If the message is not specified (or is nil) it will default to "You are anot authorized + # + # If the message is not specified (or is nil) it will default to "You are not authorized # to access this page." This default can be overridden by setting default_message. - # + # # exception.default_message = "Default error message" # exception.message # => "Default error message" - # + # # See ControllerAdditions#authorized! for more information on rescuing from this exception. class AccessDenied < Error attr_reader :action, :subject attr_writer :default_message - + def initialize(message = nil, action = nil, subject = nil) @message = message @action = action @subject = subject @default_message = "You are not authorized to access this page." end - + def to_s @message || @default_message end diff --git a/lib/cancan/resource_authorization.rb b/lib/cancan/resource_authorization.rb index 21429df..ef9a9b2 100644 --- a/lib/cancan/resource_authorization.rb +++ b/lib/cancan/resource_authorization.rb @@ -7,18 +7,18 @@ module CanCan ResourceAuthorization.new(controller, controller.params, options.except(:only, :except)).send(method) end end - + def initialize(controller, params, options = {}) @controller = controller @params = params @options = options end - + def load_and_authorize_resource load_resource authorize_resource end - + def load_resource unless collection_actions.include? @params[:action].to_sym if new_actions.include? @params[:action].to_sym @@ -28,17 +28,17 @@ module CanCan end end end - + def authorize_resource @controller.authorize!(@params[:action].to_sym, resource.model_instance || resource.model_class) end - + private - + def resource @resource ||= ControllerResource.new(@controller, model_name, parent_resource, @options) end - + def parent_resource parent = nil [@options[:nested]].flatten.compact.each do |name| @@ -52,15 +52,15 @@ module CanCan end parent end - + def model_name @params[:controller].sub("Controller", "").underscore.split('/').last.singularize end - + def collection_actions [:index] + [@options[:collection]].flatten end - + def new_actions [:new, :create] + [@options[:new]].flatten end diff --git a/spec/cancan/ability_spec.rb b/spec/cancan/ability_spec.rb index 169c040..4a49170 100644 --- a/spec/cancan/ability_spec.rb +++ b/spec/cancan/ability_spec.rb @@ -5,17 +5,17 @@ describe CanCan::Ability do @ability = Object.new @ability.extend(CanCan::Ability) end - + it "should be able to :read anything" do @ability.can :read, :all @ability.can?(:read, String).should be_true @ability.can?(:read, 123).should be_true end - + it "should not have permission to do something it doesn't know about" do @ability.can?(:foodfight, String).should be_false end - + it "should return what block returns on a can call" do @ability.can :read, :all @ability.can :read, Symbol do |sym| @@ -24,21 +24,21 @@ describe CanCan::Ability do @ability.can?(:read, Symbol).should be_nil @ability.can?(:read, :some_symbol).should == :some_symbol end - + it "should pass class with object if :all objects are accepted" do @ability.can :preview, :all do |object_class, object| [object_class, object] end @ability.can?(:preview, 123).should == [Fixnum, 123] end - + it "should pass class with no object if :all objects are accepted and class is passed directly" do @ability.can :preview, :all do |object_class, object| [object_class, object] end @ability.can?(:preview, Hash).should == [Hash, nil] end - + it "should pass action and object for global manage actions" do @ability.can :manage, Array do |action, object| [action, object] @@ -46,14 +46,14 @@ describe CanCan::Ability do @ability.can?(:stuff, [1, 2]).should == [:stuff, [1, 2]] @ability.can?(:stuff, Array).should == [:stuff, nil] end - + it "should alias update or destroy actions to modify action" do @ability.alias_action :update, :destroy, :to => :modify @ability.can(:modify, :all) { :modify_called } @ability.can?(:update, 123).should == :modify_called @ability.can?(:destroy, 123).should == :modify_called end - + it "should return block result for action, object_class, and object for any action" do @ability.can :manage, :all do |action, object_class, object| [action, object_class, object] @@ -61,56 +61,56 @@ describe CanCan::Ability do @ability.can?(:foo, 123).should == [:foo, Fixnum, 123] @ability.can?(:bar, Fixnum).should == [:bar, Fixnum, nil] end - + it "should automatically alias index and show into read calls" do @ability.can :read, :all @ability.can?(:index, 123).should be_true @ability.can?(:show, 123).should be_true end - + it "should automatically alias new and edit into create and update respectively" do @ability.can(:create, :all) { :create_called } @ability.can(:update, :all) { :update_called } @ability.can?(:new, 123).should == :create_called @ability.can?(:edit, 123).should == :update_called end - + it "should not respond to prepare (now using initialize)" do @ability.should_not respond_to(:prepare) end - + it "should offer cannot? method which is simply invert of can?" do @ability.cannot?(:tie, String).should be_true end - + it "should be able to specify multiple actions and match any" do @ability.can [:read, :update], :all @ability.can?(:read, 123).should be_true @ability.can?(:update, 123).should be_true @ability.can?(:count, 123).should be_false end - + it "should be able to specify multiple classes and match any" do @ability.can :update, [String, Array] @ability.can?(:update, "foo").should be_true @ability.can?(:update, []).should be_true @ability.can?(:update, 123).should be_false end - + it "should support custom objects in the can definition" do @ability.can :read, :stats @ability.can?(:read, :stats).should be_true @ability.can?(:update, :stats).should be_false @ability.can?(:read, :nonstats).should be_false end - + it "should support 'cannot' method to define what user cannot do" do @ability.can :read, :all @ability.cannot :read, Integer @ability.can?(:read, "foo").should be_true @ability.can?(:read, 123).should be_false end - + it "should support block on 'cannot' method" do @ability.can :read, :all @ability.cannot :read, Integer do |int| @@ -120,19 +120,19 @@ describe CanCan::Ability do @ability.can?(:read, 3).should be_true @ability.can?(:read, 123).should be_false end - + it "should append aliased actions" do @ability.alias_action :update, :to => :modify @ability.alias_action :destroy, :to => :modify @ability.aliased_actions[:modify].should == [:update, :destroy] end - + it "should clear aliased actions" do @ability.alias_action :update, :to => :modify @ability.clear_aliased_actions @ability.aliased_actions[:modify].should be_nil end - + it "should pass additional arguments to block from can?" do @ability.can :read, Integer do |int, x| int > x @@ -140,61 +140,61 @@ describe CanCan::Ability do @ability.can?(:read, 2, 1).should be_true @ability.can?(:read, 2, 3).should be_false end - + it "should use conditions as third parameter and determine abilities from it" do @ability.can :read, Array, :first => 1, :last => 3 @ability.can?(:read, [1, 2, 3]).should be_true @ability.can?(:read, [1, 2, 3, 4]).should be_false @ability.can?(:read, Array).should be_true end - + it "should allow an array of options in conditions hash" do @ability.can :read, Array, :first => [1, 3, 5] @ability.can?(:read, [1, 2, 3]).should be_true @ability.can?(:read, [2, 3]).should be_false @ability.can?(:read, [3, 4]).should be_true end - + it "should allow a range of options in conditions hash" do @ability.can :read, Array, :first => 1..3 @ability.can?(:read, [1, 2, 3]).should be_true @ability.can?(:read, [3, 4]).should be_true @ability.can?(:read, [4, 5]).should be_false end - + it "should allow nested hashes in conditions hash" do @ability.can :read, Array, :first => { :length => 5 } @ability.can?(:read, ["foo", "bar"]).should be_false @ability.can?(:read, ["test1", "foo"]).should be_true end - + it "should allow nested hash of arrays and match any element" do @ability.can :read, Array, :first => { :to_i => 3 } @ability.can?(:read, [[1, 2, 3]]).should be_true @ability.can?(:read, [[4, 5, 6]]).should be_false end - + it "should return conditions for a given ability" do @ability.can :read, Array, :first => 1, :last => 3 @ability.conditions(:show, Array).should == {:first => 1, :last => 3} end - + it "should raise an exception when a block is used on condition" do @ability.can :read, Array do |a| true end lambda { @ability.conditions(:show, Array) }.should raise_error(CanCan::Error, "Cannot determine ability conditions from block for :show Array") end - + it "should return an empty hash for conditions when there are no conditions" do @ability.can :read, Array @ability.conditions(:show, Array).should == {} end - + it "should return false when performed on an action which isn't defined" do @ability.conditions(:foo, Array).should == false end - + it "should has eated cheezburger" do lambda { @ability.can? :has, :cheezburger diff --git a/spec/cancan/active_record_additions_spec.rb b/spec/cancan/active_record_additions_spec.rb index 41aaf3c..7166393 100644 --- a/spec/cancan/active_record_additions_spec.rb +++ b/spec/cancan/active_record_additions_spec.rb @@ -8,18 +8,18 @@ describe CanCan::ActiveRecordAdditions do @ability = Object.new @ability.extend(CanCan::Ability) end - + it "should call where(:id => nil) when no ability is defined so no records are found" do stub(@model_class).where(:id => nil).stub!.joins(nil) { :no_where } @model_class.accessible_by(@ability, :read).should == :no_where end - + it "should call where with matching ability conditions" do @ability.can :read, @model_class, :foo => {:bar => 1} stub(@model_class).where(:foos => { :bar => 1 }).stub!.joins([:foo]) { :found_records } @model_class.accessible_by(@ability, :read).should == :found_records end - + it "should default to :read ability and use scoped when where isn't available" do @ability.can :read, @model_class, :foo => {:bar => 1} stub(@model_class).scoped(:conditions => {:foos => {:bar => 1}}, :joins => [:foo]) { :found_records } diff --git a/spec/cancan/can_definition_spec.rb b/spec/cancan/can_definition_spec.rb index 1b5f534..6762a3d 100644 --- a/spec/cancan/can_definition_spec.rb +++ b/spec/cancan/can_definition_spec.rb @@ -5,7 +5,7 @@ describe CanCan::CanDefinition do @conditions = {} @can = CanCan::CanDefinition.new(true, :read, Integer, @conditions, nil) end - + it "should return no association joins if none exist" do @can.association_joins.should be_nil end @@ -30,13 +30,13 @@ describe CanCan::CanDefinition do @conditions[:foo] = {:bar => {1 => 2}} @can.association_joins.should == [{:foo => [:bar]}] end - + it "should return table names in conditions for association joins" do @conditions[:foo] = {:bar => 1} @conditions[:test] = 1 @can.conditions(:tableize => true).should == { :foos => { :bar => 1}, :test => 1 } end - + it "should return no association joins if conditions is nil" do can = CanCan::CanDefinition.new(true, :read, Integer, nil, nil) can.association_joins.should be_nil diff --git a/spec/cancan/controller_additions_spec.rb b/spec/cancan/controller_additions_spec.rb index 9239557..f886c35 100644 --- a/spec/cancan/controller_additions_spec.rb +++ b/spec/cancan/controller_additions_spec.rb @@ -9,11 +9,11 @@ describe CanCan::ControllerAdditions do mock(@controller_class).helper_method(:can?, :cannot?) @controller_class.send(:include, CanCan::ControllerAdditions) end - + it "should raise ImplementationRemoved when attempting to call 'unauthorized!' on a controller" do lambda { @controller.unauthorized! }.should raise_error(CanCan::ImplementationRemoved) end - + it "should raise access denied exception if ability us unauthorized to perform a certain action" do begin @controller.authorize! :read, :foo, 1, 2, 3, :message => "Access denied!" @@ -25,12 +25,12 @@ describe CanCan::ControllerAdditions do fail "Expected CanCan::AccessDenied exception to be raised" end end - + it "should not raise access denied exception if ability is authorized to perform an action" do @controller.current_ability.can :read, :foo lambda { @controller.authorize!(:read, :foo) }.should_not raise_error end - + it "should raise access denied exception with default message if not specified" do begin @controller.authorize! :read, :foo @@ -41,29 +41,29 @@ describe CanCan::ControllerAdditions do fail "Expected CanCan::AccessDenied exception to be raised" end end - + it "should have a current_ability method which generates an ability for the current user" do @controller.current_ability.should be_kind_of(Ability) end - + it "should provide a can? and cannot? methods which go through the current ability" do @controller.current_ability.should be_kind_of(Ability) @controller.can?(:foo, :bar).should be_false @controller.cannot?(:foo, :bar).should be_true end - + it "load_and_authorize_resource should setup a before filter which passes call to ResourceAuthorization" do stub(CanCan::ResourceAuthorization).new(@controller, @controller.params, :foo => :bar).mock!.load_and_authorize_resource mock(@controller_class).before_filter({}) { |options, block| block.call(@controller) } @controller_class.load_and_authorize_resource :foo => :bar end - + it "authorize_resource should setup a before filter which passes call to ResourceAuthorization" do stub(CanCan::ResourceAuthorization).new(@controller, @controller.params, :foo => :bar).mock!.authorize_resource mock(@controller_class).before_filter(:except => :show) { |options, block| block.call(@controller) } @controller_class.authorize_resource :foo => :bar, :except => :show end - + it "load_resource should setup a before filter which passes call to ResourceAuthorization" do stub(CanCan::ResourceAuthorization).new(@controller, @controller.params, :foo => :bar).mock!.load_resource mock(@controller_class).before_filter(:only => [:show, :index]) { |options, block| block.call(@controller) } diff --git a/spec/cancan/controller_resource_spec.rb b/spec/cancan/controller_resource_spec.rb index c93b055..ee61e44 100644 --- a/spec/cancan/controller_resource_spec.rb +++ b/spec/cancan/controller_resource_spec.rb @@ -4,53 +4,53 @@ describe CanCan::ControllerResource do before(:each) do @controller = Object.new end - + it "should determine model class by constantizing give name" do CanCan::ControllerResource.new(@controller, :ability).model_class.should == Ability end - + it "should fetch model through model class and assign it to the instance" do stub(Ability).find(123) { :some_ability } CanCan::ControllerResource.new(@controller, :ability).find(123) @controller.instance_variable_get(:@ability).should == :some_ability end - + it "should fetch model through parent and assign it to the instance" do parent = Object.new stub(parent).model_instance.stub!.abilities.stub!.find(123) { :some_ability } CanCan::ControllerResource.new(@controller, :ability, parent).find(123) @controller.instance_variable_get(:@ability).should == :some_ability end - + it "should build model through model class and assign it to the instance" do stub(Ability).new(123) { :some_ability } CanCan::ControllerResource.new(@controller, :ability).build(123) @controller.instance_variable_get(:@ability).should == :some_ability end - + it "should build model through parent and assign it to the instance" do parent = Object.new stub(parent).model_instance.stub!.abilities.stub!.build(123) { :some_ability } CanCan::ControllerResource.new(@controller, :ability, parent).build(123) @controller.instance_variable_get(:@ability).should == :some_ability end - + it "should not load resource if instance variable is already provided" do @controller.instance_variable_set(:@ability, :some_ability) CanCan::ControllerResource.new(@controller, :ability).find(123) @controller.instance_variable_get(:@ability).should == :some_ability end - + it "should use the model class option if provided" do stub(Person).find(123) { :some_resource } CanCan::ControllerResource.new(@controller, :ability, nil, :resource => Person).find(123) @controller.instance_variable_get(:@ability).should == :some_resource end - + it "should convert string to constant for resource" do CanCan::ControllerResource.new(@controller, :ability, nil, :resource => "Person").model_class.should == Person end - + it "should raise an exception when specifying :class option since it is no longer used" do lambda { CanCan::ControllerResource.new(@controller, :ability, nil, :class => Person) diff --git a/spec/cancan/exceptions_spec.rb b/spec/cancan/exceptions_spec.rb index 6ea6b43..1c98832 100644 --- a/spec/cancan/exceptions_spec.rb +++ b/spec/cancan/exceptions_spec.rb @@ -5,29 +5,29 @@ describe CanCan::AccessDenied do before(:each) do @exception = CanCan::AccessDenied.new(nil, :some_action, :some_subject) end - + it "should have action and subject accessors" do @exception.action.should == :some_action @exception.subject.should == :some_subject end - + it "should have a changable default message" do @exception.message.should == "You are not authorized to access this page." @exception.default_message = "Unauthorized!" @exception.message.should == "Unauthorized!" end end - + describe "with only a message" do before(:each) do @exception = CanCan::AccessDenied.new("Access denied!") end - + it "should have nil action and subject" do @exception.action.should be_nil @exception.subject.should be_nil end - + it "should have passed message" do @exception.message.should == "Access denied!" end diff --git a/spec/cancan/resource_authorization_spec.rb b/spec/cancan/resource_authorization_spec.rb index 29f2048..4d9a88e 100644 --- a/spec/cancan/resource_authorization_spec.rb +++ b/spec/cancan/resource_authorization_spec.rb @@ -4,101 +4,101 @@ describe CanCan::ResourceAuthorization do before(:each) do @controller = Object.new # simple stub for now end - + it "should load the resource into an instance variable if params[:id] is specified" do stub(Ability).find(123) { :some_resource } authorization = CanCan::ResourceAuthorization.new(@controller, :controller => "abilities", :action => "show", :id => 123) authorization.load_resource @controller.instance_variable_get(:@ability).should == :some_resource end - + it "should properly load resource for namespaced controller" do stub(Ability).find(123) { :some_resource } authorization = CanCan::ResourceAuthorization.new(@controller, :controller => "admin/abilities", :action => "show", :id => 123) authorization.load_resource @controller.instance_variable_get(:@ability).should == :some_resource end - + it "should properly load resource for namespaced controller when using '::' for namespace" do stub(Ability).find(123) { :some_resource } authorization = CanCan::ResourceAuthorization.new(@controller, :controller => "Admin::AbilitiesController", :action => "show", :id => 123) authorization.load_resource @controller.instance_variable_get(:@ability).should == :some_resource end - + it "should build a new resource with hash if params[:id] is not specified" do stub(Ability).new(:foo => "bar") { :some_resource } authorization = CanCan::ResourceAuthorization.new(@controller, :controller => "abilities", :action => "create", :ability => {:foo => "bar"}) authorization.load_resource @controller.instance_variable_get(:@ability).should == :some_resource end - + it "should build a new resource even if attribute hash isn't specified" do stub(Ability).new(nil) { :some_resource } authorization = CanCan::ResourceAuthorization.new(@controller, :controller => "abilities", :action => "new") authorization.load_resource @controller.instance_variable_get(:@ability).should == :some_resource end - + it "should not build a resource when on index action" do authorization = CanCan::ResourceAuthorization.new(@controller, :controller => "abilities", :action => "index") authorization.load_resource @controller.instance_variable_get(:@ability).should be_nil end - + it "should perform authorization using controller action and loaded model" do @controller.instance_variable_set(:@ability, :some_resource) stub(@controller).authorize!(:show, :some_resource) { raise CanCan::AccessDenied } authorization = CanCan::ResourceAuthorization.new(@controller, :controller => "abilities", :action => "show") lambda { authorization.authorize_resource }.should raise_error(CanCan::AccessDenied) end - + it "should perform authorization using controller action and non loaded model" do stub(@controller).authorize!(:show, Ability) { raise CanCan::AccessDenied } authorization = CanCan::ResourceAuthorization.new(@controller, :controller => "abilities", :action => "show") lambda { authorization.authorize_resource }.should raise_error(CanCan::AccessDenied) end - + it "should call load_resource and authorize_resource for load_and_authorize_resource" do authorization = CanCan::ResourceAuthorization.new(@controller, :controller => "abilities", :action => "show") mock(authorization).load_resource mock(authorization).authorize_resource authorization.load_and_authorize_resource end - + it "should not build a resource when on custom collection action" do authorization = CanCan::ResourceAuthorization.new(@controller, {:controller => "abilities", :action => "sort"}, {:collection => [:sort, :list]}) authorization.load_resource @controller.instance_variable_get(:@ability).should be_nil end - + it "should build a resource when on custom new action even when params[:id] exists" do stub(Ability).new(nil) { :some_resource } authorization = CanCan::ResourceAuthorization.new(@controller, {:controller => "abilities", :action => "build", :id => 123}, {:new => :build}) authorization.load_resource @controller.instance_variable_get(:@ability).should == :some_resource end - + it "should not try to load resource for other action if params[:id] is undefined" do authorization = CanCan::ResourceAuthorization.new(@controller, :controller => "abilities", :action => "list") authorization.load_resource @controller.instance_variable_get(:@ability).should be_nil end - + it "should load nested resource and fetch other resource through the association" do stub(Person).find(456).stub!.abilities.stub!.find(123) { :some_ability } authorization = CanCan::ResourceAuthorization.new(@controller, {:controller => "abilities", :action => "show", :id => 123, :person_id => 456}, {:nested => :person}) authorization.load_resource @controller.instance_variable_get(:@ability).should == :some_ability end - + it "should load nested resource and build resource through a deep association" do stub(Person).find(456).stub!.behaviors.stub!.find(789).stub!.abilities.stub!.build(nil) { :some_ability } authorization = CanCan::ResourceAuthorization.new(@controller, {:controller => "abilities", :action => "new", :person_id => 456, :behavior_id => 789}, {:nested => [:person, :behavior]}) authorization.load_resource @controller.instance_variable_get(:@ability).should == :some_ability end - + it "should not load nested resource and build through this if *_id param isn't specified" do stub(Person).find(456) { :some_person } stub(Ability).new(nil) { :some_ability } @@ -107,7 +107,7 @@ describe CanCan::ResourceAuthorization do @controller.instance_variable_get(:@person).should == :some_person @controller.instance_variable_get(:@ability).should == :some_ability end - + it "should load the model using a custom class" do stub(Person).find(123) { :some_resource } authorization = CanCan::ResourceAuthorization.new(@controller, {:controller => "abilities", :action => "show", :id => 123}, {:resource => Person}) diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb index 4e670be..20c75f6 100644 --- a/spec/spec_helper.rb +++ b/spec/spec_helper.rb @@ -13,7 +13,7 @@ end class Ability include CanCan::Ability - + def initialize(user) end end From 2a3dd85a185b0f27d308633db499fddb182216dc Mon Sep 17 00:00:00 2001 From: Ryan Bates Date: Fri, 21 May 2010 14:20:45 -0700 Subject: [PATCH 4/5] adding :name option to load_and_authorize_resource if it does not match controller - closes #65 --- CHANGELOG.rdoc | 2 ++ lib/cancan/controller_additions.rb | 10 ++++++++++ lib/cancan/resource_authorization.rb | 2 +- spec/cancan/resource_authorization_spec.rb | 7 +++++++ 4 files changed, 20 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.rdoc b/CHANGELOG.rdoc index 828453c..38ffc70 100644 --- a/CHANGELOG.rdoc +++ b/CHANGELOG.rdoc @@ -1,3 +1,5 @@ +* Adding :name option to load_and_authorize_resource if it does not match controller - see issue #65 + * Fixing issue when using accessible_by with nil can conditions (thanks jrallison) - see issue #66 * Pluralize table name for belongs_to associations in can conditions hash (thanks logandk) - see issue #62 diff --git a/lib/cancan/controller_additions.rb b/lib/cancan/controller_additions.rb index 4b78b25..28f3bb4 100644 --- a/lib/cancan/controller_additions.rb +++ b/lib/cancan/controller_additions.rb @@ -59,6 +59,11 @@ module CanCan # # load_resource :nested => [:publisher, :author] # + # [:+name+] + # The name of the resource if it cannot be determined from controller (string or symbol). + # + # load_resource :name => :article + # # [:+resource+] # The class to use for the model (string or constant). # @@ -102,6 +107,11 @@ module CanCan # [:+except+] # Does not apply before filter to given actions. # + # [:+name+] + # The name of the resource if it cannot be determined from controller (string or symbol). + # + # load_resource :name => :article + # # [:+resource+] # The class to use for the model (string or constant). Alternatively pass a symbol # to represent a resource which does not have a class. diff --git a/lib/cancan/resource_authorization.rb b/lib/cancan/resource_authorization.rb index ef9a9b2..0b7fcec 100644 --- a/lib/cancan/resource_authorization.rb +++ b/lib/cancan/resource_authorization.rb @@ -54,7 +54,7 @@ module CanCan end def model_name - @params[:controller].sub("Controller", "").underscore.split('/').last.singularize + @options[:name] || @params[:controller].sub("Controller", "").underscore.split('/').last.singularize end def collection_actions diff --git a/spec/cancan/resource_authorization_spec.rb b/spec/cancan/resource_authorization_spec.rb index 4d9a88e..d561fed 100644 --- a/spec/cancan/resource_authorization_spec.rb +++ b/spec/cancan/resource_authorization_spec.rb @@ -114,4 +114,11 @@ describe CanCan::ResourceAuthorization do authorization.load_resource @controller.instance_variable_get(:@ability).should == :some_resource end + + it "should use :name option to determine resource name" do + stub(Ability).find(123) { :some_resource } + authorization = CanCan::ResourceAuthorization.new(@controller, {:controller => "foo", :action => "show", :id => 123}, {:name => :ability}) + authorization.load_resource + @controller.instance_variable_get(:@ability).should == :some_resource + end end From 1ade44221a5e54b7c561499b89794150827dd5d6 Mon Sep 17 00:00:00 2001 From: Ryan Bates Date: Fri, 21 May 2010 15:22:21 -0700 Subject: [PATCH 5/5] load parent resources for collection actions such 'index' --- CHANGELOG.rdoc | 2 ++ lib/cancan/resource_authorization.rb | 4 +++- spec/cancan/resource_authorization_spec.rb | 13 ++++++++++++- 3 files changed, 17 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.rdoc b/CHANGELOG.rdoc index 38ffc70..3a3c89f 100644 --- a/CHANGELOG.rdoc +++ b/CHANGELOG.rdoc @@ -1,3 +1,5 @@ +* Load nested parent resources on collection actions such as "index" (thanks dohzya) + * Adding :name option to load_and_authorize_resource if it does not match controller - see issue #65 * Fixing issue when using accessible_by with nil can conditions (thanks jrallison) - see issue #66 diff --git a/lib/cancan/resource_authorization.rb b/lib/cancan/resource_authorization.rb index 0b7fcec..aa8f710 100644 --- a/lib/cancan/resource_authorization.rb +++ b/lib/cancan/resource_authorization.rb @@ -20,7 +20,9 @@ module CanCan end def load_resource - unless collection_actions.include? @params[:action].to_sym + if collection_actions.include? @params[:action].to_sym + parent_resource + else if new_actions.include? @params[:action].to_sym resource.build(@params[model_name.to_sym]) elsif @params[:id] diff --git a/spec/cancan/resource_authorization_spec.rb b/spec/cancan/resource_authorization_spec.rb index d561fed..6f50b3a 100644 --- a/spec/cancan/resource_authorization_spec.rb +++ b/spec/cancan/resource_authorization_spec.rb @@ -86,12 +86,23 @@ describe CanCan::ResourceAuthorization do end it "should load nested resource and fetch other resource through the association" do - stub(Person).find(456).stub!.abilities.stub!.find(123) { :some_ability } + person = Object.new + stub(Person).find(456) { person } + stub(person).abilities.stub!.find(123) { :some_ability } authorization = CanCan::ResourceAuthorization.new(@controller, {:controller => "abilities", :action => "show", :id => 123, :person_id => 456}, {:nested => :person}) authorization.load_resource + @controller.instance_variable_get(:@person).should == person @controller.instance_variable_get(:@ability).should == :some_ability end + it "should load nested resource for collection action" do + person = Object.new + stub(Person).find(456) { person } + authorization = CanCan::ResourceAuthorization.new(@controller, {:controller => "abilities", :action => "index", :person_id => 456}, {:nested => :person}) + authorization.load_resource + @controller.instance_variable_get(:@person).should == person + end + it "should load nested resource and build resource through a deep association" do stub(Person).find(456).stub!.behaviors.stub!.find(789).stub!.abilities.stub!.build(nil) { :some_ability } authorization = CanCan::ResourceAuthorization.new(@controller, {:controller => "abilities", :action => "new", :person_id => 456, :behavior_id => 789}, {:nested => [:person, :behavior]})