cancancan 1.8.2 → 1.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ee08238dc809747b4d8fd583546d8090ae41c388
-  data.tar.gz: 07de2fb484baa605dab80da5444378178c7a02c9
+  metadata.gz: b834aa0ca99b2b6ab4c5b731ab3f80163b4cf502
+  data.tar.gz: 0e52c52dca9331cd0f99d26f16b804c3669dd796
 SHA512:
-  metadata.gz: 306997662a1978541ecc1a851cc779f486e91493ba6270ce708baaae32abc94f5d71d2cb17a4c5396d62ea9a0a35e0043b5f8d572ec48c6b32c36bf9d1727275
-  data.tar.gz: fbc981d0af75b1e9ee1888dae3f69542962ca07d566c731188171a5a2978e67a08b290415f18588c24b3950a834a0d5ad859a82142e2e6ded3c8e54ca87aa57f
+  metadata.gz: 46d18d924b8eae0a1ef18b9991adc41e1a781a4885554a2a3badb3f60dc9dca8ced9ccec84d2c92150558fddb189e1c56664167fcca71316ffed92c25e13c02c
+  data.tar.gz: 8b4382876b82ed5c5826da510b6baebca02ef9c60da24dcdd6682e888e02bd44eb8990f45ca22381d5ddef91749a4f82b8753147be30ef2819aeda96b8def805

data/CHANGELOG.rdoc

@@ -1,6 +1,11 @@
 Develop
 
 
+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)

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/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|
+  unless defined?(failure_message) # RSpec < 3
+    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.2"
+  VERSION = "1.8.3"
 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

@@ -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
@@ -517,7 +517,7 @@ describe CanCan::ControllerResource do
       it "only calls the santitize method with actions matching param_actions" do
         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] }
 
         expect(controller).not_to receive(:send).with(:resource_params)
         resource.send("resource_params")
@@ -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

@@ -311,7 +311,6 @@ if defined? CanCan::ModelAdapters::ActiveRecordAdapter
     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/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.2
+  version: 1.8.3
 platform: ruby
 authors:
 - Bryan Rite
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-05 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