cancancan 1.8.0 → 1.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7079b16052c2f98ebe67d6ce08e390188bca856d
-  data.tar.gz: faa43141ca3124dbe3d40ceb30a76ca78bc56117
+  metadata.gz: 819e93ed0b90294960a5cf198d9b2b706bb92102
+  data.tar.gz: d172cc5b2b9a84c5c16a984bf4f7a736b7972a56
 SHA512:
-  metadata.gz: 8168024035574501d8bef61033f458facb1b7173ed98d901b9b51aedc0c659470f6210beb308273de9cd437e4d75027eb39321f104a9e8dc8f933593f1a67aa1
-  data.tar.gz: e71e7aa4f2a66f0f660aa9ce224dff3c0de2efc3b0fb85d461113175e5349700bf4475f5f9ca7abf16c56457488a33b3b5d954e753b021f162428c5827e28cd5
+  metadata.gz: 0561f92075412910012056ba8de57554d093bf19d8b4d8453a79b322e46fac3a5cd55683312505afd85c6d910fd55ca6ea787f1db1f57d4debd8e91e89adefce
+  data.tar.gz: e241a95106dd3ee46df19a7808368fbcfb970798e8e87bc0836e4f88df3b032a4f1462e698b0a739ff57ff37b90661c598bc96ebf89f824bc025dc68e09070c0

data/Appraisals

@@ -64,7 +64,6 @@ appraise "sequel_3.x" do
   gem 'activesupport', '~> 3.0', :require => 'active_support/all'
 
   gemfile.platforms :jruby do
-    gem "activerecord-jdbcsqlite3-adapter"
     gem "jdbc-sqlite3"
   end
 

data/CHANGELOG.rdoc

@@ -1,6 +1,28 @@
 Develop
 
 
+1.8.4 (June 24th, 2014)
+
+* Fix cancancan#86 - Fixes previous RSpec 3 update as there was a bug in the fix for RSpec 2.99. (bryanrite)
+
+
+1.8.3 (June 24th, 2014)
+
+* Fix cancancan#85 - Remove deprecation notices for RSpec 3 and continue backwards compatibility. (andypike, bryanrite, porteta)
+
+
+1.8.2 (June 5th, 2014)
+
+* Fix cancancan#75 - More specific hash-like object check. (bryanrite)
+
+
+1.8.1 (May 27th, 2014)
+
+* Fix cancancan#67 - Sequel tests are run properly for JRuby. (bryanrite)
+
+* Fix cancancan#68 - Checks for hash-like objects in subject better. (bryanrite)
+
+
 1.8.0 (May 8th, 2014)
 
 * Feature cancan#884 - Add a Sequel model adapter (szetobo)

data/README.rdoc

