cancancan 1.8.0 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7079b16052c2f98ebe67d6ce08e390188bca856d
-  data.tar.gz: faa43141ca3124dbe3d40ceb30a76ca78bc56117
+  metadata.gz: b8ae98ee2960d59064addef2385b147001f02a90
+  data.tar.gz: 6f906603e1573ab3983ec429e0ba0a91b830a486
 SHA512:
-  metadata.gz: 8168024035574501d8bef61033f458facb1b7173ed98d901b9b51aedc0c659470f6210beb308273de9cd437e4d75027eb39321f104a9e8dc8f933593f1a67aa1
-  data.tar.gz: e71e7aa4f2a66f0f660aa9ce224dff3c0de2efc3b0fb85d461113175e5349700bf4475f5f9ca7abf16c56457488a33b3b5d954e753b021f162428c5827e28cd5
+  metadata.gz: e61cfecc5894d707b9f1db24278eb117fae7cec6fac6514ffdfc95eee8ec64db6c2fba872e2a98dc0342520e7aa61256a8453dd8ded1eefd85cf18f91513fa53
+  data.tar.gz: 36256ef9081035d4eb1b66a79197beeb7e971ed4efc4df96a6f4f039f7d98632ce6b992381bc15234f649989a9f3e64f0d3c45f4aae0d2c2e8cfdc37020d7c0d

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,13 @@
 Develop
 
 
+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

@@ -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/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.respond_to?(:key?) && subject.key?(:any)
         subject[:any]
       else
         [subject]

data/lib/cancan/version.rb

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

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
@@ -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])
 
-        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

data/spec/cancan/model_adapters/active_record_adapter_spec.rb

@@ -305,7 +305,7 @@ 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

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cancancan
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.8.1
 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-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -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.