cancan 1.3.4 → 1.4.0.beta1

data/spec/cancan/query_spec.rb

@@ -7,101 +7,101 @@ describe CanCan::Query do
   end
 
   it "should have false conditions if no abilities match" do
-    @ability.query(:destroy, Person).conditions.should == "true=false"
+    @ability.query(:destroy, Project).conditions.should == "true=false"
   end
 
   it "should return hash for single `can` definition" do
-    @ability.can :read, Person, :blocked => false, :user_id => 1
-    @ability.query(:read, Person).conditions.should == { :blocked => false, :user_id => 1 }
+    @ability.can :read, Project, :blocked => false, :user_id => 1
+    @ability.query(:read, Project).conditions.should == { :blocked => false, :user_id => 1 }
   end
 
   it "should merge multiple can definitions into single SQL string joining with OR" do
-    @ability.can :read, Person, :blocked => false
-    @ability.can :read, Person, :admin => true
-    @ability.query(:read, Person).conditions.should == "(admin=true) OR (blocked=false)"
+    @ability.can :read, Project, :blocked => false
+    @ability.can :read, Project, :admin => true
+    @ability.query(:read, Project).conditions.should == "(admin=true) OR (blocked=false)"
   end
 
   it "should merge multiple can definitions into single SQL string joining with OR and AND" do
-    @ability.can :read, Person, :blocked => false, :active => true
-    @ability.can :read, Person, :admin => true
-    @ability.query(:read, Person).conditions.should orderlessly_match("(blocked=false AND active=true) OR (admin=true)")
+    @ability.can :read, Project, :blocked => false, :active => true
+    @ability.can :read, Project, :admin => true
+    @ability.query(:read, Project).conditions.should orderlessly_match("(blocked=false AND active=true) OR (admin=true)")
   end
 
   it "should merge multiple can definitions into single SQL string joining with OR and AND" do
-    @ability.can :read, Person, :blocked => false, :active => true
-    @ability.can :read, Person, :admin => true
-    @ability.query(:read, Person).conditions.should orderlessly_match("(blocked=false AND active=true) OR (admin=true)")
+    @ability.can :read, Project, :blocked => false, :active => true
+    @ability.can :read, Project, :admin => true
+    @ability.query(:read, Project).conditions.should orderlessly_match("(blocked=false AND active=true) OR (admin=true)")
   end
 
   it "should return false conditions for cannot clause" do
-    @ability.cannot :read, Person
-    @ability.query(:read, Person).conditions.should == "true=false"
+    @ability.cannot :read, Project
+    @ability.query(:read, Project).conditions.should == "true=false"
   end
 
   it "should return SQL for single `can` definition in front of default `cannot` condition" do
-    @ability.cannot :read, Person
-    @ability.can :read, Person, :blocked => false, :user_id => 1
-    @ability.query(:read, Person).conditions.should orderlessly_match("blocked=false AND user_id=1")
+    @ability.cannot :read, Project
+    @ability.can :read, Project, :blocked => false, :user_id => 1
+    @ability.query(:read, Project).conditions.should orderlessly_match("blocked=false AND user_id=1")
   end
 
   it "should return true condition for single `can` definition in front of default `can` condition" do
-    @ability.can :read, Person
-    @ability.can :read, Person, :blocked => false, :user_id => 1
-    @ability.query(:read, Person).conditions.should == 'true=true'
+    @ability.can :read, Project
+    @ability.can :read, Project, :blocked => false, :user_id => 1
+    @ability.query(:read, Project).conditions.should == 'true=true'
   end
 
   it "should return false condition for single `cannot` definition" do
-    @ability.cannot :read, Person, :blocked => true, :user_id => 1
-    @ability.query(:read, Person).conditions.should == 'true=false'
+    @ability.cannot :read, Project, :blocked => true, :user_id => 1
+    @ability.query(:read, Project).conditions.should == 'true=false'
   end
 
   it "should return `false condition` for single `cannot` definition in front of default `cannot` condition" do
-    @ability.cannot :read, Person
-    @ability.cannot :read, Person, :blocked => true, :user_id => 1
-    @ability.query(:read, Person).conditions.should == 'true=false'
+    @ability.cannot :read, Project
+    @ability.cannot :read, Project, :blocked => true, :user_id => 1
+    @ability.query(:read, Project).conditions.should == 'true=false'
   end
 
   it "should return `not (sql)` for single `cannot` definition in front of default `can` condition" do
