marnen-cancan 2.0.0.alpha.pre.f1cebde51a87be149b4970a3287826bb63c0ac0b

data/lib/cancan/model_adapters/data_mapper_adapter.rb

@@ -0,0 +1,34 @@
+module CanCan
+  module ModelAdapters
+    class DataMapperAdapter < AbstractAdapter
+      def self.for_class?(model_class)
+        model_class <= DataMapper::Resource
+      end
+
+      def self.find(model_class, id)
+        model_class.get(id)
+      end
+
+      def self.override_conditions_hash_matching?(subject, conditions)
+        conditions.any? { |k,v| !k.kind_of?(Symbol) }
+      end
+
+      def self.matches_conditions_hash?(subject, conditions)
+        collection = DataMapper::Collection.new(subject.query, [ subject ])
+        !!collection.first(conditions)
+      end
+
+      def database_records
+        scope = @model_class.all(:conditions => ["0 = 1"])
+        cans, cannots = @rules.partition { |r| r.base_behavior }
+        return scope if cans.empty?
+        # apply unions first, then differences. this mean cannot overrides can
+        cans.each    { |r| scope += @model_class.all(:conditions => r.conditions) }
+        cannots.each { |r| scope -= @model_class.all(:conditions => r.conditions) }
+        scope
+      end
+    end # class DataMapper
+  end # module ModelAdapters
+end # module CanCan
+
+DataMapper::Model.append_extensions(CanCan::ModelAdditions::ClassMethods)

data/lib/cancan/model_adapters/default_adapter.rb

@@ -0,0 +1,7 @@
+module CanCan
+  module ModelAdapters
+    class DefaultAdapter < AbstractAdapter
+      # This adapter is used when no matching adapter is found
+    end
+  end
+end

data/lib/cancan/model_adapters/mongoid_adapter.rb

@@ -0,0 +1,54 @@
+module CanCan
+  module ModelAdapters
+    class MongoidAdapter < AbstractAdapter
+      def self.for_class?(model_class)
+        model_class <= Mongoid::Document
+      end
+
+      def self.override_conditions_hash_matching?(subject, conditions)
+        conditions.any? do |k,v|
+          key_is_not_symbol = lambda { !k.kind_of?(Symbol) }
+          subject_value_is_array = lambda do
+            subject.respond_to?(k) && subject.send(k).is_a?(Array)
+          end
+
+          key_is_not_symbol.call || subject_value_is_array.call
+        end
+      end
+
+      def self.matches_conditions_hash?(subject, conditions)
+        # To avoid hitting the db, retrieve the raw Mongo selector from
+        # the Mongoid Criteria and use Mongoid::Matchers#matches?
+        subject.matches?( subject.class.where(conditions).selector )
+      end
+
+      def database_records
+        if @rules.size == 0
+          @model_class.where(:_id => {'$exists' => false, '$type' => 7}) # return no records in Mongoid
+        elsif @rules.size == 1 && @rules[0].conditions.is_a?(Mongoid::Criteria)
+          @rules[0].conditions
+        else
+          # we only need to process can rules if
+          # there are no rules with empty conditions
+          rules = @rules.reject { |rule| rule.conditions.empty? && rule.base_behavior }
+          process_can_rules = @rules.count == rules.count
+
+          rules.inject(@model_class.all) do |records, rule|
+            if process_can_rules && rule.base_behavior
+              records.or rule.conditions
+            elsif !rule.base_behavior
+              records.excludes rule.conditions
+            else
+              records
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# simplest way to add `accessible_by` to all Mongoid Documents
+module Mongoid::Document::ClassMethods
+  include CanCan::ModelAdditions::ClassMethods
+end

data/lib/cancan/model_additions.rb

@@ -0,0 +1,29 @@
+module CanCan
+
+  # This module adds the accessible_by class method to a model. It is included in the model adapters.
+  module ModelAdditions
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Returns a scope which fetches only the records that the passed ability
+      # can perform a given action on. The action defaults to :index. This
+      # 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.
+      def accessible_by(ability, action = :index)
+        ability.model_adapter(self, action).database_records
+      end
+    end
+  end
+end

data/lib/cancan/rule.rb

