grouped_scope 0.6.1 → 3.1.0

data/README.rdoc

@@ -1,98 +0,0 @@
-
-== GroupedScope: Has Many Associations IN (GROUPS)
-
-GroupedScope aims to make two things easier in your ActiveRecord models. First, provide a 
-easy way to group objects, second, to allow the group to share associated object via existing 
-has_many relationships. See installation and usage for more details.
-
-By the way, this plugin has been tested with rails 2.3.2, 2.2.2, and 2.1.1
-
-
-=== Installation & Usage
-
-From your project's RAILS_ROOT, run:
-
-  ./script/plugin install git://github.com/metaskills/grouped_scope.git
-
-To use GroupedScope on a model it must have a :group_id column.
-
-  class AddGroupId < ActiveRecord::Migration
-    def self.up
-      add_column :employees, :group_id, :integer
-    end
-    def self.down
-      remove_column :employees, :group_id
-    end
-  end
-
-Assume the following model.
-
-  class Employee < ActiveRecord::Base
-    has_many :reports
-    grouped_scope :reports
-  end
-  
-By calling grouped_scope on any association you create a new group accessor for each 
-instance. The object returned will act just like an array and at least include the 
-current object that called it.
-
-  @employee_one.group   # => [#<Employee id: 1, group_id: nil>]
-  
-To group resources, just assign the same :group_id in the schema. Note that in future 
-versions I will be extending the GroupedScope::Grouping that each object belongs to. 
-If you do not just want to assign some random integers, then take a look at that model 
-and the belongs_to :grouping code, schema needed ofcourse
-
-  @employee_one.update_attribute :group_id, 1
-  @employee_two.update_attribute :group_id, 1
-  @employee_one.group   # => [#<Employee id: 1, group_id: 1>, #<Employee id: 2, group_id: 1>]
-
-Calling grouped_scope on the :reports association leaves the existing association intact.
-
-  @employee_one.reports  # => [#<Report id: 2, employee_id: 1>]
-  @employee_two.reports  # => [#<Report id: 18, employee_id: 2>, #<Report id: 36, employee_id: 2>]
-
-Now the good part, all associations passed to the grouped_scope method can be called 
-on the group proxy. The collection will return resources shared by the group.
-
-  @employee_one.group.reports   # => [#<Report id: 2, employee_id: 1>, 
-                                      #<Report id: 18, employee_id: 2>, 
-                                      #<Report id: 36, employee_id: 2>]
-
-You can even call named scopes defined on the objects in the collection and association 
-extensions defined on the original has_many. For instance:
-
-  @employee.group.reports.urgent.assigned_to(user)
-
-
-
-=== Todo List
-
-* Go back and start adding some rdocs.
-* Add more GroupedScope::Grouping code.
-* Add polymorphic support.
-* Add/test has_and_belongs_to_many
-* Raise errors and/or support :finder_sql/:counter_sql.
-* Add a user definable group_id schema.
-
-
-=== Helping Our & Running Tests
-
-Running the test suite is easy to do. Just make sure you have the following gems installed. 
-
-* shoulda
-* quitebacktrace
-* mocha
-* factory_girl
-
-If you want to run the tests for a specific version of rails in gems (other than the latest), 
-then you can set the RAILS_VERSION environment variable. For example `env RAILS_VERSION=1.2.6 autotest`. 
-When doing this you also need to make sure that you download version 4.1 of shoulda (not the gem) 
-and place its lib contents into `test/lib/shoulda` and `test/lib/shoulda.rb`. The reason is that 
-the latest should gem require ActiveSupport greater than 2.0.
-
-
-
-Copyright (c) 2008 Ken Collins, Decisiv Inc.
-Released under the MIT license.
-

data/lib/grouped_scope/association_reflection.rb

