grouped_scope 0.6.1 → 3.1.0

data/lib/grouped_scope/arish/reflection.rb

@@ -0,0 +1,18 @@
+module GroupedScope
+  module Arish
+    module Reflection
+      module AssociationReflection
+        
+        extend ActiveSupport::Concern
+        
+        included do
+          attr_accessor :grouped_scope
+          alias :grouped_scope? :grouped_scope
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Reflection::AssociationReflection.send :include, GroupedScope::Arish::Reflection::AssociationReflection

data/lib/grouped_scope/arish/relation/predicate_builer.rb

@@ -0,0 +1,27 @@
+module GroupedScope
+  module Arish
+    module PredicateBuilder
+      
+      extend ActiveSupport::Concern
+      
+      included do
+        singleton_class.alias_method_chain :build_from_hash, :grouped_scope
+      end
+      
+      module ClassMethods
+        
+        def build_from_hash_with_grouped_scope(engine, attributes, default_table)
+          attributes.select{ |column, value| GroupedScope::SelfGroupping === value }.each do |column_value|
+            column, value = column_value
+            attributes[column] = value.arel_table[column.to_s].in(value.ids_sql)
+          end
+          build_from_hash_without_grouped_scope(engine, attributes, default_table)
+        end
+        
+      end
+
+    end
+  end
+end
+
+ActiveRecord::PredicateBuilder.send :include, GroupedScope::Arish::PredicateBuilder

data/lib/grouped_scope/errors.rb

@@ -7,6 +7,5 @@ module GroupedScope
     def initialize(owner) ; @owner = owner ; end
     def message ; %|The #{@owner.class} class does not have a "group_id" attribute.| ; end
   end
-  
-  
-end
+
+end

data/lib/grouped_scope/self_grouping.rb

@@ -1,13 +1,13 @@
 module GroupedScope
   class SelfGroupping
     
-    attr_reader :proxy_owner
+    attr_reader :proxy_owner, :reflection
     
-    delegate :primary_key, :quote_value, :columns_hash, :to => :proxy_class
+    delegate :quote_value, :columns_hash, :to => :proxy_class
     
     [].methods.each do |m|
-      unless m =~ /(^__|^nil\?|^send|^object_id$|class|extend|respond_to\?)/
-        delegate m, :to => :group_proxy
+      unless m =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/
+        delegate m, :to => :grouped_proxy
       end
     end
     
@@ -17,45 +17,71 @@ module GroupedScope
       @proxy_owner = proxy_owner
     end
     
+    def blank?
+      proxy_owner.group_id.blank?
+    end
+    
+    def present?
+      !blank?
+    end
+    
     def ids
-      @ids ||= find_selves(group_id_scope_options).map(&:id)
+      grouped_scoped_ids.map(&primary_key.to_sym)
+    end
+    
+    def ids_sql
+      Arel.sql(grouped_scoped_ids.to_sql)
     end
     
     def quoted_ids
       ids.map { |id| quote_value(id,columns_hash[primary_key]) }.join(',')
     end
     
+    def with_reflection(reflection)
+      @reflection = reflection
+      yield
+    ensure
+      @reflection = nil
+    end
+    
     def respond_to?(method, include_private=false)
-      super || !proxy_class.grouped_scopes[method].blank?
+      super || proxy_class.grouped_reflections[method].present? || grouped_proxy.respond_to?(method, include_private)
     end
     
     
     protected
     
-    def group_proxy
-      @group_proxy ||= find_selves(group_scope_options)
+    def primary_key
+      reflection ? reflection.association_primary_key : proxy_class.primary_key
     end
     
-    def all_grouped?
-      proxy_owner.all_grouped? rescue false
+    def arel_group_id
+      arel_table['group_id']
     end
     
-    def no_group?
-      proxy_owner.group_id.blank?
+    def arel_primary_key
+      arel_table[primary_key]
+    end
+    
+    def arel_table
+      reflection ? Arel::Table.new(reflection.table_name) : proxy_class.arel_table
     end
     
-    def find_selves(options={})
-      proxy_owner.class.find :all, options
+    def grouped_proxy
+      @grouped_proxy ||= grouped_scoped
+    end
+    
+    def all_grouped?
+      proxy_owner.all_grouped? rescue false
     end
     
-    def group_scope_options
-      return {} if all_grouped?
-      conditions = no_group? ? { primary_key => proxy_owner.id } : { :group_id => proxy_owner.group_id }
-      { :conditions => conditions }
+    def grouped_scoped
+      return proxy_class.scoped if all_grouped?
+      proxy_class.where present? ? arel_group_id.eq(proxy_owner.group_id) : arel_primary_key.eq(proxy_owner.id)
     end
     
-    def group_id_scope_options
-      { :select => primary_key }.merge(group_scope_options)
+    def grouped_scoped_ids
+      grouped_scoped.select(arel_primary_key)
     end
     
     def proxy_class