@@ -0,0 +1,178 @@
+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 Rule # :nodoc:
+    attr_reader :base_behavior, :subjects, :actions, :conditions
+    attr_writer :expanded_actions, :expanded_subjects
+
+    # 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 = nil, subject = nil, *extra_args, &block)
+      @match_all = action.nil? && subject.nil?
+      @base_behavior = base_behavior
+      @actions = [action].flatten
+      @subjects = [subject].flatten
+      @attributes = [extra_args.shift].flatten if extra_args.first.kind_of?(Symbol) || extra_args.first.kind_of?(Array) && extra_args.first.first.kind_of?(Symbol)
+      raise Error, "You are not able to supply a block with a hash of conditions in #{action} #{subject} ability. Use either one." if extra_args.first.kind_of?(Hash) && !block.nil?
+      @conditions = extra_args.first || {}
+      @block = block
+    end
+
+    # Matches the subject, action, and given attribute. Conditions are not checked here.
+    def relevant?(action, subject, attribute)
+      subject = subject.values.first if subject.class == Hash
+      @match_all || (matches_action?(action) && matches_subject?(subject) && matches_attribute?(attribute))
+    end
+
+    # Matches the block or conditions hash
+    def matches_conditions?(action, subject, attribute)
+      if @match_all
+        call_block_with_all(action, subject, attribute)
+      elsif @block && subject_object?(subject)
+        @block.arity == 1 ? @block.call(subject) : @block.call(subject, attribute)
+      elsif @conditions.kind_of?(Hash) && subject.class == Hash
+        nested_subject_matches_conditions?(subject)
+      elsif @conditions.kind_of?(Hash) && subject_object?(subject)
+        matches_conditions_hash?(subject)
+      else
+        # Don't stop at "cannot" definitions when there are conditions.
+        @conditions.empty? ? true : @base_behavior
+      end
+    end
+
+    def only_block?
+      !conditions? && !@block.nil?
+    end
+
+    def only_raw_sql?
+      @block.nil? && conditions? && !@conditions.kind_of?(Hash)
+    end
+
+    def attributes?
+      @attributes.present?
+    end
+
+    def conditions?
+      @conditions.present?
+    end
+
+    def instance_conditions?
+      @block || conditions?
+    end
+
+    def unmergeable?
+      @conditions.respond_to?(:keys) && (! @conditions.keys.first.kind_of? Symbol)
+    end
+
+    def associations_hash(conditions = @conditions)
+      hash = {}
+      conditions.map do |name, value|
+        hash[name] = associations_hash(value) if value.kind_of? Hash
+      end if conditions.kind_of? Hash
+      hash
+    end
+
+    def attributes_from_conditions
+      attributes = {}
+      @conditions.each do |key, value|
+        attributes[key] = value unless [Array, Range, Hash].include? value.class
+      end if @conditions.kind_of? Hash
+      attributes
+    end
+
+    def specificity
+      specificity = 1
+      specificity += 1 if attributes? || conditions?
+      specificity += 2 unless base_behavior
+      specificity
+    end
+
+    private
+
+    def subject_object?(subject)
+      # klass = (subject.kind_of?(Hash) ? subject.values.first : subject).class
+      # klass == Class || klass == Module
+      !subject.kind_of?(Symbol) && !subject.kind_of?(String)
+    end
+
+    def matches_action?(action)
+      @expanded_actions.include?(:access) || @expanded_actions.include?(action.to_sym)
+    end
+
+    def matches_subject?(subject)
+      subject = subject_name(subject) if subject_object? subject
+      @expanded_subjects.include?(:all) || @expanded_subjects.include?(subject.to_sym) || @expanded_subjects.include?(subject) # || matches_subject_class?(subject)
+    end
+
+    def matches_attribute?(attribute)
+      # don't consider attributes in a cannot clause when not matching - this can probably be refactored
+      if !@base_behavior && @attributes && attribute.nil?
+        false
+      else
+        @attributes.nil? || attribute.nil? || @attributes.include?(attribute.to_sym)
+      end
+    end
+
+    # TODO deperecate this
+    def matches_subject_class?(subject)
+      @expanded_subjects.any? { |sub| sub.kind_of?(Module) && (subject.kind_of?(sub) || subject.class.to_s == sub.to_s || subject.kind_of?(Module) && subject.ancestors.include?(sub)) }
+    end
+
+    # Checks if the given subject matches the given conditions hash.
+    # This behavior can be overriden by a model adapter by defining two class methods:
+    # override_matching_for_conditions?(subject, conditions) and
+    # matches_conditions_hash?(subject, conditions)
+    def matches_conditions_hash?(subject, conditions = @conditions)
+      if conditions.empty?
+        true
+      else
+        if model_adapter(subject).override_conditions_hash_matching? subject, conditions
+          model_adapter(subject).matches_conditions_hash? subject, conditions
+        else
+          conditions.all? do |name, value|
+            if model_adapter(subject).override_condition_matching? subject, name, value
+              model_adapter(subject).matches_condition? subject, name, value
+            else
+              attribute = subject.send(name)
+              if value.kind_of?(Hash)
+                if attribute.kind_of? Array
+                  attribute.any? { |element| matches_conditions_hash? element, value }
+                else
+                  attribute && matches_conditions_hash?(attribute, value)
+                end
+              elsif value.kind_of?(Enumerable)
+                value.include? attribute
+              else
+                attribute == value
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def nested_subject_matches_conditions?(subject_hash)
+      parent, child = subject_hash.first
+      matches_conditions_hash?(parent, @conditions[parent.class.name.downcase.to_sym] || {})
+    end
+
+    def call_block_with_all(action, subject, attribute)
+      if subject_object? subject
+        @block.call(action, subject_name(subject), subject, attribute)
+      else
+        @block.call(action, subject, nil, attribute)
+      end
+    end
+
+    def subject_name(subject)
+      subject.class.to_s.underscore.pluralize.to_sym
+    end
+
+    def model_adapter(subject)
+      CanCan::ModelAdapters::AbstractAdapter.adapter_class(subject_object?(subject) ? subject.class : subject)
+    end
+  end
+end