-    @ability.can :read, Person
-    @ability.cannot :read, Person, :blocked => true, :user_id => 1
-    @ability.query(:read, Person).conditions.should orderlessly_match("not (blocked=true AND user_id=1)")
+    @ability.can :read, Project
+    @ability.cannot :read, Project, :blocked => true, :user_id => 1
+    @ability.query(:read, Project).conditions.should orderlessly_match("not (blocked=true AND user_id=1)")
   end
 
   it "should return appropriate sql conditions in complex case" do
-    @ability.can :read, Person
-    @ability.can :manage, Person, :id => 1
-    @ability.can :update, Person, :manager_id => 1
-    @ability.cannot :update, Person, :self_managed => true
-    @ability.query(:update, Person).conditions.should == 'not (self_managed=true) AND ((manager_id=1) OR (id=1))'
-    @ability.query(:manage, Person).conditions.should == {:id=>1}
-    @ability.query(:read, Person).conditions.should == 'true=true'
+    @ability.can :read, Project
+    @ability.can :manage, Project, :id => 1
+    @ability.can :update, Project, :manager_id => 1
+    @ability.cannot :update, Project, :self_managed => true
+    @ability.query(:update, Project).conditions.should == 'not (self_managed=true) AND ((manager_id=1) OR (id=1))'
+    @ability.query(:manage, Project).conditions.should == {:id=>1}
+    @ability.query(:read, Project).conditions.should == 'true=true'
   end
 
   it "should have nil joins if no can definitions" do
-    @ability.query(:read, Person).joins.should be_nil
+    @ability.query(:read, Project).joins.should be_nil
   end
 
   it "should have nil joins if no nested hashes specified in conditions" do
-    @ability.can :read, Person, :blocked => false
-    @ability.can :read, Person, :admin => true
-    @ability.query(:read, Person).joins.should be_nil
+    @ability.can :read, Project, :blocked => false
+    @ability.can :read, Project, :admin => true
+    @ability.query(:read, Project).joins.should be_nil
   end
 
   it "should merge separate joins into a single array" do
-    @ability.can :read, Person, :project => { :blocked => false }
-    @ability.can :read, Person, :company => { :admin => true }
-    @ability.query(:read, Person).joins.inspect.should orderlessly_match([:company, :project].inspect)
+    @ability.can :read, Project, :project => { :blocked => false }
+    @ability.can :read, Project, :company => { :admin => true }
+    @ability.query(:read, Project).joins.inspect.should orderlessly_match([:company, :project].inspect)
   end
 
   it "should merge same joins into a single array" do
-    @ability.can :read, Person, :project => { :blocked => false }
-    @ability.can :read, Person, :project => { :admin => true }
-    @ability.query(:read, Person).joins.should == [:project]
+    @ability.can :read, Project, :project => { :blocked => false }
+    @ability.can :read, Project, :project => { :admin => true }
+    @ability.query(:read, Project).joins.should == [:project]
   end
 
   it "should merge complex, nested joins" do
-    @ability.can :read, Person, :project => { :bar => {:test => true} }, :company => { :bar => {:test => true} }
-    @ability.can :read, Person, :project => { :foo => {:bar => true}, :bar => {:zip => :zap} }
-    @ability.query(:read, Person).joins.inspect.should orderlessly_match([{:project => [:bar, :foo]}, {:company => [:bar]}].inspect)
+    @ability.can :read, Project, :project => { :bar => {:test => true} }, :company => { :bar => {:test => true} }
+    @ability.can :read, Project, :project => { :foo => {:bar => true}, :bar => {:zip => :zap} }
+    @ability.query(:read, Project).joins.inspect.should orderlessly_match([{:project => [:bar, :foo]}, {:company => [:bar]}].inspect)
   end
 end

data/spec/spec.opts

@@ -1 +1,2 @@
 --color
+--backtrace

data/spec/spec_helper.rb

@@ -19,8 +19,18 @@ class Ability
   end
 end
 
-# this class helps out in testing SQL conditions
-class Person
+# Generic class to mimic a model
+class Project
+  attr_accessor :name
+
+  def initialize(attributes = {})
+    @name = attributes[:name]
+  end
+
+  def attributes=(attributes)
+    @name = attributes[:name] if attributes[:name]
+  end
+
   class << self
     protected
 

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cancan
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  prerelease: true
   segments: 
   - 1
-  - 3
   - 4
-  version: 1.3.4
+  - 0
+  - beta1
+  version: 1.4.0.beta1
 platform: ruby
 authors: 
 - Ryan Bates
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-31 00:00:00 -07:00
+date: 2010-09-03 00:00:00 -07:00
 default_executable: 
 dependencies: []