@@ -2,7 +2,7 @@
 {<img src="https://badge.fury.io/rb/cancancan.png" alt="Gem Version" />}[http://badge.fury.io/rb/cancancan]
 {<img src="https://travis-ci.org/CanCanCommunity/cancancan.png?branch=master" alt="Build Status" />}[https://travis-ci.org/CanCanCommunity/cancancan]
 {<img src="https://codeclimate.com/github/CanCanCommunity/cancancan.png" />}[https://codeclimate.com/github/CanCanCommunity/cancancan]
-{<img src="http://inch-pages.github.io/github/CanCanCommunity/cancancan.png" alt="Inline docs" />}[http://inch-pages.github.io/github/CanCanCommunity/cancancan]
+{<img src="http://inch-ci.org/github/CanCanCommunity/cancancan.png" alt="Inline docs" />}[http://inch-ci.org/github/CanCanCommunity/cancancan]
 
 Wiki[https://github.com/bryanrite/cancancan/wiki] | RDocs[http://rdoc.info/projects/ryanb/cancan] | Screencast[http://railscasts.com/episodes/192-authorization-with-cancan]
 
@@ -173,7 +173,7 @@ Cancancan uses {appraisals}[https://github.com/thoughtbot/appraisal] to test the
 
 When first developing, you may need to run <tt>bundle install</tt> and then <tt>appraisal install</tt>, to install the different sets.
 
-You can then run all appraisal files (like CI does), with <tt>appraisal rake</tt> or just run a specific set <tt>appraisal rails_3.0 rake</tt>.
+You can then run all appraisal files (like CI does), with <tt>appraisal rake</tt> or just run a specific set <tt>appraisal activerecord_3.0 rake</tt>.
 
 See the {CONTRIBUTING}[https://github.com/CanCanCommunity/cancancan/blob/develop/CONTRIBUTING.md] and {spec/README}[https://github.com/bryanrite/cancancan/blob/master/spec/README.rdoc] for more information.
 

data/cancancan.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'bundler', '~> 1.3'
   s.add_development_dependency 'rake', '~> 10.1.1'
-  s.add_development_dependency 'rspec', '~> 2.14'
+  s.add_development_dependency 'rspec', '~> 3.0.0'
   s.add_development_dependency 'appraisal', '>= 1.0.0'
 
   s.rubyforge_project = s.name

data/gemfiles/sequel_3.x.gemfile

@@ -6,7 +6,6 @@ gem "sequel", "~> 3.47.0"
 gem "activesupport", "~> 3.0", :require => "active_support/all"
 
 platforms :jruby do
-  gem "activerecord-jdbcsqlite3-adapter"
   gem "jdbc-sqlite3"
 end
 

data/lib/cancan/ability.rb

@@ -285,7 +285,7 @@ module CanCan
 
     # It translates to an array the subject or the hash with multiple subjects given to can?.
     def extract_subjects(subject)
-      subject = if subject.respond_to?(:keys) && subject.key?(:any)
+      subject = if subject.kind_of?(Hash) && subject.key?(:any)
         subject[:any]
       else
         [subject]

data/lib/cancan/matchers.rb

@@ -4,7 +4,7 @@ if rspec_module == 'RSpec'
   require 'rspec/core'
   require 'rspec/expectations'
 else
-  ActiveSupport::Deprecation.warn("RSpec v1 will not be supported in the CanCanCan >= 2.0.0")
+  ActiveSupport::Deprecation.warn("RSpec < 3 will not be supported in the CanCanCan >= 2.0.0")
 end
 
 Kernel.const_get(rspec_module)::Matchers.define :be_able_to do |*args|
@@ -12,11 +12,17 @@ Kernel.const_get(rspec_module)::Matchers.define :be_able_to do |*args|
     ability.can?(*args)
   end
 
-  failure_message_for_should do |ability|
+  # Check that RSpec is < 2.99
+  if !respond_to?(:failure_message) && respond_to?(:failure_message_for_should)
+    alias :failure_message :failure_message_for_should
+    alias :failure_message_when_negated :failure_message_for_should_not
+  end
+
+  failure_message do |ability|
     "expected to be able to #{args.map(&:inspect).join(" ")}"
   end
 
-  failure_message_for_should_not do |ability|
+  failure_message_when_negated do |ability|
     "expected not to be able to #{args.map(&:inspect).join(" ")}"
   end
 end

data/lib/cancan/version.rb

@@ -1,3 +1,3 @@
 module CanCan
-  VERSION = "1.8.0"
+  VERSION = "1.8.4"
 end

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

@@ -27,6 +27,6 @@ class Ability
     #   can :update, Article, :published => true
     #
     # See the wiki for details:
-    # https://github.com/bryanrite/cancancan/wiki/Defining-Abilities
+    # https://github.com/CanCanCommunity/cancancan/wiki/Defining-Abilities
   end
 end

data/spec/cancan/ability_spec.rb

@@ -7,12 +7,12 @@ describe CanCan::Ability do
 
   it "is able to :read anything" do
     @ability.can :read, :all
-    expect(@ability.can?(:read, String)).to be_true
-    expect(@ability.can?(:read, 123)).to be_true
+    expect(@ability.can?(:read, String)).to be(true)
+    expect(@ability.can?(:read, 123)).to be(true)
   end
 
   it "does not have permission to do something it doesn't know about" do
-    expect(@ability.can?(:foodfight, String)).to be_false
+    expect(@ability.can?(:foodfight, String)).to be(false)
   end
 
   it "passes true to `can?` when non false/nil is returned in block" do
@@ -20,7 +20,7 @@ describe CanCan::Ability do
     @ability.can :read, Symbol do |sym|
       "foo" # TODO test that sym is nil when no instance is passed
     end
-    expect(@ability.can?(:read, :some_symbol)).to be_true
+    expect(@ability.can?(:read, :some_symbol)).to be(true)
   end
 
   it "passes nil to a block when no instance is passed" do
@@ -28,7 +28,7 @@ describe CanCan::Ability do
       expect(sym).to be_nil
       true
     end
-    expect(@ability.can?(:read, Symbol)).to be_true
+    expect(@ability.can?(:read, Symbol)).to be(true)
   end
 
   it "passes to previous rule, if block returns false or nil" do
@@ -39,10 +39,10 @@ describe CanCan::Ability do
     @ability.can :read, Integer do |i|
       i > 10
     end
-    expect(@ability.can?(:read, Symbol)).to be_true
-    expect(@ability.can?(:read, 11)).to be_true
-    expect(@ability.can?(:read, 1)).to be_true
-    expect(@ability.can?(:read, 6)).to be_false
+    expect(@ability.can?(:read, Symbol)).to be(true)
+    expect(@ability.can?(:read, 11)).to be(true)
+    expect(@ability.can?(:read, 1)).to be(true)
+    expect(@ability.can?(:read, 6)).to be(false)
   end
 
   it "does not pass class with object if :all objects are accepted" do
@@ -51,7 +51,7 @@ describe CanCan::Ability do
       @block_called = true
     end
     @ability.can?(:preview, 123)
-    expect(@block_called).to be_true
+    expect(@block_called).to be(true)
   end
 
   it "does not call block when only class is passed, only return true" do
@@ -59,8 +59,8 @@ describe CanCan::Ability do
     @ability.can :preview, :all do |object|
       @block_called = true
     end
-    expect(@ability.can?(:preview, Hash)).to be_true
-    expect(@block_called).to be_false
+    expect(@ability.can?(:preview, Hash)).to be(true)
+    expect(@block_called).to be(false)
   end
 
   it "passes only object for global manage actions" do
@@ -68,22 +68,22 @@ describe CanCan::Ability do
       expect(object).to eq("foo")
       @block_called = true
     end
-    expect(@ability.can?(:stuff, "foo")).to be_true
-    expect(@block_called).to be_true
+    expect(@ability.can?(:stuff, "foo")).to be(true)
+    expect(@block_called).to be(true)
   end
 
   it "makes alias for update or destroy actions to modify action" do
     @ability.alias_action :update, :destroy, :to => :modify
     @ability.can :modify, :all
-    expect(@ability.can?(:update, 123)).to be_true
-    expect(@ability.can?(:destroy, 123)).to be_true
+    expect(@ability.can?(:update, 123)).to be(true)
+    expect(@ability.can?(:destroy, 123)).to be(true)
   end
 
   it "allows deeply nested aliased actions" do
     @ability.alias_action :increment, :to => :sort
     @ability.alias_action :sort, :to => :modify
     @ability.can :modify, :all
-    expect(@ability.can?(:increment, 123)).to be_true
+    expect(@ability.can?(:increment, 123)).to be(true)
   end
 
   it "raises an Error if alias target is an exist action" do
@@ -98,7 +98,7 @@ describe CanCan::Ability do
       @block_called = true
     end
     @ability.can?(:foo, 123)
-    expect(@block_called).to be_true
+    expect(@block_called).to be(true)
   end
 
   it "passes nil to object when comparing class with can check" do
@@ -109,20 +109,20 @@ describe CanCan::Ability do
       @block_called = true
     end
     @ability.can?(:foo, Hash)
-    expect(@block_called).to be_true
+    expect(@block_called).to be(true)
   end
 
   it "automatically makes alias for index and show into read calls" do
     @ability.can :read, :all
-    expect(@ability.can?(:index, 123)).to be_true
-    expect(@ability.can?(:show, 123)).to be_true
+    expect(@ability.can?(:index, 123)).to be(true)
+    expect(@ability.can?(:show, 123)).to be(true)
   end
 
   it "automatically makes alias for new and edit into create and update respectively" do
     @ability.can :create, :all
     @ability.can :update, :all
-    expect(@ability.can?(:new, 123)).to be_true
-    expect(@ability.can?(:edit, 123)).to be_true
+    expect(@ability.can?(:new, 123)).to be(true)
+    expect(@ability.can?(:edit, 123)).to be(true)
   end
 
   it "does not respond to prepare (now using initialize)" do
@@ -130,56 +130,56 @@ describe CanCan::Ability do
   end
 
   it "offers cannot? method which is simply invert of can?" do
-    expect(@ability.cannot?(:tie, String)).to be_true
+    expect(@ability.cannot?(:tie, String)).to be(true)
   end
 
   it "is able to specify multiple actions and match any" do
     @ability.can [:read, :update], :all
-    expect(@ability.can?(:read, 123)).to be_true
-    expect(@ability.can?(:update, 123)).to be_true
-    expect(@ability.can?(:count, 123)).to be_false
+    expect(@ability.can?(:read, 123)).to be(true)
+    expect(@ability.can?(:update, 123)).to be(true)
+    expect(@ability.can?(:count, 123)).to be(false)
   end
 
   it "is able to specify multiple classes and match any" do
     @ability.can :update, [String, Range]
-    expect(@ability.can?(:update, "foo")).to be_true
-    expect(@ability.can?(:update, 1..3)).to be_true
-    expect(@ability.can?(:update, 123)).to be_false
+    expect(@ability.can?(:update, "foo")).to be(true)
+    expect(@ability.can?(:update, 1..3)).to be(true)
+    expect(@ability.can?(:update, 123)).to be(false)
   end
 
   it "checks if there is a permission for any of given subjects" do
     @ability.can :update, [String, Range]
-    expect(@ability.can?(:update, {:any => ["foo", 1..3]})).to be_true
-    expect(@ability.can?(:update, {:any => [1..3, "foo"]})).to be_true
-    expect(@ability.can?(:update, {:any => [123, "foo"]})).to be_true
-    expect(@ability.can?(:update, {:any => [123, 1.0]})).to be_false
+    expect(@ability.can?(:update, {:any => ["foo", 1..3]})).to be(true)
+    expect(@ability.can?(:update, {:any => [1..3, "foo"]})).to be(true)
+    expect(@ability.can?(:update, {:any => [123, "foo"]})).to be(true)
+    expect(@ability.can?(:update, {:any => [123, 1.0]})).to be(false)
   end
 
   it "supports custom objects in the rule" do
     @ability.can :read, :stats
-    expect(@ability.can?(:read, :stats)).to be_true
-    expect(@ability.can?(:update, :stats)).to be_false
-    expect(@ability.can?(:read, :nonstats)).to be_false
-    expect(@ability.can?(:read, {:any => [:stats, :nonstats]})).to be_true
-    expect(@ability.can?(:read, {:any => [:nonstats, :neitherstats]})).to be_false
+    expect(@ability.can?(:read, :stats)).to be(true)
+    expect(@ability.can?(:update, :stats)).to be(false)
+    expect(@ability.can?(:read, :nonstats)).to be(false)
+    expect(@ability.can?(:read, {:any => [:stats, :nonstats]})).to be(true)
+    expect(@ability.can?(:read, {:any => [:nonstats, :neitherstats]})).to be(false)
   end
 
   it "checks ancestors of class" do
     @ability.can :read, Numeric
-    expect(@ability.can?(:read, Integer)).to be_true
-    expect(@ability.can?(:read, 1.23)).to be_true
-    expect(@ability.can?(:read, "foo")).to be_false
-    expect(@ability.can?(:read, {:any => [Integer, String]})).to be_true
+    expect(@ability.can?(:read, Integer)).to be(true)
+    expect(@ability.can?(:read, 1.23)).to be(true)
+    expect(@ability.can?(:read, "foo")).to be(false)
+    expect(@ability.can?(:read, {:any => [Integer, String]})).to be(true)
   end
 
   it "supports 'cannot' method to define what user cannot do" do
     @ability.can :read, :all
     @ability.cannot :read, Integer
-    expect(@ability.can?(:read, "foo")).to be_true
-    expect(@ability.can?(:read, 123)).to be_false
-    expect(@ability.can?(:read, {:any => ["foo", "bar"]})).to be_true
-    expect(@ability.can?(:read, {:any => [123, "foo"]})).to be_false
-    expect(@ability.can?(:read, {:any => [123, 456]})).to be_false
+    expect(@ability.can?(:read, "foo")).to be(true)
+    expect(@ability.can?(:read, 123)).to be(false)
+    expect(@ability.can?(:read, {:any => ["foo", "bar"]})).to be(true)
+    expect(@ability.can?(:read, {:any => [123, "foo"]})).to be(false)
+    expect(@ability.can?(:read, {:any => [123, 456]})).to be(false)
   end
 
   it "passes to previous rule, if block returns false or nil" do
@@ -187,22 +187,23 @@ describe CanCan::Ability do
     @ability.cannot :read, Integer do |int|
       int > 10 ? nil : ( int > 5 )
     end
-    expect(@ability.can?(:read, "foo")).to be_true
-    expect(@ability.can?(:read, 3)).to be_true
-    expect(@ability.can?(:read, 8)).to be_false
-    expect(@ability.can?(:read, 123)).to be_true
-    expect(@ability.can?(:read, {:any => [123, 8]})).to be_true
-    expect(@ability.can?(:read, {:any => [8, 9]})).to be_false
+
+    expect(@ability.can?(:read, "foo")).to be(true)
+    expect(@ability.can?(:read, 3)).to be(true)
+    expect(@ability.can?(:read, 8)).to be(false)
+    expect(@ability.can?(:read, 123)).to be(true)
+    expect(@ability.can?(:read, {:any => [123, 8]})).to be(true)
+    expect(@ability.can?(:read, {:any => [8, 9]})).to be(false)
   end
 
   it "always returns `false` for single cannot definition" do
     @ability.cannot :read, Integer do |int|
       int > 10 ? nil : ( int > 5 )
     end
-    expect(@ability.can?(:read, "foo")).to be_false
-    expect(@ability.can?(:read, 3)).to be_false
-    expect(@ability.can?(:read, 8)).to be_false
-    expect(@ability.can?(:read, 123)).to be_false
+    expect(@ability.can?(:read, "foo")).to be(false)
+    expect(@ability.can?(:read, 3)).to be(false)
+    expect(@ability.can?(:read, 8)).to be(false)
+    expect(@ability.can?(:read, 123)).to be(false)
   end
 
   it "passes to previous cannot definition, if block returns false or nil" do
@@ -210,10 +211,10 @@ describe CanCan::Ability do
     @ability.can :read, Integer do |int|
       int > 10 ? nil : ( int > 5 )
     end
-    expect(@ability.can?(:read, "foo")).to be_false
-    expect(@ability.can?(:read, 3)).to be_false
-    expect(@ability.can?(:read, 10)).to be_true
-    expect(@ability.can?(:read, 123)).to be_false
+    expect(@ability.can?(:read, "foo")).to be(false)
+    expect(@ability.can?(:read, 3)).to be(false)
+    expect(@ability.can?(:read, 10)).to be(true)
+    expect(@ability.can?(:read, 123)).to be(false)
   end
 
   it "appends aliased actions" do
@@ -232,91 +233,94 @@ describe CanCan::Ability do
     @ability.can :read, Integer do |int, x|
       int > x
     end
-    expect(@ability.can?(:read, 2, 1)).to be_true
-    expect(@ability.can?(:read, 2, 3)).to be_false
-    expect(@ability.can?(:read, {:any => [4, 5]}, 3)).to be_true
-    expect(@ability.can?(:read, {:any => [2, 3]}, 3)).to be_false
+
+    expect(@ability.can?(:read, 2, 1)).to be(true)
+    expect(@ability.can?(:read, 2, 3)).to be(false)
+    expect(@ability.can?(:read, {:any => [4, 5]}, 3)).to be(true)
+    expect(@ability.can?(:read, {:any => [2, 3]}, 3)).to be(false)
   end
 
   it "uses conditions as third parameter and determine abilities from it" do
     @ability.can :read, Range, :begin => 1, :end => 3
-    expect(@ability.can?(:read, 1..3)).to be_true
-    expect(@ability.can?(:read, 1..4)).to be_false
-    expect(@ability.can?(:read, Range)).to be_true
-    expect(@ability.can?(:read, {:any => [1..3, 1..4]})).to be_true
-    expect(@ability.can?(:read, {:any => [1..4, 2..4]})).to be_false
+
+    expect(@ability.can?(:read, 1..3)).to be(true)
+    expect(@ability.can?(:read, 1..4)).to be(false)
+    expect(@ability.can?(:read, Range)).to be(true)
+    expect(@ability.can?(:read, {:any => [1..3, 1..4]})).to be(true)
+    expect(@ability.can?(:read, {:any => [1..4, 2..4]})).to be(false)
   end
 
   it "allows an array of options in conditions hash" do
     @ability.can :read, Range, :begin => [1, 3, 5]
-    expect(@ability.can?(:read, 1..3)).to be_true
-    expect(@ability.can?(:read, 2..4)).to be_false
-    expect(@ability.can?(:read, 3..5)).to be_true
-    expect(@ability.can?(:read, {:any => [2..4, 3..5]})).to be_true
-    expect(@ability.can?(:read, {:any => [2..4, 2..5]})).to be_false
+
+    expect(@ability.can?(:read, 1..3)).to be(true)
+    expect(@ability.can?(:read, 2..4)).to be(false)
+    expect(@ability.can?(:read, 3..5)).to be(true)
+    expect(@ability.can?(:read, {:any => [2..4, 3..5]})).to be(true)
+    expect(@ability.can?(:read, {:any => [2..4, 2..5]})).to be(false)
   end
 
   it "allows a range of options in conditions hash" do
     @ability.can :read, Range, :begin => 1..3
-    expect(@ability.can?(:read, 1..10)).to be_true
-    expect(@ability.can?(:read, 3..30)).to be_true
-    expect(@ability.can?(:read, 4..40)).to be_false
+    expect(@ability.can?(:read, 1..10)).to be(true)
+    expect(@ability.can?(:read, 3..30)).to be(true)
+    expect(@ability.can?(:read, 4..40)).to be(false)
   end
 
   it "allows nested hashes in conditions hash" do
     @ability.can :read, Range, :begin => { :to_i => 5 }
-    expect(@ability.can?(:read, 5..7)).to be_true
-    expect(@ability.can?(:read, 6..8)).to be_false
+    expect(@ability.can?(:read, 5..7)).to be(true)
+    expect(@ability.can?(:read, 6..8)).to be(false)
   end
 
   it "matches any element passed in to nesting if it's an array (for has_many associations)" do
     @ability.can :read, Range, :to_a => { :to_i => 3 }
-    expect(@ability.can?(:read, 1..5)).to be_true
-    expect(@ability.can?(:read, 4..6)).to be_false
+    expect(@ability.can?(:read, 1..5)).to be(true)
+    expect(@ability.can?(:read, 4..6)).to be(false)
   end
 
   it "accepts a set as a condition value" do
     expect(object_with_foo_2 = double(:foo => 2)).to receive(:foo)
-    expect(object_with_foo_3 = double(:foo => 3)).to receive(:foo) 
+    expect(object_with_foo_3 = double(:foo => 3)).to receive(:foo)
     @ability.can :read, Object, :foo => [1, 2, 5].to_set
-    expect(@ability.can?(:read, object_with_foo_2)).to be_true
-    expect(@ability.can?(:read, object_with_foo_3)).to be_false
+    expect(@ability.can?(:read, object_with_foo_2)).to be(true)
+    expect(@ability.can?(:read, object_with_foo_3)).to be(false)
   end
 
   it "does not match subjects return nil for methods that must match nested a nested conditions hash" do
     expect(object_with_foo = double(:foo => :bar)).to receive(:foo)
     @ability.can :read, Array, :first => { :foo => :bar }
-    expect(@ability.can?(:read, [object_with_foo])).to be_true
-    expect(@ability.can?(:read, [])).to be_false
+    expect(@ability.can?(:read, [object_with_foo])).to be(true)
+    expect(@ability.can?(:read, [])).to be(false)
   end
 
   it "matches strings but not substrings specified in a conditions hash" do
     @ability.can :read, String, :presence => "declassified"
-    expect(@ability.can?(:read, "declassified")).to be_true
-    expect(@ability.can?(:read, "classified")).to be_false
+    expect(@ability.can?(:read, "declassified")).to be(true)
+    expect(@ability.can?(:read, "classified")).to be(false)
   end
 
   it "does not stop at cannot definition when comparing class" do
     @ability.can :read, Range
     @ability.cannot :read, Range, :begin => 1
-    expect(@ability.can?(:read, 2..5)).to be_true
-    expect(@ability.can?(:read, 1..5)).to be_false
-    expect(@ability.can?(:read, Range)).to be_true
+    expect(@ability.can?(:read, 2..5)).to be(true)
+    expect(@ability.can?(:read, 1..5)).to be(false)
+    expect(@ability.can?(:read, Range)).to be(true)
   end
 
   it "stops at cannot definition when no hash is present" do
     @ability.can :read, :all
     @ability.cannot :read, Range
-    expect(@ability.can?(:read, 1..5)).to be_false
-    expect(@ability.can?(:read, Range)).to be_false
+    expect(@ability.can?(:read, 1..5)).to be(false)
+    expect(@ability.can?(:read, Range)).to be(false)
   end
 
   it "allows to check ability for Module" do
     module B; end
     class A; include B; end
     @ability.can :read, B
-    expect(@ability.can?(:read, A)).to be_true
-    expect(@ability.can?(:read, A.new)).to be_true
+    expect(@ability.can?(:read, A)).to be(true)
+    expect(@ability.can?(:read, A.new)).to be(true)
   end
 
   it "passes nil to a block for ability on Module when no instance is passed" do
@@ -326,33 +330,35 @@ describe CanCan::Ability do
       expect(sym).to be_nil
       true
     end
-    expect(@ability.can?(:read, B)).to be_true
-    expect(@ability.can?(:read, A)).to be_true
+    expect(@ability.can?(:read, B)).to be(true)
+    expect(@ability.can?(:read, A)).to be(true)
   end
 
   it "checks permissions through association when passing a hash of subjects" do
     @ability.can :read, Range, :string => {:length => 3}
-    expect(@ability.can?(:read, "foo" => Range)).to be_true
-    expect(@ability.can?(:read, "foobar" => Range)).to be_false
-    expect(@ability.can?(:read, 123 => Range)).to be_true
-    expect(@ability.can?(:read, {:any => [{"foo" => Range}, {"foobar" => Range}]})).to be_true
-    expect(@ability.can?(:read, {:any => [{"food" => Range}, {"foobar" => Range}]})).to be_false
+
+    expect(@ability.can?(:read, "foo" => Range)).to be(true)
+    expect(@ability.can?(:read, "foobar" => Range)).to be(false)
+    expect(@ability.can?(:read, 123 => Range)).to be(true)
+    expect(@ability.can?(:read, {:any => [{"foo" => Range}, {"foobar" => Range}]})).to be(true)
+    expect(@ability.can?(:read, {:any => [{"food" => Range}, {"foobar" => Range}]})).to be(false)
   end
 
   it "checks permissions correctly when passing a hash of subjects with multiple definitions" do
     @ability.can :read, Range, :string => {:length => 4}
     @ability.can [:create, :read], Range, :string => {:upcase => 'FOO'}
-    expect(@ability.can?(:read, "foo" => Range)).to be_true
-    expect(@ability.can?(:read, "foobar" => Range)).to be_false
-    expect(@ability.can?(:read, 1234 => Range)).to be_true
-    expect(@ability.can?(:read, {:any => [{"foo" => Range}, {"foobar" => Range}]})).to be_true
-    expect(@ability.can?(:read, {:any => [{"foo.bar" => Range}, {"foobar" => Range}]})).to be_false
+
+    expect(@ability.can?(:read, "foo" => Range)).to be(true)
+    expect(@ability.can?(:read, "foobar" => Range)).to be(false)
+    expect(@ability.can?(:read, 1234 => Range)).to be(true)
+    expect(@ability.can?(:read, {:any => [{"foo" => Range}, {"foobar" => Range}]})).to be(true)
+    expect(@ability.can?(:read, {:any => [{"foo.bar" => Range}, {"foobar" => Range}]})).to be(false)
   end
 
   it "allows to check ability on Hash-like object" do
     class Container < Hash; end
     @ability.can :read, Container
-    expect(@ability.can?(:read, Container.new)).to be_true
+    expect(@ability.can?(:read, Container.new)).to be(true)
   end
 
   it "has initial attributes based on hash conditions of 'new' action" do
@@ -474,7 +480,7 @@ describe CanCan::Ability do
       another_ability.can :use, :search
 
       @ability.merge(another_ability)
-      expect(@ability.can?(:use, :search)).to be_true
+      expect(@ability.can?(:use, :search)).to be(true)
       expect(@ability.send(:rules).size).to eq(2)
     end
   end

data/spec/cancan/controller_additions_spec.rb

@@ -17,7 +17,7 @@ describe CanCan::ControllerAdditions do
   it "authorize! assigns @_authorized instance variable and pass args to current ability" do
     allow(@controller.current_ability).to receive(:authorize!).with(:foo, :bar)
     @controller.authorize!(:foo, :bar)
-    expect(@controller.instance_variable_get(:@_authorized)).to be_true
+    expect(@controller.instance_variable_get(:@_authorized)).to be(true)
   end
 
   it "has a current_ability method which generates an ability for the current user" do
@@ -26,8 +26,8 @@ describe CanCan::ControllerAdditions do
 
   it "provides a can? and cannot? methods which go through the current ability" do
     expect(@controller.current_ability).to be_kind_of(Ability)
-    expect(@controller.can?(:foo, :bar)).to be_false
-    expect(@controller.cannot?(:foo, :bar)).to be_true
+    expect(@controller.can?(:foo, :bar)).to be(false)
+    expect(@controller.cannot?(:foo, :bar)).to be(true)
   end
 
   it "load_and_authorize_resource setups a before filter which passes call to ControllerResource" do
@@ -38,7 +38,7 @@ describe CanCan::ControllerAdditions do
   end
 
   it "load_and_authorize_resource properly passes first argument as the resource name" do
-    expect(cancan_resource_class = double).to receive(:load_and_authorize_resource) 
+    expect(cancan_resource_class = double).to receive(:load_and_authorize_resource)
     allow(CanCan::ControllerResource).to receive(:new).with(@controller, :project, :foo => :bar) {cancan_resource_class}
     expect(@controller_class).to receive(:before_filter).with({}) { |options, &block| block.call(@controller) }
     @controller_class.load_and_authorize_resource :project, :foo => :bar
@@ -50,14 +50,14 @@ describe CanCan::ControllerAdditions do
   end
 
   it "authorize_resource setups a before filter which passes call to ControllerResource" do
-    expect(cancan_resource_class = double).to receive(:authorize_resource) 
+    expect(cancan_resource_class = double).to receive(:authorize_resource)
     allow(CanCan::ControllerResource).to receive(:new).with(@controller, nil, :foo => :bar) {cancan_resource_class}
     expect(@controller_class).to receive(:before_filter).with(:except => :show, :if => true) { |options, &block| block.call(@controller) }
     @controller_class.authorize_resource :foo => :bar, :except => :show, :if => true
   end
 
   it "load_resource setups a before filter which passes call to ControllerResource" do
-    expect(cancan_resource_class = double).to receive(:load_resource) 
+    expect(cancan_resource_class = double).to receive(:load_resource)
     allow(CanCan::ControllerResource).to receive(:new).with(@controller, nil, :foo => :bar) {cancan_resource_class}
     expect(@controller_class).to receive(:before_filter).with(:only => [:show, :index], :unless => false) { |options, &block| block.call(@controller) }
     @controller_class.load_resource :foo => :bar, :only => [:show, :index], :unless => false
@@ -66,7 +66,7 @@ describe CanCan::ControllerAdditions do
   it "skip_authorization_check setups a before filter which sets @_authorized to true" do
     expect(@controller_class).to receive(:before_filter).with(:filter_options) { |options, &block| block.call(@controller) }
     @controller_class.skip_authorization_check(:filter_options)
-    expect(@controller.instance_variable_get(:@_authorized)).to be_true
+    expect(@controller.instance_variable_get(:@_authorized)).to be(true)
   end
 
   it "check_authorization triggers AuthorizationNotPerformed in after filter" do
@@ -112,7 +112,7 @@ describe CanCan::ControllerAdditions do
   it "cancan_skipper is an empty hash with :authorize and :load options and remember changes" do
     expect(@controller_class.cancan_skipper).to eq({:authorize => {}, :load => {}})
     @controller_class.cancan_skipper[:load] = true
-    expect(@controller_class.cancan_skipper[:load]).to be_true
+    expect(@controller_class.cancan_skipper[:load]).to be(true)
   end
 
   it "skip_authorize_resource adds itself to the cancan skipper with given model name and options" do

data/spec/cancan/controller_resource_spec.rb

@@ -127,10 +127,10 @@ describe CanCan::ControllerResource do
     context "with a strong parameters method" do
       it "accepts and uses the specified symbol for santitizing input" do
         params.merge!(:controller => "model")
-        controller.stub(:resource_params).and_return(:resource => 'params')
-        controller.stub(:model_params).and_return(:model => 'params')
-        controller.stub(:create_params).and_return(:create => 'params')
-        controller.stub(:custom_params).and_return(:custom => 'params')
+        allow(controller).to receive(:resource_params).and_return(:resource => 'params')
+        allow(controller).to receive(:model_params).and_return(:model => 'params')
+        allow(controller).to receive(:create_params).and_return(:create => 'params')
+        allow(controller).to receive(:custom_params).and_return(:custom => 'params')
         resource = CanCan::ControllerResource.new(controller, {:param_method => :custom_params})
         expect(resource.send("resource_params")).to eq(:custom => 'params')
       end
@@ -149,27 +149,27 @@ describe CanCan::ControllerResource do
 
       it "prefers to use the create_params method for santitizing input" do
         params.merge!(:controller => "model")
-        controller.stub(:resource_params).and_return(:resource => 'params')
-        controller.stub(:model_params).and_return(:model => 'params')
-        controller.stub(:create_params).and_return(:create => 'params')
-        controller.stub(:custom_params).and_return(:custom => 'params')
+        allow(controller).to receive(:resource_params).and_return(:resource => 'params')
+        allow(controller).to receive(:model_params).and_return(:model => 'params')
+        allow(controller).to receive(:create_params).and_return(:create => 'params')
+        allow(controller).to receive(:custom_params).and_return(:custom => 'params')
         resource = CanCan::ControllerResource.new(controller)
         expect(resource.send("resource_params")).to eq(:create => 'params')
       end
 
       it "prefers to use the <model_name>_params method for santitizing input if create is not found" do
         params.merge!(:controller => "model")
-        controller.stub(:resource_params).and_return(:resource => 'params')
-        controller.stub(:model_params).and_return(:model => 'params')
-        controller.stub(:custom_params).and_return(:custom => 'params')
+        allow(controller).to receive(:resource_params).and_return(:resource => 'params')
+        allow(controller).to receive(:model_params).and_return(:model => 'params')
+        allow(controller).to receive(:custom_params).and_return(:custom => 'params')
         resource = CanCan::ControllerResource.new(controller)
         expect(resource.send("resource_params")).to eq(:model => 'params')
       end
 
       it "prefers to use the resource_params method for santitizing input if create or model is not found" do
         params.merge!(:controller => "model")
-        controller.stub(:resource_params).and_return(:resource => 'params')
-        controller.stub(:custom_params).and_return(:custom => 'params')
+        allow(controller).to receive(:resource_params).and_return(:resource => 'params')
+        allow(controller).to receive(:custom_params).and_return(:custom => 'params')
         resource = CanCan::ControllerResource.new(controller)
         expect(resource.send("resource_params")).to eq(:resource => 'params')
       end
@@ -194,7 +194,7 @@ describe CanCan::ControllerResource do
       resource = CanCan::ControllerResource.new(controller)
       resource.load_resource
       expect(controller.instance_variable_get(:@model)).to be_nil
-      expect(controller.instance_variable_defined?(:@models)).to be_false
+      expect(controller.instance_variable_defined?(:@models)).to be(false)
     end
 
     it "does not use accessible_by when defining abilities through a block" do
@@ -204,7 +204,7 @@ describe CanCan::ControllerResource do
       resource = CanCan::ControllerResource.new(controller)
       resource.load_resource
       expect(controller.instance_variable_get(:@model)).to be_nil
-      expect(controller.instance_variable_defined?(:@models)).to be_false
+      expect(controller.instance_variable_defined?(:@models)).to be(false)
     end
 
     it "does not authorize single resource in collection action" do
@@ -515,17 +515,17 @@ describe CanCan::ControllerResource do
 
     context "with a strong parameters method" do
       it "only calls the santitize method with actions matching param_actions" do
-        controller.stub(:resource_params).and_return(:resource => 'params')
+        allow(controller).to receive(:resource_params).and_return(:resource => 'params')
         resource = CanCan::ControllerResource.new(controller)
-        resource.stub(:param_actions => [:create])
+        allow(resource).to receive(:param_actions) { [:create] }
 
-        controller.should_not_receive(:send).with(:resource_params)
+        expect(controller).not_to receive(:send).with(:resource_params)
         resource.send("resource_params")
       end
 
       it "uses the proper action param based on the action" do
-        controller.stub(:create_params).and_return(:create => 'params')
-        controller.stub(:update_params).and_return(:update => 'params')
+        allow(controller).to receive(:create_params).and_return(:create => 'params')
+        allow(controller).to receive(:update_params).and_return(:update => 'params')
         resource = CanCan::ControllerResource.new(controller)
         expect(resource.send("resource_params")).to eq(:update => 'params')
       end
@@ -579,41 +579,41 @@ describe CanCan::ControllerResource do
   it "skips resource behavior for :only actions in array" do
     allow(controller_class).to receive(:cancan_skipper) { {:load => {nil => {:only => [:index, :show]}}} }
     params.merge!(:action => "index")
-    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be_true
-    expect(CanCan::ControllerResource.new(controller, :some_resource).skip?(:load)).to be_false
+    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be(true)
+    expect(CanCan::ControllerResource.new(controller, :some_resource).skip?(:load)).to be(false)
     params.merge!(:action => "show")
-    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be_true
+    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be(true)
     params.merge!(:action => "other_action")
-    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be_false
+    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be_falsey
   end
 
   it "skips resource behavior for :only one action on resource" do
     allow(controller_class).to receive(:cancan_skipper) { {:authorize => {:model => {:only => :index}}} }
     params.merge!(:action => "index")
-    expect(CanCan::ControllerResource.new(controller).skip?(:authorize)).to be_false
-    expect(CanCan::ControllerResource.new(controller, :model).skip?(:authorize)).to be_true
+    expect(CanCan::ControllerResource.new(controller).skip?(:authorize)).to be(false)
+    expect(CanCan::ControllerResource.new(controller, :model).skip?(:authorize)).to be(true)
     params.merge!(:action => "other_action")
-    expect(CanCan::ControllerResource.new(controller, :model).skip?(:authorize)).to be_false
+    expect(CanCan::ControllerResource.new(controller, :model).skip?(:authorize)).to be_falsey
   end
 
   it "skips resource behavior :except actions in array" do
     allow(controller_class).to receive(:cancan_skipper) { {:load => {nil => {:except => [:index, :show]}}} }
     params.merge!(:action => "index")
-    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be_false
+    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be_falsey
     params.merge!(:action => "show")
-    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be_false
+    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be_falsey
     params.merge!(:action => "other_action")
-    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be_true
-    expect(CanCan::ControllerResource.new(controller, :some_resource).skip?(:load)).to be_false
+    expect(CanCan::ControllerResource.new(controller).skip?(:load)).to be(true)
+    expect(CanCan::ControllerResource.new(controller, :some_resource).skip?(:load)).to be(false)
   end
 
   it "skips resource behavior :except one action on resource" do
     allow(controller_class).to receive(:cancan_skipper) { {:authorize => {:model => {:except => :index}}} }
     params.merge!(:action => "index")
-    expect(CanCan::ControllerResource.new(controller, :model).skip?(:authorize)).to be_false
+    expect(CanCan::ControllerResource.new(controller, :model).skip?(:authorize)).to be_falsey
     params.merge!(:action => "other_action")
-    expect(CanCan::ControllerResource.new(controller).skip?(:authorize)).to be_false
-    expect(CanCan::ControllerResource.new(controller, :model).skip?(:authorize)).to be_true
+    expect(CanCan::ControllerResource.new(controller).skip?(:authorize)).to be(false)
+    expect(CanCan::ControllerResource.new(controller, :model).skip?(:authorize)).to be(true)
   end
 
   it "skips loading and authorization" do

data/spec/cancan/model_adapters/active_record_adapter_spec.rb

@@ -305,13 +305,12 @@ if defined? CanCan::ModelAdapters::ActiveRecordAdapter
         article.secret == true
       end
 
-      relation.stub(:count).and_raise('Unexpected scope execution.')
+      allow(relation).to receive(:count).and_raise('Unexpected scope execution.')
 
       expect { @ability.can? :read, Article }.not_to raise_error
     end
 
     context "when MetaWhere is defined" do
-
       before :each do
         pending "[Deprecated] MetaWhere support is being removed" unless defined? MetaWhere
       end
@@ -338,39 +337,38 @@ if defined? CanCan::ModelAdapters::ActiveRecordAdapter
       end
 
       it "matches any MetaWhere condition" do
-
         adapter = CanCan::ModelAdapters::ActiveRecordAdapter
         article1 = Article.new(:priority => 1, :name => "Hello World")
-        expect(adapter.matches_condition?(article1, :priority.eq, 1)).to be_true
-        expect(adapter.matches_condition?(article1, :priority.eq, 2)).to be_false
-        expect(adapter.matches_condition?(article1, :priority.eq_any, [1, 2])).to be_true
-        expect(adapter.matches_condition?(article1, :priority.eq_any, [2, 3])).to be_false
-        expect(adapter.matches_condition?(article1, :priority.eq_all, [1, 1])).to be_true
-        expect(adapter.matches_condition?(article1, :priority.eq_all, [1, 2])).to be_false
-        expect(adapter.matches_condition?(article1, :priority.ne, 2)).to be_true
-        expect(adapter.matches_condition?(article1, :priority.ne, 1)).to be_false
-        expect(adapter.matches_condition?(article1, :priority.in, [1, 2])).to be_true
-        expect(adapter.matches_condition?(article1, :priority.in, [2, 3])).to be_false
-        expect(adapter.matches_condition?(article1, :priority.nin, [2, 3])).to be_true
-        expect(adapter.matches_condition?(article1, :priority.nin, [1, 2])).to be_false
-        expect(adapter.matches_condition?(article1, :priority.lt, 2)).to be_true
-        expect(adapter.matches_condition?(article1, :priority.lt, 1)).to be_false
-        expect(adapter.matches_condition?(article1, :priority.lteq, 1)).to be_true
-        expect(adapter.matches_condition?(article1, :priority.lteq, 0)).to be_false
-        expect(adapter.matches_condition?(article1, :priority.gt, 0)).to be_true
-        expect(adapter.matches_condition?(article1, :priority.gt, 1)).to be_false
-        expect(adapter.matches_condition?(article1, :priority.gteq, 1)).to be_true
-        expect(adapter.matches_condition?(article1, :priority.gteq, 2)).to be_false
-        expect(adapter.matches_condition?(article1, :name.like, "%ello worl%")).to be_true
-        expect(adapter.matches_condition?(article1, :name.like, "hello world")).to be_true
-        expect(adapter.matches_condition?(article1, :name.like, "hello%")).to be_true
-        expect(adapter.matches_condition?(article1, :name.like, "h%d")).to be_true
-        expect(adapter.matches_condition?(article1, :name.like, "%helo%")).to be_false
-        expect(adapter.matches_condition?(article1, :name.like, "hello")).to be_false
-        expect(adapter.matches_condition?(article1, :name.like, "hello.world")).to be_false
+        expect(adapter.matches_condition?(article1, :priority.eq, 1)).to be(true)
+        expect(adapter.matches_condition?(article1, :priority.eq, 2)).to be(false)
+        expect(adapter.matches_condition?(article1, :priority.eq_any, [1, 2])).to be(true)
+        expect(adapter.matches_condition?(article1, :priority.eq_any, [2, 3])).to be(false)
+        expect(adapter.matches_condition?(article1, :priority.eq_all, [1, 1])).to be(true)
+        expect(adapter.matches_condition?(article1, :priority.eq_all, [1, 2])).to be(false)
+        expect(adapter.matches_condition?(article1, :priority.ne, 2)).to be(true)
+        expect(adapter.matches_condition?(article1, :priority.ne, 1)).to be(false)
+        expect(adapter.matches_condition?(article1, :priority.in, [1, 2])).to be(true)
+        expect(adapter.matches_condition?(article1, :priority.in, [2, 3])).to be(false)
+        expect(adapter.matches_condition?(article1, :priority.nin, [2, 3])).to be(true)
+        expect(adapter.matches_condition?(article1, :priority.nin, [1, 2])).to be(false)
+        expect(adapter.matches_condition?(article1, :priority.lt, 2)).to be(true)
+        expect(adapter.matches_condition?(article1, :priority.lt, 1)).to be(false)
+        expect(adapter.matches_condition?(article1, :priority.lteq, 1)).to be(true)
+        expect(adapter.matches_condition?(article1, :priority.lteq, 0)).to be(false)
+        expect(adapter.matches_condition?(article1, :priority.gt, 0)).to be(true)
+        expect(adapter.matches_condition?(article1, :priority.gt, 1)).to be(false)
+        expect(adapter.matches_condition?(article1, :priority.gteq, 1)).to be(true)
+        expect(adapter.matches_condition?(article1, :priority.gteq, 2)).to be(false)
+        expect(adapter.matches_condition?(article1, :name.like, "%ello worl%")).to be_truthy
+        expect(adapter.matches_condition?(article1, :name.like, "hello world")).to be_truthy
+        expect(adapter.matches_condition?(article1, :name.like, "hello%")).to be_truthy
+        expect(adapter.matches_condition?(article1, :name.like, "h%d")).to be_truthy
+        expect(adapter.matches_condition?(article1, :name.like, "%helo%")).to be_falsey
+        expect(adapter.matches_condition?(article1, :name.like, "hello")).to be_falsey
+        expect(adapter.matches_condition?(article1, :name.like, "hello.world")).to be_falsey
         # For some reason this is reporting "The not_matches MetaWhere condition is not supported."
-        # expect(adapter.matches_condition?(article1, :name.nlike, "%helo%")).to be_true
-        # expect(adapter.matches_condition?(article1, :name.nlike, "%ello worl%")).to be_false
+        # expect(adapter.matches_condition?(article1, :name.nlike, "%helo%")).to be(true)
+        # expect(adapter.matches_condition?(article1, :name.nlike, "%ello worl%")).to be(false)
       end
     end
   end

data/spec/cancan/model_adapters/mongoid_adapter_spec.rb

@@ -119,7 +119,7 @@ if defined? CanCan::ModelAdapters::MongoidAdapter
           expect(MongoidProject.accessible_by(@ability, :read)).to eq([obj])
 
           obj2 = MongoidProject.create(:title => 'Lord')
-          expect(@ability.can?(:read, obj2)).to be_false
+          expect(@ability.can?(:read, obj2)).to be(false)
         end
 
         describe "activates only when there are Criteria in the hash" do
@@ -145,7 +145,7 @@ if defined? CanCan::ModelAdapters::MongoidAdapter
           expect(MongoidProject.accessible_by(@ability, :read)).to eq([obj])
 
           obj2 = MongoidProject.create(:title => 'Lord')
-          expect(@ability.can?(:read, obj2)).to be_false
+          expect(@ability.can?(:read, obj2)).to be(false)
         end
 
         it "handles :field.size" do
@@ -155,7 +155,7 @@ if defined? CanCan::ModelAdapters::MongoidAdapter
           expect(MongoidProject.accessible_by(@ability, :read)).to eq([obj])
 
           obj2 = MongoidProject.create(:titles => ['Palatin', 'Margrave', 'Marquis'])
-          expect(@ability.can?(:read, obj2)).to be_false
+          expect(@ability.can?(:read, obj2)).to be(false)
         end
 
         it "handles :field.exists" do
@@ -165,7 +165,7 @@ if defined? CanCan::ModelAdapters::MongoidAdapter
           expect(MongoidProject.accessible_by(@ability, :read)).to eq([obj])
 
           obj2 = MongoidProject.create
-          expect(@ability.can?(:read, obj2)).to be_false
+          expect(@ability.can?(:read, obj2)).to be(false)
         end
 
         it "handles :field.gt" do
@@ -175,7 +175,7 @@ if defined? CanCan::ModelAdapters::MongoidAdapter
           expect(MongoidProject.accessible_by(@ability, :read)).to eq([obj])
 
           obj2 = MongoidProject.create(:age => 40)
-          expect(@ability.can?(:read, obj2)).to be_false
+          expect(@ability.can?(:read, obj2)).to be(false)
         end
 
         it "handles instance not saved to database" do
@@ -187,7 +187,7 @@ if defined? CanCan::ModelAdapters::MongoidAdapter
           expect(MongoidProject.accessible_by(@ability, :read).entries).to eq([])
 
           obj2 = MongoidProject.new(:title => 'Lord')
-          expect(@ability.can?(:read, obj2)).to be_false
+          expect(@ability.can?(:read, obj2)).to be(false)
         end
       end
 

data/spec/cancan/model_adapters/sequel_adapter_spec.rb

@@ -1,80 +1,81 @@
-if ENV["MODEL_ADAPTER"] == "sequel"
-  require "spec_helper"
+require "spec_helper"
 
-  DB = Sequel.sqlite
+if defined? CanCan::ModelAdapters::SequelAdapter
 
-  DB.create_table :users do
-    primary_key :id
-    String :name
-  end
+  describe CanCan::ModelAdapters::SequelAdapter do
+    DB = if RUBY_PLATFORM == 'java'
+      Sequel.connect('jdbc:sqlite:db.sqlite3')
+    else
+      Sequel.sqlite
+    end
 
-  class User < Sequel::Model
-    one_to_many :articles
-  end
+    DB.create_table :users do
+      primary_key :id
+      String :name
+    end
 
-  DB.create_table :articles do
-    primary_key :id
-    String :name
-    TrueClass :published
-    TrueClass :secret
-    Integer :priority
-    foreign_key :user_id, :users
-  end
+    class User < Sequel::Model
+      one_to_many :articles
+    end
 
-  class Article < Sequel::Model
-    many_to_one :user
-    one_to_many :comments
-  end
+    DB.create_table :articles do
+      primary_key :id
+      String :name
+      TrueClass :published
+      TrueClass :secret
+      Integer :priority
+      foreign_key :user_id, :users
+    end
 
-  DB.create_table :comments do
-    primary_key :id
-    TrueClass :spam
-    foreign_key :article_id, :articles
-  end
+    class Article < Sequel::Model
+      many_to_one :user
+      one_to_many :comments
+    end
 
-  class Comment < Sequel::Model
-    many_to_one :article
-  end
+    DB.create_table :comments do
+      primary_key :id
+      TrueClass :spam
+      foreign_key :article_id, :articles
+    end
+
+    class Comment < Sequel::Model
+      many_to_one :article
+    end
 
-  describe CanCan::ModelAdapters::SequelAdapter do
     before(:each) do
       Comment.dataset.delete
       Article.dataset.delete
       User.dataset.delete
-      @ability = Object.new
-      @ability.extend(CanCan::Ability)
+      (@ability = double).extend(CanCan::Ability)
     end
 
     it "should be for only sequel model classes" do
-      CanCan::ModelAdapters::SequelAdapter.should_not be_for_class(Object)
-      CanCan::ModelAdapters::SequelAdapter.should be_for_class(Article)
-      CanCan::ModelAdapters::AbstractAdapter.adapter_class(Article).should == CanCan::ModelAdapters::SequelAdapter
+      expect(CanCan::ModelAdapters::SequelAdapter).to_not be_for_class(Object)
+      expect(CanCan::ModelAdapters::SequelAdapter).to be_for_class(Article)
+      expect(CanCan::ModelAdapters::AbstractAdapter.adapter_class(Article)).to eq CanCan::ModelAdapters::SequelAdapter
     end
 
     it "should find record" do
       article = Article.create
-      CanCan::ModelAdapters::SequelAdapter.find(Article, article.id).should == article
+      expect(CanCan::ModelAdapters::SequelAdapter.find(Article, article.id)).to eq article
     end
 
     it "should not fetch any records when no abilities are defined" do
       Article.create
-      Article.accessible_by(@ability).all.should be_empty
+      expect(Article.accessible_by(@ability).all).to be_empty
     end
 
     it "should fetch all articles when one can read all" do
       @ability.can :read, Article
       article = Article.create
-      @ability.should be_able_to(:read, article)
-      Article.accessible_by(@ability).all.should == [article]
+      expect(Article.accessible_by(@ability).all).to eq [article]
     end
 
     it "should fetch only the articles that are published" do
       @ability.can :read, Article, :published => true
       article1 = Article.create(:published => true)
       article2 = Article.create(:published => false)
-      @ability.should be_able_to(:read, article1)
-      @ability.should_not be_able_to(:read, article2)
-      Article.accessible_by(@ability).all.should == [article1]
+      expect(Article.accessible_by(@ability).all).to eq [article1]
     end
 
     it "should fetch any articles which are published or secret" do
@@ -84,11 +85,7 @@ if ENV["MODEL_ADAPTER"] == "sequel"
       article2 = Article.create(:published => true, :secret => true)
       article3 = Article.create(:published => false, :secret => true)
       article4 = Article.create(:published => false, :secret => false)
-      @ability.should be_able_to(:read, article1)
-      @ability.should be_able_to(:read, article2)
-      @ability.should be_able_to(:read, article3)
-      @ability.should_not be_able_to(:read, article4)
-      Article.accessible_by(@ability).all.should == [article1, article2, article3]
+      expect(Article.accessible_by(@ability).all).to eq([article1, article2, article3])
     end
 
     it "should fetch only the articles that are published and not secret" do
@@ -98,20 +95,14 @@ if ENV["MODEL_ADAPTER"] == "sequel"
       article2 = Article.create(:published => true, :secret => true)
       article3 = Article.create(:published => false, :secret => true)
       article4 = Article.create(:published => false, :secret => false)
-      @ability.should be_able_to(:read, article1)
-      @ability.should_not be_able_to(:read, article2)
-      @ability.should_not be_able_to(:read, article3)
-      @ability.should_not be_able_to(:read, article4)
-      Article.accessible_by(@ability).all.should == [article1]
+      expect(Article.accessible_by(@ability).all).to eq [article1]
     end
 
     it "should only read comments for articles which are published" do
       @ability.can :read, Comment, :article => { :published => true }
       comment1 = Comment.create(:article => Article.create(:published => true))
       comment2 = Comment.create(:article => Article.create(:published => false))
-      @ability.should be_able_to(:read, comment1)
-      @ability.should_not be_able_to(:read, comment2)
-      Comment.accessible_by(@ability).all.should == [comment1]
+      expect(Comment.accessible_by(@ability).all).to eq [comment1]
     end
 
     it "should only read comments for articles which are published and user is 'me'" do
@@ -120,10 +111,7 @@ if ENV["MODEL_ADAPTER"] == "sequel"
       comment1 = Comment.create(:article => Article.create(:published => true, :user => user1))
       comment2 = Comment.create(:article => Article.create(:published => true))
       comment3 = Comment.create(:article => Article.create(:published => false, :user => user1))
-      @ability.should be_able_to(:read, comment1)
-      @ability.should_not be_able_to(:read, comment2)
-      @ability.should_not be_able_to(:read, comment3)
-      Comment.accessible_by(@ability).all.should == [comment1]
+      expect(Comment.accessible_by(@ability).all).to eq [comment1]
     end
 
     it "should allow conditions in SQL and merge with hash conditions" do
@@ -138,11 +126,7 @@ if ENV["MODEL_ADAPTER"] == "sequel"
       article2 = Article.create(:published => true, :secret => true, :priority => 1)
       article3 = Article.create(:published => true, :secret => true, :priority => 2)
       article4 = Article.create(:published => false, :secret => false, :priority => 2)
-      @ability.should be_able_to(:read, article1)
-      @ability.should be_able_to(:read, article2)
-      @ability.should_not be_able_to(:read, article3)
-      @ability.should_not be_able_to(:read, article4)
-      Article.accessible_by(@ability).all.should == [article1, article2]
+      expect(Article.accessible_by(@ability).all).to eq [article1, article2]
     end
   end
 end

data/spec/matchers.rb

@@ -3,11 +3,11 @@ RSpec::Matchers.define :orderlessly_match do |original_string|
     original_string.split('').sort == given_string.split('').sort
   end
 
-  failure_message_for_should do |given_string|
+  failure_message do |given_string|
     "expected \"#{given_string}\" to have the same characters as \"#{original_string}\""
   end
 
-  failure_message_for_should_not do |given_string|
+  failure_message_when_negated do |given_string|
     "expected \"#{given_string}\" not to have the same characters as \"#{original_string}\""
   end
 end

data/spec/spec_helper.rb

@@ -14,7 +14,6 @@ $:.unshift File.expand_path('../support', __FILE__)
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
   config.mock_with :rspec

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cancancan
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.8.4
 platform: ruby
 authors:
 - Bryan Rite
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-08 00:00:00.000000000 Z
+date: 2014-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -45,14 +45,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -149,7 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.4
 requirements: []
 rubyforge_project: cancancan
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Simple authorization solution for Rails.