data/lib/generators/cancan/ability/USAGE

@@ -0,0 +1,5 @@
+Description:
+  The cancan:ability generator creates an Ability class in the models
+  directory. You can move this file anywhere you want as long as it
+  is in the load path. A test/spec file is also generated depending
+  on if a spec directory exists.

data/lib/generators/cancan/ability/ability_generator.rb

@@ -0,0 +1,16 @@
+module Cancan
+  module Generators
+    class AbilityGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      def generate_ability
+        copy_file "ability.rb", "app/models/ability.rb"
+        if File.exist?(File.join(destination_root, "spec"))
+          copy_file "ability_spec.rb", "spec/models/ability_spec.rb"
+        else
+          copy_file "ability_test.rb", "test/unit/ability_test.rb"
+        end
+      end
+    end
+  end
+end

data/lib/generators/cancan/ability/templates/ability.rb

@@ -0,0 +1,24 @@
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    # Define abilities for the passed in (current) user. For example:
+    #
+    #   if user
+    #     can :access, :all
+    #   else
+    #     can :access, :home
+    #     can :create, [:users, :sessions]
+    #   end
+    #
+    # Here if there is a user he will be able to perform any action on any controller.
+    # If someone is not logged in he can only access the home, users, and sessions controllers.
+    #
+    # The first argument to `can` is the action the user can perform. The second argument
+    # is the controller name they can perform that action on. You can pass :access and :all
+    # to represent any action and controller respectively. Passing an array to either of
+    # these will grant permission on each item in the array.
+    #
+    # See the wiki for details: https://github.com/ryanb/cancan/wiki/Defining-Abilities
+  end
+end

data/lib/generators/cancan/ability/templates/ability_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+require "cancan/matchers"
+
+describe Ability do
+  describe "as guest" do
+    before(:each) do
+      @ability = Ability.new(nil)
+    end
+
+    it "can only create a user" do
+      # Define what a guest can and cannot do
+      # @ability.should be_able_to(:create, :users)
+      # @ability.should_not be_able_to(:update, :users)
+    end
+  end
+end

data/lib/generators/cancan/ability/templates/ability_test.rb

@@ -0,0 +1,10 @@
+require "test_helper"
+
+class AbilityTest < ActiveSupport::TestCase
+  def guest_can_only_create_user
+    ability = Ability.new(nil)
+    # Define what a guest can and cannot do
+    # assert ability.can?(:create, :users)
+    # assert ability.cannot?(:update, :users)
+  end
+end

data/spec/README.rdoc