@@ -1,54 +0,0 @@
-module GroupedScope
-  class AssociationReflection < ActiveRecord::Reflection::AssociationReflection
-    
-    ((ActiveRecord::Reflection::AssociationReflection.instance_methods-Class.instance_methods) +
-    (ActiveRecord::Reflection::AssociationReflection.private_instance_methods-Class.private_instance_methods)).each do |m| 
-      undef_method(m)
-    end
-    
-    attr_accessor :name, :options
-    
-    def initialize(active_record,ungrouped_name)
-      @active_record = active_record
-      @ungrouped_name = ungrouped_name
-      @name = :"grouped_scope_#{@ungrouped_name}"
-      verify_ungrouped_reflection
-      super(ungrouped_reflection.macro, @name, ungrouped_reflection.options.dup, @active_record)
-      create_grouped_association
-    end
-    
-    def ungrouped_reflection
-      @active_record.reflections[@ungrouped_name]
-    end
-    
-    def respond_to?(method, include_private=false)
-      super || ungrouped_reflection.respond_to?(method,include_private)
-    end
-    
-    
-    private
-    
-    def method_missing(method, *args, &block)
-      ungrouped_reflection.send(method, *args, &block)
-    end
-    
-    def verify_ungrouped_reflection
-      if ungrouped_reflection.blank? || ungrouped_reflection.macro.to_s !~ /has_many|has_and_belongs_to_many/
-        raise ArgumentError, "Cannot create a group scope for :#{@ungrouped_name} because it is not a has_many " + 
-                             "or a has_and_belongs_to_many association. Make sure to call grouped_scope after " + 
-                             "the has_many associations."
-      end
-    end
-    
-    def create_grouped_association
-      active_record.send(macro, name, options)
-      association_proxy_class = options[:through] ? ActiveRecord::Associations::HasManyThroughAssociation : ActiveRecord::Associations::HasManyAssociation
-      active_record.send(:collection_reader_method, self, association_proxy_class)
-      
-      active_record.reflections[name] = self
-      active_record.grouped_scopes[@ungrouped_name] = true
-      options[:grouped_scope] = true
-    end
-    
-  end
-end

data/lib/grouped_scope/class_methods.rb

@@ -1,32 +0,0 @@
-module GroupedScope
-  module ClassMethods
-    
-    def grouped_scopes
-      read_inheritable_attribute(:grouped_scopes) || write_inheritable_attribute(:grouped_scopes, {})
-    end
-    
-    def grouped_scope(*associations)
-      create_belongs_to_for_grouped_scope
-      associations.each { |association| AssociationReflection.new(self,association) }
-      create_grouped_scope_accessor
-    end
-    
-    private
-    
-    def create_grouped_scope_accessor
-      define_method(:group) do
-        @group ||= SelfGroupping.new(self)
-      end
-    end
-    
-    def create_belongs_to_for_grouped_scope
-      grouping_class_name = 'GroupedScope::Grouping'
-      existing_grouping = reflections[:grouping]
-      return false if existing_grouping && existing_grouping.macro == :belongs_to && existing_grouping.options[:class_name] == grouping_class_name
-      belongs_to :grouping, :foreign_key => 'group_id', :class_name => grouping_class_name
-    end
-    
-  end
-end
-
-ActiveRecord::Base.send :extend, GroupedScope::ClassMethods

data/lib/grouped_scope/core_ext.rb

@@ -1,29 +0,0 @@
-
-class ActiveRecord::Base
-  
-  class << self
-    
-    private
-    
-    def attribute_condition_with_grouped_scope(*args)
-      if ActiveRecord::VERSION::STRING >= '2.3.0'
-        quoted_column_name, argument = args
-        case argument
-          when GroupedScope::SelfGroupping then "#{quoted_column_name} IN (?)"
-          else attribute_condition_without_grouped_scope(quoted_column_name,argument)
-        end
-      else
-        argument = args.first
-        case argument
-          when GroupedScope::SelfGroupping then "IN (?)"
-          else attribute_condition_without_grouped_scope(argument)
-        end
-      end
-    end
-    alias_method_chain :attribute_condition, :grouped_scope
-    
-  end
-  
-end
-
-

data/lib/grouped_scope/grouping.rb

@@ -1,9 +0,0 @@
-module GroupedScope
-  class Grouping < ActiveRecord::Base
-    
-    
-    
-    
-  end
-end
-

data/lib/grouped_scope/has_many_association.rb