@@ -65,9 +91,19 @@ module GroupedScope
     
     private
     
-    def method_missing(method, *args, &block)
-      if proxy_class.grouped_scopes[method]
-        proxy_owner.send("grouped_scope_#{method}", *args, &block)
+    def method_missing(method, *args)
+      if proxy_class.grouped_reflections[method]
+        if block_given?
+          proxy_owner.send(:"grouped_scope_#{method}", *args)  { |*block_args| yield(*block_args) }
+        else
+          proxy_owner.send(:"grouped_scope_#{method}", *args)
+        end
+      elsif grouped_proxy.respond_to?(method)
+        if block_given?
+          grouped_proxy.send(method, *args)  { |*block_args| yield(*block_args) }
+        else
+          grouped_proxy.send(method, *args)
+        end
       else
         super
       end

data/lib/grouped_scope/version.rb

@@ -1,5 +1,3 @@
 module GroupedScope
-  
-  VERSION = '0.6.1'
-    
-end
+  VERSION = '3.1.0'
+end

data/test/cases/has_many_test.rb

@@ -0,0 +1,155 @@
+require 'helper'
+
+class GroupedScope::HasManyTest < GroupedScope::TestCase
+  
+  describe 'For an Employee' do
+    
+    before do 
+      @employee = FactoryGirl.create(:employee)
+    end
+    
+    it 'scopes existing association to owner' do
+      assert_sql(/"employee_id" = #{@employee.id}/) do
+        @employee.reports(true)
+      end
+    end
+    
+    it 'scopes group association to owner when no group present' do
+      assert_sql(/"employee_id" = #{@employee.id}/) do
+        @employee.group.reports(true)
+      end
+    end
+    
+    it 'scopes group association to owner when group present' do
+      @employee.update_attribute :group_id, 43
+      assert_sql(/"employee_id" IN \(SELECT "employees"\."id" FROM "employees"  WHERE "employees"\."group_id" = 43\)/) do
+        @employee.group.reports(true)
+      end
+    end
+    
+    describe 'for counting sql' do
+      
+      before do
+        @e1 = FactoryGirl.create(:employee_with_reports, :group_id => 1)
+        @e2 = FactoryGirl.create(:employee_with_reports, :group_id => 1)
+      end
+      
+      it 'scope count sql to owner' do
+        assert_sql(/SELECT COUNT\(\*\)/,/"employee_id" = #{@e1.id}/) do
+          @e1.reports(true).count
+        end
+      end
+      
+      it 'scope count sql to group' do
+        assert_sql(/SELECT COUNT\(\*\)/,/"employee_id" IN \(SELECT "employees"\."id" FROM "employees"  WHERE "employees"\."group_id" = #{@e1.group_id}\)/) do
+          @e1.group.reports(true).count
+        end
+      end
+      
+      it '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
+    
+    describe 'training association extensions' do
+    
+      before do
+        @e1 = FactoryGirl.create(:employee_with_urgent_reports, :group_id => 1)
+        @e2 = FactoryGirl.create(:employee, :group_id => 1)
+        @urgent_reports = @e1.reports.select(&:urgent_title?)
+      end
+      
+      it 'find urgent report via normal ungrouped association' do
+        assert_same_elements @urgent_reports, @e1.reports(true).urgent
+      end
+      
+      it 'find urgent report via grouped reflection' do
+        assert_same_elements @urgent_reports, @e2.group.reports(true).urgent
+      end
+      
+      it 'use association extension SQL along with group reflection' do
+        assert_sql(select_from_reports, where_for_groups(@e2.group_id), where_for_urgent_title) do
+          @e2.group.reports.urgent
+        end
+      end
+    
+    end
+    
+    describe 'training named scopes' do
+      
+      before do
+        @e1 = FactoryGirl.create(:employee_with_urgent_reports, :group_id => 1)
+        @e2 = FactoryGirl.create(:employee, :group_id => 1)
+        @urgent_titles = @e1.reports.select(&:urgent_title?)
+        @urgent_bodys = @e1.reports.select(&:urgent_body?)
+      end
+      
+      it '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
+      
+      it '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
+      
+      it 'use named scope SQL along with group reflection' do
+        assert_sql(select_from_reports, where_for_groups(@e2.group_id), where_for_urgent_body, where_for_urgent_title) do
+          @e2.group.reports.with_urgent_title.with_urgent_body.inspect
+        end
+      end
+      
+    end
+    
+  end
+  
+  describe 'For a LegacyEmployee' do
+  
+    before do
+      @employee = FactoryGirl.create(:legacy_employee)
+    end
+  
+    it 'scope existing association to owner' do
+      assert_sql(/"legacy_reports"."email" = '#{@employee.id}'/) do
+        @employee.reports(true)
+      end
+    end
+    
+    it 'scope group association to owner, since no group is present' do
+      assert_sql(/"legacy_reports"."email" = '#{@employee.id}'/) do
+        @employee.group.reports(true)
+      end
+    end
+    
+    it 'scopes group association to owners group when present' do
+      @employee.update_attribute :group_id, 43
+      assert_sql(/"legacy_reports"."email" IN \(SELECT "legacy_employees"\."email" FROM "legacy_employees"  WHERE "legacy_employees"\."group_id" = 43\)/) do
+        @employee.group.reports(true)
+      end
+    end
+    
+  end
+  
+  
+  protected
+  
+  def select_from_reports
+    /SELECT "reports"\.\* FROM "reports"/
+  end
+  
+  def where_for_groups(id)
+    /WHERE "reports"."employee_id" IN \(SELECT "employees"\."id" FROM "employees"  WHERE "employees"\."group_id" = #{id}\)/
+  end
+  
+  def where_for_urgent_body
+    /WHERE.*body LIKE '%URGENT%'/
+  end
+  
+  def where_for_urgent_title
+    /WHERE.*"?reports"?."?title"? = 'URGENT'/
+  end
+  
+  
+end

data/test/cases/has_many_through_test.rb

@@ -0,0 +1,51 @@
+require 'helper'
+
+class GroupedScope::HasManyThroughTest < GroupedScope::TestCase
+  
+  before do
+    @e1 = FactoryGirl.create(:employee, :group_id => 1)
+    @e1.departments << Department.hr << Department.finance
+    @e2 = FactoryGirl.create(:employee, :group_id => 1)
+    @e2.departments << Department.it
+    @all_group_departments = [Department.hr, Department.it, Department.finance]
+  end
+  
+  describe 'For default association' do
+
+    it 'scope to owner' do
+      assert_sql(/"employee_id" = #{@e1.id}/) do
+        @e1.departments(true)
+      end
+    end
+    
+    it 'scope count to owner' do
+      assert_sql(/"employee_id" = #{@e1.id}/) do
+        @e1.departments(true).count
+      end
+    end
+    
+  end
+  
+  describe 'For grouped association' do
+
+    it 'scope to group' do
+      
+      assert_sql(/"employee_id" IN \(SELECT "employees"\."id" FROM "employees"  WHERE "employees"\."group_id" = #{@e1.group_id}\)/) do
+        @e2.group.departments(true)
+      end
+    end
+    
+    it 'scope count to group' do
+      assert_sql(/"employee_id" IN \(SELECT "employees"\."id" FROM "employees"  WHERE "employees"\."group_id" = #{@e1.group_id}\)/) do
+        @e1.group.departments(true).count
+      end
+    end
+    
+    it 'have a group count equal to sum of separate owner counts' do
+      assert_equal @e1.departments(true).count + @e2.departments(true).count, @e2.group.departments(true).count
+    end
+    
+  end
+  
+  
+end

data/test/cases/reflection_test.rb

@@ -0,0 +1,62 @@
+require 'helper'
+
+class GroupedScope::ReflectionTest < GroupedScope::TestCase
+  
+  it 'creates a has_many association named :grouped_scope_* using existing association as a suffix' do
+    assert FactoryGirl.create(:employee).respond_to?(:grouped_scope_reports)
+  end
+  
+  it 'does not add the #grouped_scope to existing reflection' do
+    assert_nil Employee.reflections[:reports].grouped_scope?
+  end
+  
+  it 'should have added the #grouped_scope to new grouped reflection' do
+    assert Employee.reflections[:grouped_scope_reports].grouped_scope?
+  end
+  
+  describe 'Class attribute for #grouped_reflections' do
+    
+    it 'should one' do
+      assert_instance_of Hash, Employee.grouped_reflections
+    end
+
+    it 'populate with new grouped scopes' do
+      assert_nil Employee.grouped_reflections[:newgroupes]
+      Employee.class_eval { has_many(:newgroupes) ; grouped_scope(:newgroupes) }
+      assert Employee.grouped_reflections[:newgroupes]
+    end
+    
+  end
+  
+  describe 'Raise and exception' do
+
+    it 'when a association does not exist' do
+      begin
+        raised = false
+        Employee.class_eval{ grouped_scope(:doesnotexist) }
+      rescue ArgumentError => e
+        raised = true
+        e.message.must_match %r{Cannot create a group scope for :doesnotexist}
+      ensure
+        assert raised, 'Did not raise an ArgumentError'
+      end
+    end
+
+    it 'when the association is not a has_many or a has_and_belongs_to_many' do
+      begin
+        raised = false
+        Employee.class_eval { belongs_to(:belongstowillnotwork) ; grouped_scope(:belongstowillnotwork) }
+      rescue ArgumentError => e
+        raised = true
+        e.message.must_match %r{:belongstowillnotwork.*the reflection is blank or not supported}
+      ensure
+        assert raised, 'Did not raise an ArgumentError'
+      end
+    end
+
+  end
+  
+
+  
+  
+end