metaskills-grouped_scope 0.5.1

data/lib/grouped_scope.rb

@@ -0,0 +1,15 @@
+require 'grouped_scope/errors'
+require 'grouped_scope/grouping'
+require 'grouped_scope/self_grouping'
+require 'grouped_scope/association_reflection'
+require 'grouped_scope/class_methods'
+require 'grouped_scope/has_many_association'
+require 'grouped_scope/has_many_through_association'
+require 'grouped_scope/core_ext'
+
+module GroupedScope
+  
+  VERSION = '0.5.1'
+    
+end
+

data/test/factories.rb

@@ -0,0 +1,46 @@
+
+Factory.sequence(:id)     { |n| n }
+Factory.sequence(:email)  { |n| "test_#{n}@domain.com" }
+Factory.sequence(:title)  { |n| "Report Title ##{n}" }
+
+Factory.define :employee do |e|
+  e.name      { "Factory Employee ##{Factory.next(:id)}" }
+  e.email     { Factory.next(:email) }
+end
+
+Factory.define :report do |r|
+  r.title     { Factory.next(:title) }
+  r.body      'Bla bla bla. Bla. Bla bla.'
+end
+
+Factory.define :employee_with_reports, :class => 'Employee' do |e|
+  e.name      { "Factory Employee ##{Factory.next(:id)}" }
+  e.email     { Factory.next(:email) }
+  e.reports   { |employee| [employee.association(:report),employee.association(:report)] }
+end
+
+Factory.define :employee_with_urgent_reports, :class => 'Employee' do |e|
+  e.name      { "Factory Employee ##{Factory.next(:id)}" }
+  e.email     { Factory.next(:email) }
+  e.reports   { |employee| [employee.association(:report), employee.association(:report,:title=>'URGENT'), 
+                            employee.association(:report), employee.association(:report,:body=>'This is URGENT.')] }
+end
+
+
+Factory.define :legacy_employee do |e|
+  e.name      { "Legacy Factory Employee ##{Factory.next(:id)}" }
+  e.email     { Factory.next(:email) }
+end
+
+Factory.define :legacy_report do |r|
+  r.title     { Factory.next(:title) }
+  r.body      'Legacy bla bla. Legacy. Legacy bla.'
+end
+
+Factory.define :legacy_employee_with_reports, :class => 'LegacyEmployee' do |e|
+  e.name      { "Legacy Factory Employee ##{Factory.next(:id)}" }
+  e.email     { Factory.next(:email) }
+  e.reports   { |employee| [employee.association(:legacy_report),employee.association(:legacy_report)] }
+end
+
+

data/test/grouped_scope/association_reflection_test.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/../helper'
+
+class GroupedScope::AssociationReflectionTest < GroupedScope::TestCase
+  
+  def setup
+    setup_environment
+  end
+  
+  context 'For initialization' do
+
+    context 'Raise and exception' do
+
+      setup { @reflection_klass = GroupedScope::AssociationReflection }
+
+      should 'when a association does not exist' do
+        assert_raise(ArgumentError) { @reflection_klass.new(Employee,:foobars) }
+      end
+
+      should 'when the association is not a has_many or a has_and_belongs_to_many' do
+        Employee.class_eval { belongs_to(:foo) }
+        assert_raise(ArgumentError) { @reflection_klass.new(Employee,:foo) }
+      end
+
+    end
+
+  end
+  
+  
+  context 'For #ungrouped_reflection' do
+    
+    setup do
+      @ungrouped_reflection = Employee.reflections[:reports]
+      @grouped_reflection = Employee.reflections[:grouped_scope_reports]
+    end
+    
+    should 'access ungrouped reflection' do
+      assert_equal @ungrouped_reflection, @grouped_reflection.ungrouped_reflection
+    end
+    
+    should 'delegate instance methods to #ungrouped_reflection' do
+      methods = [:class_name,:klass,:table_name,:primary_key_name,:active_record,
+                 :association_foreign_key,:counter_cache_column,:source_reflection]
+      # CHANGED [Rails 1.2.6] Account for quoted_table_name.
+      methods << :quoted_table_name if @ungrouped_reflection.respond_to?(:quoted_table_name)
+      methods.each do |m|
+        assert_equal @ungrouped_reflection.send(m), @grouped_reflection.send(m),
+          "The method #{m.inspect} does not appear to be proxied to the ungrouped reflection."
+      end
+    end
+    
+    should 'not delegate to #ungrouped_reflection for #options and #name' do
+      assert_not_equal @ungrouped_reflection.name, @grouped_reflection.name
+      assert_not_equal @ungrouped_reflection.options, @grouped_reflection.options
+    end
+    
+    should 'derive class name to same as ungrouped reflection' do
+      # CHANGED [Rails 1.2.6] Account for quoted_table_name.
+      if @ungrouped_reflection.respond_to?(:derive_class_name)
+        assert_equal @ungrouped_reflection.send(:derive_class_name), @grouped_reflection.send(:derive_class_name)
+      end
+    end
+    
+    should 'derive primary key name to same as ungrouped reflection' do
+      # CHANGED [Rails 1.2.6] Account for quoted_table_name.
+      if @ungrouped_reflection.respond_to?(:derive_primary_key_name)
+        assert_equal @ungrouped_reflection.send(:derive_primary_key_name), @grouped_reflection.send(:derive_primary_key_name)
+      end
+    end
+    
+    should 'honor explicit legacy reports association options like class_name and foreign_key' do
+      @ungrouped_reflection = LegacyEmployee.reflections[:reports]
+      @grouped_reflection   = LegacyEmployee.reflections[:grouped_scope_reports]
+      [:class_name,:primary_key_name].each do |m|
+        assert_equal @ungrouped_reflection.send(m), @grouped_reflection.send(m),
+          "The method #{m.inspect} does not appear to be proxied to the ungrouped reflection."
+      end
+    end
+    
+  end
+  
+  
+  
+end

