refactoring query.joins

spec/cancan/active_record_additions_spec.rb

@@ -45,7 +45,7 @@ describe CanCan::ActiveRecordAdditions do
       end
     end
     # @ability.conditions(:read, @model_class).should == '(too.car=1 AND too.far.bar=1) OR (foo.bar=1)'
-    # @ability.association_joins(:read, @model_class).should == [{:too => [:far]}, :foo]
+    # @ability.associations_hash(:read, @model_class).should == [{:too => [:far]}, :foo]
     @model_class.accessible_by(@ability).should == :found_records
   end
 end

spec/cancan/can_definition_spec.rb

@@ -7,38 +7,38 @@ describe CanCan::CanDefinition do
   end
 
   it "should return no association joins if none exist" do
-    @can.association_joins.should be_nil
+    @can.associations_hash.should == {}
   end
 
   it "should return no association for joins if just attributes" do
     @conditions[:foo] = :bar
-    @can.association_joins.should be_nil
+    @can.associations_hash.should == {}
   end
 
   it "should return single association for joins" do
     @conditions[:foo] = {:bar => 1}
-    @can.association_joins.should == [{:foo=>[]}]
+    @can.associations_hash.should == {:foo => {}}
   end
 
   it "should return multiple associations for joins" do
     @conditions[:foo] = {:bar => 1}
     @conditions[:test] = {1 => 2}
-    @can.association_joins.map(&:to_s).sort.should == [:foo, :test].map(&:to_s).sort
+    @can.associations_hash.should == {:foo => {}, :test => {}}
   end
 
   it "should return nested associations for joins" do
     @conditions[:foo] = {:bar => {1 => 2}}
-    @can.association_joins.should == [{:foo => [{:bar=>[]}]}]
+    @can.associations_hash.should == {:foo => {:bar => {}}}
   end
 
   it "should return table names in conditions for association joins" do
     @conditions[:foo] = {:bar => 1}
     @conditions[:test] = 1
-    @can.tableized_conditions.should == { :foos => { :bar => 1}, :test => 1 }
+    @can.tableized_conditions.should == {:foos => {:bar => 1}, :test => 1}
   end
 
   it "should return no association joins if conditions is nil" do
     can = CanCan::CanDefinition.new(true, :read, Integer, nil, nil)
-    can.association_joins.should be_nil
+    can.associations_hash.should == {}
   end
 end

spec/cancan/query_spec.rb

@@ -41,35 +41,30 @@ describe CanCan::Query do
   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
-    
-    result = @ability.query(:read, Person).conditions.should orderlessly_match("blocked=false AND user_id=1")
+    @ability.query(:read, Person).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'
   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'
   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'
   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
-    
-    result = @ability.query(:read, Person).conditions.should orderlessly_match("not (blocked=true AND user_id=1)")
+    @ability.query(:read, Person).conditions.should orderlessly_match("not (blocked=true AND user_id=1)")
   end
   
   it "should return appropriate sql conditions in complex case" do
@@ -77,9 +72,36 @@ describe CanCan::Query do
     @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'
   end
+  
+  it "should have nil joins if no can definitions" do
+    @ability.query(:read, Person).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
+  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)
+  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]
+  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)
+  end
 end