decisiv-grouped_scope 0.5.1.1

data/CHANGELOG

@@ -0,0 +1,34 @@
+
+*master*
+
+* 
+
+
+*0.5.1* (January 7th 2009)
+
+* Add rails 2.2.2 to test task and remove quite backtrace usage so 1.2.6 testing can run. [Ken Collins]
+
+
+*0.4* (October 3rd 2008)
+
+* Use the #737f2bdabb of NamedScope plugin from http://github.com/metaskills/named_scope/tree/master
+
+
+*0.3* (October 2nd 2008)
+
+* Add additional NamedScope patches for attribute_condition. 
+  Also added GroupedScope::CoreExt to follow suite for GroupedScope::SelfGrouping attribute_conditions.
+
+
+*0.2* (September 29th 2008)
+
+* Add WillPaginate test and confirm grouped scope, named scope, and will paginate all play together.  [Ken Collins]
+
+* Stronger back port for named_scope in 1.2.6 and 2.0.4. Fixed bug where association proxy owner scope was after named_scope calls.  [Ken Collins]
+
+
+*0.1* (September 26th, 2008)
+
+* Initial public release.  [Ken Collins]
+
+

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2008 Ken Collins, Decisiv Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.rdoc

@@ -0,0 +1,98 @@
+
+== 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 1.2.6, 2.0.4, 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/Rakefile

@@ -0,0 +1,43 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+def reset_invoked
+  ['test_rails','test'].each do |name|
+    Rake::Task[name].instance_variable_set '@already_invoked', false
+  end
+end
+
+
+desc 'Default: run unit tests.'
+task :default => :test_rails
+
+desc 'Test the GroupedScope plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Test the GroupedScope plugin with Rails 2.1.1, 2.0.4 & 1.2.6 gems'
+task :test_rails do
+  test = Rake::Task['test']
+  versions = ['2.2.2','2.1.1','2.0.4','1.2.6']
+  versions.each do |version|
+    ENV['RAILS_VERSION'] = "#{version}"
+    test.invoke
+    reset_invoked unless version == versions.last
+  end
+end
+
+desc 'Generate documentation for the GroupedScope plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'GroupedScope'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+

data/init.rb

@@ -0,0 +1,2 @@
+require 'grouped_scope'
+

data/lib/grouped_scope/association_reflection.rb

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,21 @@
+
+class ActiveRecord::Base
+  
+  class << self
+    
+    private
+    
+    def attribute_condition_with_grouped_scope(argument)
+      case argument
+        when GroupedScope::SelfGroupping then "IN (?)"
+        else attribute_condition_without_grouped_scope(argument)
+      end
+    end
+    
+    alias_method_chain :attribute_condition, :grouped_scope
+    
+  end
+  
+end
+
+

data/lib/grouped_scope/errors.rb

@@ -0,0 +1,12 @@
+module GroupedScope
+  
+  class GroupedScopeError < StandardError #:nodoc:
+  end
+  
+  class NoGroupIdError < GroupedScopeError #:nodoc:
+    def initialize(owner) ; @owner = owner ; end
+    def message ; %|The #{@owner.class} class does not have a "group_id" attribute.| ; end
+  end
+  
+  
+end

data/lib/grouped_scope/grouping.rb

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

data/lib/grouped_scope/has_many_association.rb

@@ -0,0 +1,30 @@
+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]
+        # CHANGED [Rails 1.2.6] Account for quoted_table_name.
+        table_name = @reflection.respond_to?(:quoted_table_name) ? @reflection.quoted_table_name : @reflection.klass.table_name
+        if @reflection.options[:as]
+          # TODO: Need to add case for polymorphic :as option.
+        else
+          @finder_sql = "#{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

@@ -0,0 +1,28 @@
+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

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

data/lib/grouped_scope/self_grouping.rb

@@ -0,0 +1,78 @@
+module GroupedScope
+  class SelfGroupping
+    
+    attr_reader :proxy_owner
+    
+    delegate :primary_key, :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
+      end
+    end
+    
+    
+    def initialize(proxy_owner)
+      raise NoGroupIdError.new(proxy_owner) unless proxy_owner.class.column_names.include?('group_id')
+      @proxy_owner = proxy_owner
+    end
+    
+    def ids
+      @ids ||= find_selves(group_id_scope_options).map(&:id)
+    end
+    
+    def quoted_ids
+      ids.map { |id| quote_value(id,columns_hash[primary_key]) }.join(',')
+    end
+    
+    def respond_to?(method, include_private=false)
+      super || !proxy_class.grouped_scopes[method].blank?
+    end
+    
+    
+    protected
+    
+    def group_proxy
+      @group_proxy ||= find_selves(group_scope_options)
+    end
+    
+    def all_grouped?
+      proxy_owner.all_grouped? rescue false
+    end
+    
+    def no_group?
+      proxy_owner.group_id.blank?
+    end
+    
+    def find_selves(options={})
+      proxy_owner.class.find :all, options
+    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 }
+    end
+    
+    def group_id_scope_options
+      { :select => primary_key }.merge(group_scope_options)
+    end
+    
+    def proxy_class
+      proxy_owner.class
+    end
+    
+    
+    private
+    
+    def method_missing(method, *args, &block)
+      if proxy_class.grouped_scopes[method]
+        proxy_owner.send("grouped_scope_#{method}", *args, &block)
+      else
+        super
+      end
+    end
+    
+  end
+end
+

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