data/test/grouped_scope/class_methods_test.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../helper'
+
+class GroupedScope::ClassMethodsTest < GroupedScope::TestCase
+  
+  def setup
+    setup_environment
+  end
+  
+  context 'For .grouped_scopes' do
+    
+    should 'have a inheritable attribute hash' do
+      assert_instance_of Hash, Employee.grouped_scopes
+    end
+    
+    should 'add to inheritable attributes with new grouped_scope' do
+      Employee.grouped_scopes[:foobars] = nil
+      Employee.class_eval { has_many(:foobars) ; grouped_scope(:foobars) }
+      assert Employee.grouped_scopes[:foobars]
+    end
+
+  end
+  
+  context 'For .grouped_scope' do
+    
+    should 'create a belongs_to :grouping association' do
+      assert Employee.reflections[:grouping]
+    end
+    
+    should 'not recreate belongs_to :grouping on additional calls' do
+      Employee.stubs(:belongs_to).never
+      Employee.class_eval { has_many(:foobars) ; grouped_scope(:foobars) }
+    end
+    
+    should 'create a has_many assoc named :grouped_scope_* using existing association as a suffix' do
+      grouped_reports_assoc = Employee.reflections[:grouped_scope_reports]
+      assert_instance_of GroupedScope::AssociationReflection, grouped_reports_assoc
+      assert Factory(:employee).respond_to?(:grouped_scope_reports)
+    end
+    
+    should 'not add the :grouped_scope option to existing reflection' do
+      assert_nil Employee.reflections[:reports].options[:grouped_scope]
+    end
+    
+    should 'have added the :grouped_scope option to new grouped reflection' do
+      assert Employee.reflections[:grouped_scope_reports].options[:grouped_scope]
+    end
+    
+  end
+  
+  
+end

data/test/grouped_scope/has_many_association_test.rb