@@ -1,28 +0,0 @@
-module GroupedScope
-  module HasManyAssociation
-    
-    def self.included(klass)
-      klass.class_eval do
-        alias_method_chain :construct_sql, :group_scope
-      end
-    end
-    
-    def construct_sql_with_group_scope
-      if @reflection.options[:grouped_scope]
-        if @reflection.options[:as]
-          # TODO: Need to add case for polymorphic :as option.
-        else
-          @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} IN (#{@owner.group.quoted_ids})"
-          @finder_sql << " AND (#{conditions})" if conditions
-        end
-        @counter_sql = @finder_sql
-      else
-        construct_sql_without_group_scope
-      end
-    end
-    
-    
-  end
-end
-
-ActiveRecord::Associations::HasManyAssociation.send :include, GroupedScope::HasManyAssociation

data/lib/grouped_scope/has_many_through_association.rb

@@ -1,28 +0,0 @@
-module GroupedScope
-  module HasManyThroughAssociation
-    
-    def self.included(klass)
-      klass.class_eval do
-        alias_method_chain :construct_conditions, :group_scope
-      end
-    end
-    
-    def construct_conditions_with_group_scope
-      conditions = construct_conditions_without_group_scope
-      if @reflection.options[:grouped_scope]
-        if as = @reflection.options[:as]
-          # TODO: Need to add case for polymorphic :as option.
-        else
-          pattern = "#{@reflection.primary_key_name} = #{@owner.quoted_id}"
-          replacement = "#{@reflection.primary_key_name} IN (#{@owner.group.quoted_ids})"
-          conditions.sub!(pattern,replacement)
-        end
-      end
-      conditions
-    end
-    
-    
-  end
-end
-
-ActiveRecord::Associations::HasManyThroughAssociation.send :include, GroupedScope::HasManyThroughAssociation

data/lib/grouped_scope/instance_methods.rb

@@ -1,10 +0,0 @@
-module GroupedScope
-  module InstanceMethods
-    
-    def group
-      @group ||= SelfGroupping.new(self)
-    end
-    
-    
-  end
-end

data/test/grouped_scope/association_reflection_test.rb

@@ -1,73 +0,0 @@
-require 'helper'
-
-class GroupedScope::AssociationReflectionTest < GroupedScope::TestCase
-  
-  setup do
-    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
-        lambda{ @reflection_klass.new(Employee,:doesnotexist) }.must_raise(ArgumentError)
-      end
-
-      should 'when the association is not a has_many or a has_and_belongs_to_many' do
-        Employee.class_eval { belongs_to(:foo) }
-        lambda{ @reflection_klass.new(Employee,:foo) }.must_raise(ArgumentError)
-      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]
-      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
-      @ungrouped_reflection.name.wont_equal @grouped_reflection.name
-      @ungrouped_reflection.options.wont_equal @grouped_reflection.options
-    end
-    
-    should 'derive class name to same as ungrouped reflection' do
-      assert_equal @ungrouped_reflection.send(:derive_class_name), @grouped_reflection.send(:derive_class_name)
-    end
-    
-    should 'derive primary key name to same as ungrouped reflection' do
-      assert_equal @ungrouped_reflection.send(:derive_primary_key_name), @grouped_reflection.send(:derive_primary_key_name)
-    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

@@ -1,51 +0,0 @@
-require 'helper'
-
-class GroupedScope::ClassMethodsTest < GroupedScope::TestCase
-  
-  setup do
-    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 FactoryGirl.create(: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

@@ -1,156 +0,0 @@
-require 'helper'
-
-class GroupedScope::HasManyAssociationTest < GroupedScope::TestCase
-  
-  setup do
-    setup_environment
-  end
-  
-  context 'For an Employee' do
-    
-    setup do 
-      @employee = FactoryGirl.create(: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 = FactoryGirl.create(:employee_with_reports, :group_id => 1)
-        @e2 = FactoryGirl.create(: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 = FactoryGirl.create(:employee_with_urgent_reports, :group_id => 1)
-        @e2 = FactoryGirl.create(: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 = 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
-      
-      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 = FactoryGirl.create(: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