@@ -0,0 +1,28 @@
+= CanCan Specs
+
+== Running the specs
+
+To run the specs first run the +bundle+ command to install the necessary gems and the +rake+ command to run the specs.
+
+  bundle
+  rake
+
+The specs currently require Ruby 1.8.7. Ruby 1.9.2 support will be coming soon.
+
+
+== Model Adapters
+
+CanCan offers separate specs for different model adapters (such as Mongoid and Data Mapper). By default it will use Active Record but you can change this by setting the +MODEL_ADAPTER+ environment variable before running. You can run the +bundle+ command with this as well to ensure you have the installed gems.
+
+  MODEL_ADAPTER=data_mapper bundle
+  MODEL_ADAPTER=data_mapper rake
+
+The different model adapters you can specify are:
+
+* active_record (default)
+* data_mapper
+* mongoid
+
+You can also run the +spec_all+ rake task to run specs for each adapter.
+
+  rake spec_all

data/spec/cancan/ability_spec.rb

@@ -0,0 +1,541 @@
+require "spec_helper"
+
+describe CanCan::Ability do
+  before(:each) do
+    @ability = Object.new
+    @ability.extend(CanCan::Ability)
+  end
+
+
+  # Basic Action & Subject
+
+  it "allows access to only what is defined" do
+    @ability.can?(:paint, :fences).should be_false
+    @ability.can :paint, :fences
+    @ability.can?(:paint, :fences).should be_true
+    @ability.can?(:wax, :fences).should be_false
+    @ability.can?(:paint, :cars).should be_false
+  end
+
+  it "allows access to everything when :access, :all is used" do
+    @ability.can?(:paint, :fences).should be_false
+    @ability.can :access, :all
+    @ability.can?(:paint, :fences).should be_true
+    @ability.can?(:wax, :fences).should be_true
+    @ability.can?(:paint, :cars).should be_true
+  end
+
+  it "allows access to multiple actions and subjects" do
+    @ability.can [:paint, :sand], [:fences, :decks]
+    @ability.can?(:paint, :fences).should be_true
+    @ability.can?(:sand, :fences).should be_true
+    @ability.can?(:paint, :decks).should be_true
+    @ability.can?(:sand, :decks).should be_true
+    @ability.can?(:wax, :fences).should be_false
+    @ability.can?(:paint, :cars).should be_false
+  end
+
+  it "allows strings instead of symbols in ability check" do
+    @ability.can :paint, :fences
+    @ability.can?("paint", "fences").should be_true
+  end
+
+
+  # Aliases
+
+  it "has default index, show, new, update, delete aliases" do
+    @ability.can :read, :projects
+    @ability.can?(:index, :projects).should be_true
+    @ability.can?(:show, :projects).should be_true
+    @ability.can :create, :projects
+    @ability.can?(:new, :projects).should be_true
+    @ability.can :update, :projects
+    @ability.can?(:edit, :projects).should be_true
+    @ability.can :destroy, :projects
+    @ability.can?(:delete, :projects).should be_true
+  end
+
+  it "follows deep action aliases" do
+    @ability.alias_action :update, :destroy, :to => :modify
+    @ability.can :modify, :projects
+    @ability.can?(:update, :projects).should be_true
+    @ability.can?(:destroy, :projects).should be_true
+    @ability.can?(:edit, :projects).should be_true
+  end
+
+  it "adds up action aliases" do
+    @ability.alias_action :update, :to => :modify
+    @ability.alias_action :destroy, :to => :modify
+    @ability.can :modify, :projects
+    @ability.can?(:update, :projects).should be_true
+    @ability.can?(:destroy, :projects).should be_true
+  end
+
+  it "follows deep subject aliases" do
+    @ability.alias_subject :mammals, :to => :animals
+    @ability.alias_subject :cats, :to => :mammals
+    @ability.can :pet, :animals
+    @ability.can?(:pet, :mammals).should be_true
+  end
+
+  it "clears current and default aliases" do
+    @ability.alias_action :update, :destroy, :to => :modify
+    @ability.clear_aliases
+    @ability.can :modify, :projects
+    @ability.can?(:update, :projects).should be_false
+    @ability.can :read, :projects
+    @ability.can?(:show, :projects).should be_false
+  end
+
+
+  # Hash Conditions
+
+  it "maps object to pluralized subject name" do
+    @ability.can :read, :ranges
+    @ability.can?(:read, :ranges).should be_true
+    @ability.can?(:read, 1..3).should be_true
+    @ability.can?(:read, 123).should be_false
+  end
+
+  it "checks conditions hash on instances only" do
+    @ability.can :read, :ranges, :begin => 1
+    @ability.can?(:read, :ranges).should be_true
+    @ability.can?(:read, 1..3).should be_true
+    @ability.can?(:read, 2..4).should be_false
+  end
+
+  it "checks conditions on both rules and matches either one" do
+    @ability.can :read, :ranges, :begin => 1
+    @ability.can :read, :ranges, :begin => 2
+    @ability.can?(:read, 1..3).should be_true
+    @ability.can?(:read, 2..4).should be_true
+    @ability.can?(:read, 3..5).should be_false
+  end
+
+  it "checks an array of options in conditions hash" do
+    @ability.can :read, :ranges, :begin => [1, 3, 5]
+    @ability.can?(:read, 1..3).should be_true
+    @ability.can?(:read, 2..4).should be_false
+    @ability.can?(:read, 3..5).should be_true
+  end
+
+  it "checks a range of options in conditions hash" do
+    @ability.can :read, :ranges, :begin => 1..3
+    @ability.can?(:read, 1..10).should be_true
+    @ability.can?(:read, 3..30).should be_true
+    @ability.can?(:read, 4..40).should be_false
+  end
+
+  it "checks nested conditions hash" do
+    @ability.can :read, :ranges, :begin => { :to_i => 5 }
+    @ability.can?(:read, 5..7).should be_true
+    @ability.can?(:read, 6..8).should be_false
+  end
+
+  it "matches any element passed in to nesting if it's an array (for has_many associations)" do
+    @ability.can :read, :ranges, :to_a => { :to_i => 3 }
+    @ability.can?(:read, 1..5).should be_true
+    @ability.can?(:read, 4..6).should be_false
+  end
+
+  it "takes presedence over rule defined without a condition" do
+    @ability.can :read, :ranges
+    @ability.can :read, :ranges, :begin => 1
+    @ability.can?(:read, 1..5).should be_true
+    @ability.can?(:read, 4..6).should be_false
+  end
+
+
+  # Block Conditions
+
+  it "executes block passing object only when instance is used" do
+    @ability.can :read, :ranges do |range|
+      range.begin == 5
+    end
+    @ability.can?(:read, :ranges).should be_true
+    @ability.can?(:read, 5..7).should be_true
+    @ability.can?(:read, 6..8).should be_false
+  end
+
+  it "returns true when other object is returned in block" do
+    @ability.can :read, :ranges do |range|
+      "foo"
+    end
+    @ability.can?(:read, 5..7).should be_true
+  end
+
+  it "passes to previous rule when block returns false" do
+    @ability.can :read, :fixnums do |i|
+      i < 5
+    end
+    @ability.can :read, :fixnums do |i|
+      i > 10
+    end
+    @ability.can?(:read, 11).should be_true
+    @ability.can?(:read, 1).should be_true
+    @ability.can?(:read, 6).should be_false
+  end
+
+  it "calls block passing arguments when no arguments are given to can" do
+    @ability.can do |action, subject, object|
+      action.should == :read
+      subject.should == :ranges
+      object.should == (2..4)
+      @block_called = true
+    end
+    @ability.can?(:read, 2..4)
+    @block_called.should be_true
+  end
+
+  it "raises an error when attempting to use a block with a hash condition since it's not likely what they want" do
+    lambda {
+      @ability.can :read, :ranges, :published => true do
+        false
+      end
+    }.should raise_error(CanCan::Error, "You are not able to supply a block with a hash of conditions in read ranges ability. Use either one.")
+  end
+
+  it "does not raise an error when attempting to use a block with an array of SQL conditions" do
+    lambda {
+      @ability.can :read, :ranges, ["published = ?", true] do
+        false
+      end
+    }.should_not raise_error(CanCan::Error)
+  end
+
+
+  # Attributes
+
+  it "allows permission on attributes" do
+    @ability.can :update, :users, :name
+    @ability.can :update, :users, [:email, :age]
+    @ability.can?(:update, :users, :name).should be_true
+    @ability.can?(:update, :users, :email).should be_true
+    @ability.can?(:update, :users, :password).should be_false
+  end
+
+  it "allows permission on all attributes when none are given" do
+    @ability.can :update, :users
+    @ability.can?(:update, :users, :password).should be_true
+  end
+
+  it "allows strings when chekcing attributes" do
+    @ability.can :update, :users, :name
+    @ability.can?(:update, :users, "name").should be_true
+  end
+
+  it "combines attribute check with conditions hash" do
+    @ability.can :update, :ranges, :begin => 1
+    @ability.can :update, :ranges, :name, :begin => 2
+    @ability.can?(:update, 1..3, :foobar).should be_true
+    @ability.can?(:update, 2..4, :foobar).should be_false
+    @ability.can?(:update, 2..4, :name).should be_true
+    @ability.can?(:update, 3..5, :name).should be_false
+  end
+
+  it "passes attribute to block and nil if no attribute checked" do
+    @ability.can :update, :ranges do |range, attribute|
+      attribute == :name
+    end
+    @ability.can?(:update, 1..3, :name).should be_true
+    @ability.can?(:update, 2..4).should be_false
+  end
+
+  it "passes attribute to block for global can definition" do
+    @ability.can do |action, subject, object, attribute|
+      attribute == :name
+    end
+    @ability.can?(:update, 1..3, :name).should be_true
+    @ability.can?(:update, 2..4).should be_false
+  end
+
+
+  # Checking if Fully Authorized
+
+  it "is not fully authorized when no authorize! call is made" do
+    @ability.can :update, :ranges, :begin => 1
+    @ability.can?(:update, :ranges).should be_true
+    @ability.should_not be_fully_authorized(:update, :ranges)
+  end
+
+  it "is fully authorized when calling authorize! with a matching action and subject" do
+    @ability.can :update, :ranges
+    @ability.authorize! :update, :ranges
+    @ability.should be_fully_authorized(:update, :ranges)
+    @ability.should_not be_fully_authorized(:create, :ranges)
+  end
+
+  it "is fully authorized when marking action and subject as such" do
+    @ability.fully_authorized! :update, :ranges
+    @ability.should be_fully_authorized(:update, :ranges)
+  end
+
+  it "is not fully authorized when a conditions hash exists but no instance is used" do
+    @ability.can :update, :ranges, :begin => 1
+    @ability.authorize! :update, :ranges
+    @ability.should_not be_fully_authorized(:update, :ranges)
+    @ability.authorize! "update", "ranges"
+    @ability.should_not be_fully_authorized(:update, :ranges)
+    @ability.authorize! :update, 1..3
+    @ability.should be_fully_authorized(:update, :ranges)
+  end
+
+  it "is not fully authorized when a block exists but no instance is used" do
+    @ability.can :update, :ranges do |range|
+      range.begin == 1
+    end
+    @ability.authorize! :update, :ranges
+    @ability.should_not be_fully_authorized(:update, :ranges)
+    @ability.authorize! :update, 1..3
+    @ability.should be_fully_authorized(:update, :ranges)
+  end
+
+  it "should accept a set as a condition value" do
+    object_with_foo_2 = Object.new
+    object_with_foo_2.should_receive(:foo) { 2 }
+    object_with_foo_3 = Object.new
+    object_with_foo_3.should_receive(:foo) { 3 }
+    @ability.can :read, :objects, :foo => [1, 2, 5].to_set
+    @ability.can?(:read, object_with_foo_2).should be_true
+    @ability.can?(:read, object_with_foo_3).should be_false
+  end
+
+  it "does not match subjects return nil for methods that must match nested a nested conditions hash" do
+    object_with_foo = Object.new
+    object_with_foo.should_receive(:foo) { :bar }
+    @ability.can :read, :arrays, :first => { :foo => :bar }
+    @ability.can?(:read, [object_with_foo]).should be_true
+    @ability.can?(:read, []).should be_false
+  end
+
+  it "is not fully authorized when attributes are required but not checked in update/create actions" do
+    @ability.can :access, :users, :name
+    @ability.authorize! :update, :users
+    @ability.should_not be_fully_authorized(:update, :users)
+    @ability.authorize! :create, :users
+    @ability.should_not be_fully_authorized(:create, :users)
+    @ability.authorize! :create, :users, :name
+    @ability.should be_fully_authorized(:create, :users)
+    @ability.authorize! :destroy, :users
+    @ability.should be_fully_authorized(:destroy, :users)
+  end
+
+  it "marks as fully authorized when authorizing with strings instead of symbols" do
+    @ability.fully_authorized! "update", "ranges"
+    @ability.should be_fully_authorized(:update, :ranges)
+    @ability.should be_fully_authorized("update", "ranges")
+    @ability.can :update, :users
+    @ability.authorize! "update", "users"
+    @ability.should be_fully_authorized(:update, :users)
+  end
+
+
+  # Cannot
+
+  it "offers cannot? method which inverts can?" do
+    @ability.cannot?(:wax, :cars).should be_true
+  end
+
+  it "supports 'cannot' method to define what user cannot do" do
+    @ability.can :read, :all
+    @ability.cannot :read, :ranges
+    @ability.can?(:read, :books).should be_true
+    @ability.can?(:read, 1..3).should be_false
+    @ability.can?(:read, :ranges).should be_false
+  end
+
+  it "passes to previous rule if cannot check returns false" do
+    @ability.can :read, :all
+    @ability.cannot :read, :ranges, :begin => 3
+    @ability.cannot :read, :ranges do |range|
+      range.begin == 5
+    end
+    @ability.can?(:read, :books).should be_true
+    @ability.can?(:read, 2..4).should be_true
+    @ability.can?(:read, 3..7).should be_false
+    @ability.can?(:read, 5..9).should be_false
+  end
+
+  it "rejects permission only to a given attribute" do
+    @ability.can :update, :books
+    @ability.cannot :update, :books, :author
+    @ability.can?(:update, :books).should be_true
+    @ability.can?(:update, :books, :author).should be_false
+  end
+
+  # Hash Association
+
+  it "checks permission through association when hash is passed as subject" do
+    @ability.can :read, :books, :range => {:begin => 3}
+    @ability.can?(:read, (1..4) => :books).should be_false
+    @ability.can?(:read, (3..5) => :books).should be_true
+    @ability.can?(:read, 123 => :books).should be_true
+  end
+
+  it "checks permissions on association hash with multiple rules" do
+    @ability.can :read, :books, :range => {:begin => 3}
+    @ability.can :read, :books, :range => {:end => 6}
+    @ability.can?(:read, (1..4) => :books).should be_false
+    @ability.can?(:read, (3..5) => :books).should be_true
+    @ability.can?(:read, (1..6) => :books).should be_true
+    @ability.can?(:read, 123 => :books).should be_true
+  end
+
+  it "checks ability on hash subclass" do
+    class Container < Hash; end
+    @ability.can :read, :containers
+    @ability.can?(:read, Container.new).should be_true
+  end
+
+
+  # Initial Attributes
+
+  it "has initial attributes based on hash conditions for a given action" do
+    @ability.can :access, :ranges, :foo => "foo", :hash => {:skip => "hashes"}
+    @ability.can :create, :ranges, :bar => 123, :array => %w[skip arrays]
+    @ability.can :new, :ranges, :baz => "baz", :range => 1..3
+    @ability.cannot :new, :ranges, :ignore => "me"
+    @ability.attributes_for(:new, :ranges).should == {:foo => "foo", :bar => 123, :baz => "baz"}
+  end
+
+
+  # Unauthorized Exception
+
+  it "raises CanCan::Unauthorized when calling authorize! on unauthorized action" do
+    begin
+      @ability.authorize! :read, :books, :message => "Access denied!"
+    rescue CanCan::Unauthorized => e
+      e.message.should == "Access denied!"
+      e.action.should == :read
+      e.subject.should == :books
+    else
+      fail "Expected CanCan::Unauthorized exception to be raised"
+    end
+  end
+
+  it "does not raise access denied exception if ability is authorized to perform an action and return subject" do
+    @ability.can :read, :foo
+    lambda {
+      @ability.authorize!(:read, :foo).should == :foo
+    }.should_not raise_error
+  end
+
+  it "knows when block is used in conditions" do
+    @ability.can :read, :foo
+    @ability.should_not have_block(:read, :foo)
+    @ability.can :read, :foo do |foo|
+      false
+    end
+    @ability.should have_block(:read, :foo)
+  end
+
+  it "knows when raw sql is used in conditions" do
+    @ability.can :read, :foo
+    @ability.should_not have_raw_sql(:read, :foo)
+    @ability.can :read, :foo, 'false'
+    @ability.should have_raw_sql(:read, :foo)
+  end
+
+  it "raises access denied exception with default message if not specified" do
+    begin
+      @ability.authorize! :read, :books
+    rescue CanCan::Unauthorized => e
+      e.default_message = "Access denied!"
+      e.message.should == "Access denied!"
+    else
+      fail "Expected CanCan::Unauthorized exception to be raised"
+    end
+  end
+
+  it "does not raise access denied exception if ability is authorized to perform an action and return subject" do
+    @ability.can :read, :books
+    lambda {
+      @ability.authorize!(:read, :books).should == :books
+    }.should_not raise_error
+  end
+
+
+  # Determining Kind of Conditions
+
+  it "knows when a block is used for conditions" do
+    @ability.can :read, :books
+    @ability.should_not have_block(:read, :books)
+    @ability.can :read, :books do |foo|
+      false
+    end
+    @ability.should have_block(:read, :books)
+  end
+
+  it "knows when raw sql is used for conditions" do
+    @ability.can :read, :books
+    @ability.should_not have_raw_sql(:read, :books)
+    @ability.can :read, :books, 'false'
+    @ability.should have_raw_sql(:read, :books)
+  end
+
+  it "determines model adapter class by asking AbstractAdapter" do
+    model_class = Object.new
+    adapter_class = Object.new
+    CanCan::ModelAdapters::AbstractAdapter.stub(:adapter_class).with(model_class) { adapter_class }
+    adapter_class.stub(:new).with(model_class, []) { :adapter_instance }
+    @ability.model_adapter(model_class, :read).should == :adapter_instance
+  end
+
+
+  # Unauthorized I18n Message
+
+  describe "unauthorized message" do
+    after(:each) do
+      I18n.backend = nil
+    end
+
+    it "uses action/subject in i18n" do
+      I18n.backend.store_translations :en, :unauthorized => {:update => {:ranges => "update ranges"}}
+      @ability.unauthorized_message(:update, :ranges).should == "update ranges"
+      @ability.unauthorized_message(:update, 2..4).should == "update ranges"
+      @ability.unauthorized_message(:update, :missing).should be_nil
+    end
+
+    it "uses symbol as subject directly" do
+      I18n.backend.store_translations :en, :unauthorized => {:has => {:cheezburger => "Nom nom nom. I eated it."}}
+      @ability.unauthorized_message(:has, :cheezburger).should == "Nom nom nom. I eated it."
+    end
+
+    it "falls back to 'access' and 'all'" do
+      I18n.backend.store_translations :en, :unauthorized => {
+        :access => {:all => "access all", :ranges => "access ranges"},
+        :update => {:all => "update all", :ranges => "update ranges"}
+      }
+      @ability.unauthorized_message(:update, :ranges).should == "update ranges"
+      @ability.unauthorized_message(:update, :hashes).should == "update all"
+      @ability.unauthorized_message(:create, :ranges).should == "access ranges"
+      @ability.unauthorized_message(:create, :hashes).should == "access all"
+    end
+
+    it "follows aliases" do
+      I18n.backend.store_translations :en, :unauthorized => {:modify => {:ranges => "modify ranges"}}
+      @ability.alias_action :update, :to => :modify
+      @ability.alias_subject :areas, :to => :ranges
+      @ability.unauthorized_message(:update, :areas).should == "modify ranges"
+      @ability.unauthorized_message(:edit, :ranges).should == "modify ranges"
+    end
+
+    it "has variables for action and subject" do
+      I18n.backend.store_translations :en, :unauthorized => {:access => {:all => "%{action} %{subject}"}} # old syntax for now in case testing with old I18n
+      @ability.unauthorized_message(:update, :ranges).should == "update ranges"
+      @ability.unauthorized_message(:edit, 1..3).should == "edit ranges"
+      # @ability.unauthorized_message(:update, ArgumentError).should == "update argument error"
+    end
+  end
+
+  it "merges the rules from another ability" do
+    @ability.can :use, :tools
+    another_ability = Object.new
+    another_ability.extend(CanCan::Ability)
+    another_ability.can :use, :search
+
+    @ability.merge(another_ability)
+    @ability.can?(:use, :search).should be_true
+    @ability.send(:rules).size.should == 2
+  end
+end