@@ -0,0 +1,157 @@
+require File.dirname(__FILE__) + '/../helper'
+
+class GroupedScope::HasManyAssociationTest < GroupedScope::TestCase
+  
+  def setup
+    setup_environment
+  end
+  
+  
+  context 'For an Employee' do
+    
+    setup do 
+      @employee = Factory(:employee)
+    end
+    
+    should 'scope existing association to owner' do
+      assert_sql(/employee_id = #{@employee.id}/) do
+        @employee.reports(true)
+      end
+    end
+    
+    should 'scope group association to group' do
+      assert_sql(/employee_id IN \(#{@employee.id}\)/) do
+        @employee.group.reports(true)
+      end
+    end
+    
+    context 'for counting sql' do
+      
+      setup do
+        @e1 = Factory(:employee_with_reports, :group_id => 1)
+        @e2 = Factory(:employee_with_reports, :group_id => 1)
+      end
+      
+      should 'scope count sql to owner' do
+        assert_sql(/SELECT count\(\*\)/,/employee_id = #{@e1.id}/) do
+          @e1.reports(true).count
+        end
+      end
+      
+      should 'scope count sql to group' do
+        assert_sql(/SELECT count\(\*\)/,/employee_id IN \(#{@e1.id},#{@e2.id}\)/) do
+          @e1.group.reports(true).count
+        end
+      end
+      
+      should 'have a group count equal to sum of seperate owner counts' do
+        assert_equal @e1.reports(true).count + @e2.reports(true).count, @e2.group.reports(true).count
+      end
+      
+    end
+    
+    context 'training association extensions' do
+    
+      setup do
+        @e1 = Factory(:employee_with_urgent_reports, :group_id => 1)
+        @e2 = Factory(:employee, :group_id => 1)
+        @urgent_reports = @e1.reports.select(&:urgent_title?)
+      end
+      
+      should 'find urgent report via normal ungrouped association' do
+        assert_same_elements @urgent_reports, @e1.reports(true).urgent
+      end
+      
+      should 'find urgent report via grouped reflection' do
+        assert_same_elements @urgent_reports, @e2.group.reports(true).urgent
+      end
+      
+      should 'use assoc extension SQL along with group reflection' do
+        assert_sql(select_from_reports, where_for_groups, where_for_urgent_title) do
+          @e2.group.reports.urgent
+        end
+      end
+    
+    end
+    
+    context 'training named scopes' do
+      
+      setup do
+        @e1 = Factory(:employee_with_urgent_reports, :group_id => 1)
+        @e2 = Factory(:employee, :group_id => 1)
+        @urgent_titles = @e1.reports.select(&:urgent_title?)
+        @urgent_bodys = @e1.reports.select(&:urgent_body?)
+      end
+      
+      should 'find urgent reports via normal named scopes by normal owner' do
+        assert_same_elements @urgent_titles, @e1.reports(true).with_urgent_title
+        assert_same_elements @urgent_bodys, @e1.reports(true).with_urgent_body
+      end
+      
+      should 'find urgent reports via group reflection by group member' do
+        assert_same_elements @urgent_titles, @e2.group.reports(true).with_urgent_title
+        assert_same_elements @urgent_bodys, @e2.group.reports(true).with_urgent_body
+      end
+      
+      should 'use named scope SQL along with group reflection' do
+        assert_sql(select_from_reports, where_for_groups, where_for_urgent_body, where_for_urgent_title) do
+          @e2.group.reports.with_urgent_title.with_urgent_body.inspect
+        end
+      end
+      
+      context 'with will paginate' do
+        
+        should 'use group reflection, named scope, and paginate SQL' do
+          where_ends_with_limits = /WHERE.*LIMIT 2 OFFSET 0/
+          assert_sql(select_from_reports, where_for_groups, where_for_urgent_body, where_for_urgent_title, where_ends_with_limits) do
+            @e2.group.reports.with_urgent_title.with_urgent_body.paginate(:page=>1,:per_page=>2)
+          end
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+  context 'For a LegacyEmployee' do
+  
+    setup do
+      @employee = Factory(:legacy_employee)
+    end
+  
+    should 'scope existing association to owner' do
+      assert_sql(/"?legacy_reports"?.email = '#{@employee.id}'/) do
+        @employee.reports(true)
+      end
+    end
+    
+    should 'scope group association to group' do
+      assert_sql(/"?legacy_reports"?.email IN \('#{@employee.id}'\)/) do
+        @employee.group.reports(true)
+      end
+    end
+    
+  end
+  
+  
+  protected
+  
+  def select_from_reports
+    /SELECT \* FROM "?reports"?/
+  end
+  
+  def where_for_groups
+    /WHERE.*"?reports"?.employee_id IN \(2,3\)/
+  end
+  
+  def where_for_urgent_body
+    /WHERE.*body LIKE '%URGENT%'/
+  end
+  
+  def where_for_urgent_title
+    /WHERE.*"?reports"?."?title"? = 'URGENT'/
+  end
+  
+  
+end

data/test/grouped_scope/has_many_through_association_test.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../helper'
+
+class GroupedScope::HasManyThroughAssociationTest < GroupedScope::TestCase
+  
+  def setup
+    setup_environment
+    @e1 = Factory(:employee, :group_id => 1)
+    @e1.departments << Department.hr << Department.finance
+    @e2 = Factory(:employee, :group_id => 1)
+    @e2.departments << Department.it
+    @all_group_departments = [Department.hr, Department.it, Department.finance]
+  end
+  
+  
+  context 'For default association' do
+
+    should 'scope to owner' do
+      assert_sql(/employee_id = #{@e1.id}/) do
+        @e1.departments(true)
+      end
+    end
+    
+    should 'scope count to owner' do
+      assert_sql(/employee_id = #{@e1.id}/) do
+        @e1.departments(true).count
+      end
+    end
+    
+  end
+  
+  context 'For grouped association' do
+
+    should 'scope to group' do
+      assert_sql(/employee_id IN \(#{@e1.id},#{@e2.id}\)/) do
+        @e2.group.departments(true)
+      end
+    end
+    
+    should 'scope count to group' do
+      assert_sql(/employee_id IN \(#{@e1.id},#{@e2.id}\)/) do
+        @e1.group.departments(true).count
+      end
+    end
+    
+    should 'have a group count equal to sum of seperate owner counts' do
+      assert_equal @e1.departments(true).count + @e2.departments(true).count, @e2.group.departments(true).count
+    end
+    
+  end
+  
+  
+  
+end

data/test/grouped_scope/self_grouping_test.rb

@@ -0,0 +1,147 @@
+require File.dirname(__FILE__) + '/../helper'
+
+class GroupedScope::SelfGrouppingTest < GroupedScope::TestCase
+  
+  def setup
+    setup_environment
+  end
+  
+  context 'General behavior' do
+    
+    setup do
+      @employee = Factory(:employee)
+    end
+    
+    should 'return an array' do
+      assert_instance_of Array, @employee.group
+    end
+    
+    should 'return #ids array' do
+      assert_equal [@employee.id], @employee.group.ids
+    end
+    
+    should 'return #quoted_ids string for use in sql statments' do
+      assert_equal "#{@employee.id}", @employee.group.quoted_ids
+    end
+    
+    should 'respond true to grouped associations' do
+      assert @employee.group.respond_to?(:reports)
+    end
+    
+    should 'raise a GroupedScope::NoGroupIdError exception for objects with no group_id schema' do
+      assert_does_not_contain FooBar.column_names, 'group_id'
+      assert_raise(GroupedScope::NoGroupIdError) { GroupedScope::SelfGroupping.new(FooBar.new) }
+    end
+    
+    should 'return correct attribute_condition for GroupedScope::SelfGroupping object' do
+      assert_sql(/"?group_id"? IN \(#{@employee.id}\)/) do
+        Employee.find :all, :conditions => {:group_id => @employee.group}
+      end
+    end
+    
+    context 'for Array delegates' do
+
+      should 'respond to first/last' do
+        [:first,:last].each do |method|
+          assert @employee.group.respond_to?(method), "Should respond to #{method.inspect}"
+        end
+      end
+      
+      should 'respond to each' do
+        assert @employee.group.respond_to?(:each)
+        @employee.group.each do |employee|
+          assert_instance_of Employee, employee
+        end
+      end
+      
+    end
+    
+  end
+  
+  context 'Calling #group' do
+    
+    should 'return an array' do
+      assert_instance_of Array, Factory(:employee).group
+    end
+    
+    context 'with a NIL group_id' do
+      
+      setup do
+        @employee = Factory(:employee)
+      end
+      
+      should 'return a collection of one' do
+        assert_equal 1, @employee.group.size
+      end
+      
+      should 'include self in group' do
+        assert_contains @employee.group, @employee
+      end
+      
+    end
+    
+    context 'with a set group_id' do
+      
+      setup do
+        @employee = Factory(:employee, :group_id => 1)
+      end
+      
+      should 'return a collection of one' do
+        assert_equal 1, @employee.group.size
+      end
+      
+      should 'include self in group' do
+        assert_contains @employee.group, @employee
+      end
+      
+    end
+    
+    context 'with different groups available' do
+      
+      setup do
+        @e1 = Factory(:employee_with_reports, :group_id => 1)
+        @e2 = Factory(:employee, :group_id => 1)
+        @e3 = Factory(:employee_with_reports, :group_id => 2)
+        @e4 = Factory(:employee, :group_id => 2)
+      end
+      
+      should 'return a collection of group members' do
+        assert_equal 2, @e1.group.size
+      end
+      
+      should 'include all group members' do
+        assert_same_elements [@e1,@e2], @e1.group
+      end
+      
+      should 'allow member to find grouped associations of other member' do
+        assert_same_elements @e1.reports, @e2.group.reports
+      end
+      
+      should 'allow proxy owner to define all grouped which ignores group_id schema' do
+        @e2.stubs(:all_grouped?).returns(true)
+        assert_same_elements [@e1,@e2,@e3,@e4], @e2.group
+        assert_same_elements @e1.reports + @e3.reports, @e2.group.reports
+      end
+      
+    end
+    
+    context 'with different groups in legacy schema' do
+      
+      setup do
+        @e1 = Factory(:legacy_employee_with_reports, :group_id => 1)
+        @e2 = Factory(:legacy_employee, :group_id => 1)
+        @e3 = Factory(:legacy_employee_with_reports, :group_id => 2)
+        @e4 = Factory(:legacy_employee, :group_id => 2)
+      end
+      
+      should 'honor legacy reports association options like class_name and foreign_key' do
+        @e2.group.reports.all? { |r| r.is_a?(LegacyReport) }
+      end
+      
+    end
+    
+    
+  end
+  
+  
+end