metaskills-grouped_scope 0.5.1

data/test/helper.rb

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__),'lib/boot') unless defined?(ActiveRecord)
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'factory_girl'
+require 'lib/test_case'
+require 'grouped_scope'
+
+class GroupedScope::TestCase
+  
+  def setup_environment(options={})
+    options.reverse_merge! :group_column => :group_id
+    setup_database(options)
+    Department.create! :name => 'IT'
+    Department.create! :name => 'Human Resources'
+    Department.create! :name => 'Finance'
+  end
+  
+  protected
+  
+  def setup_database(options)
+    ActiveRecord::Base.class_eval do
+      silence do
+        connection.create_table :employees, :force => true do |t|
+          t.column :name,         :string
+          t.column :email,        :string
+          t.column options[:group_column],  :integer
+        end
+        connection.create_table :reports, :force => true do |t|
+          t.column :title,        :string
+          t.column :body,         :string
+          t.column :employee_id,  :integer
+        end
+        connection.create_table :departments, :force => true do |t|
+          t.column :name,         :string
+        end
+        connection.create_table :department_memberships, :force => true do |t|
+          t.column :employee_id,    :integer
+          t.column :department_id,  :integer
+          t.column :meta_info,      :string
+        end
+        connection.create_table :legacy_employees, :force => true, :id => false do |t|
+          t.column :name,         :string
+          t.column :email,        :string
+          t.column options[:group_column],  :integer
+        end
+        connection.create_table :legacy_reports, :force => true do |t|
+          t.column :title,        :string
+          t.column :body,         :string
+          t.column :email,        :string
+        end
+        connection.create_table :foo_bars, :force => true do |t|
+          t.column :foo,          :string
+          t.column :bar,          :string
+        end
+      end
+    end
+  end
+  
+end
+
+class Employee < ActiveRecord::Base
+  has_many :reports do ; def urgent ; find(:all,:conditions => {:title => 'URGENT'}) ; end ; end
+  has_many :taxonomies, :as => :classable
+  has_many :department_memberships
+  has_many :departments, :through => :department_memberships
+  grouped_scope :reports, :departments
+end
+
+class Report < ActiveRecord::Base
+  named_scope :with_urgent_title, :conditions => {:title => 'URGENT'}
+  named_scope :with_urgent_body, :conditions => "body LIKE '%URGENT%'"
+  belongs_to :employee
+  def urgent_title? ; self[:title] == 'URGENT' ; end
+  def urgent_body? ; self[:body] =~ /URGENT/ ; end
+end
+
+class Department < ActiveRecord::Base
+  named_scope :it, :conditions => {:name => 'IT'}
+  named_scope :hr, :conditions => {:name => 'Human Resources'}
+  named_scope :finance, :conditions => {:name => 'Finance'}
+  has_many :department_memberships
+  has_many :employees, :through => :department_memberships
+end
+
+class DepartmentMembership < ActiveRecord::Base
+  belongs_to :employee
+  belongs_to :department
+end
+
+class LegacyEmployee < ActiveRecord::Base
+  set_primary_key :email
+  has_many :reports, :class_name => 'LegacyReport', :foreign_key => 'email'
+  grouped_scope :reports
+  alias_method :email=, :id=
+end
+
+class LegacyReport < ActiveRecord::Base
+  belongs_to :employee, :class_name => 'LegacyEmployee', :foreign_key => 'email'
+end
+
+class FooBar < ActiveRecord::Base
+  has_many :reports
+  grouped_scope :reports
+end
+
+
+

data/test/lib/boot.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+
+plugin_root     = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+framework_root  = ["#{plugin_root}/rails", "#{plugin_root}/../../rails"].detect { |p| File.directory? p }
+rails_version   = ENV['RAILS_VERSION']
+rails_version   = nil if rails_version && rails_version == ''
+
+['.','lib','test'].each do |plugin_lib|
+  load_path = File.expand_path("#{plugin_root}/#{plugin_lib}")
+  $LOAD_PATH.unshift(load_path) unless $LOAD_PATH.include?(load_path)
+end
+
+if rails_version.nil? && framework_root
+  puts "Found framework root: #{framework_root}"
+  $:.unshift "#{framework_root}/activesupport/lib", "#{framework_root}/activerecord/lib"
+else
+  puts "Using rails#{" #{rails_version}" if rails_version} from gems"
+  if rails_version
+    gem 'rails', rails_version
+  else
+    gem 'activerecord'
+  end
+end
+
+require 'active_record'
+require 'active_support'
+
+gem 'mislav-will_paginate', '2.3.4'
+require 'will_paginate'
+WillPaginate.enable_activerecord
+require 'named_scope'
+

data/test/lib/core_ext.rb

@@ -0,0 +1,20 @@
+
+unless Hash.instance_methods.include? 'except'
+  
+  Hash.class_eval do
+    
+    # Returns a new hash without the given keys.
+    def except(*keys)
+      rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| rejected.include?(key) }
+    end
+ 
+    # Replaces the hash without only the given keys.
+    def except!(*keys)
+      replace(except(*keys))
+    end
+    
+  end
+  
+end
+

data/test/lib/named_scope/core_ext.rb

@@ -0,0 +1,82 @@
+
+unless Hash.instance_methods.include? 'except'
+  Hash.class_eval do
+    
+    # Returns a new hash without the given keys.
+    def except(*keys)
+      rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| rejected.include?(key) }
+    end
+ 
+    # Replaces the hash without only the given keys.
+    def except!(*keys)
+      replace(except(*keys))
+    end
+    
+  end
+end
+
+class ActiveRecord::Base
+  class << self
+    
+    def first(*args)
+      find(:first, *args)
+    end
+
+    def last(*args)
+      find(:last, *args)
+    end
+
+    def all(*args)
+      find(:all, *args)
+    end
+    
+    private
+    
+    def find_last(options)
+      order = options[:order]
+      if order
+        order = reverse_sql_order(order)
+      elsif !scoped?(:find, :order)
+        order = "#{table_name}.#{primary_key} DESC"
+      end
+      if scoped?(:find, :order)
+        scoped_order = reverse_sql_order(scope(:find, :order))
+        scoped_methods.select { |s| s[:find].update(:order => scoped_order) }
+      end
+      find_initial(options.merge({ :order => order }))
+    end
+    
+    def reverse_sql_order(order_query)
+      reversed_query = order_query.split(/,/).each { |s|
+        if s.match(/\s(asc|ASC)$/)
+          s.gsub!(/\s(asc|ASC)$/, ' DESC')
+        elsif s.match(/\s(desc|DESC)$/)
+          s.gsub!(/\s(desc|DESC)$/, ' ASC')
+        elsif !s.match(/\s(asc|ASC|desc|DESC)$/)
+          s.concat(' DESC')
+        end
+      }.join(',')
+    end
+    
+  end
+end
+
+ActiveRecord::Associations::AssociationCollection.class_eval do
+  
+  def last(*args)
+    if fetch_first_or_last_using_find? args
+      find(:last, *args)
+    else
+      load_target unless loaded?
+      @target.last(*args)
+    end
+  end
+  
+  private
+  
+  def fetch_first_or_last_using_find?(args)
+    args.first.kind_of?(Hash) || !(loaded? || @owner.new_record? || @reflection.options[:finder_sql] || !@target.blank? || args.first.kind_of?(Integer))
+  end
+  
+end

data/test/lib/named_scope/named_scope.rb

@@ -0,0 +1,168 @@
+module ActiveRecord
+  module NamedScope
+    # All subclasses of ActiveRecord::Base have two named_scopes:
+    # * <tt>all</tt>, which is similar to a <tt>find(:all)</tt> query, and
+    # * <tt>scoped</tt>, which allows for the creation of anonymous scopes, on the fly: <tt>Shirt.scoped(:conditions => {:color => 'red'}).scoped(:include => :washing_instructions)</tt>
+    #
+    # These anonymous scopes tend to be useful when procedurally generating complex queries, where passing
+    # intermediate values (scopes) around as first-class objects is convenient.
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        named_scope :scoped, lambda { |scope| scope }
+      end
+    end
+
+    module ClassMethods
+      def scopes
+        read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+      end
+
+      # Adds a class method for retrieving and querying objects. A scope represents a narrowing of a database query,
+      # such as <tt>:conditions => {:color => :red}, :select => 'shirts.*', :include => :washing_instructions</tt>.
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :red, :conditions => {:color => 'red'}
+      #     named_scope :dry_clean_only, :joins => :washing_instructions, :conditions => ['washing_instructions.dry_clean_only = ?', true]
+      #   end
+      # 
+      # The above calls to <tt>named_scope</tt> define class methods <tt>Shirt.red</tt> and <tt>Shirt.dry_clean_only</tt>. <tt>Shirt.red</tt>, 
+      # in effect, represents the query <tt>Shirt.find(:all, :conditions => {:color => 'red'})</tt>.
+      #
+      # Unlike Shirt.find(...), however, the object returned by <tt>Shirt.red</tt> is not an Array; it resembles the association object
+      # constructed by a <tt>has_many</tt> declaration. For instance, you can invoke <tt>Shirt.red.find(:first)</tt>, <tt>Shirt.red.count</tt>,
+      # <tt>Shirt.red.find(:all, :conditions => {:size => 'small'})</tt>. Also, just
+      # as with the association objects, name scopes acts like an Array, implementing Enumerable; <tt>Shirt.red.each(&block)</tt>,
+      # <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if Shirt.red really were an Array.
+      #
+      # These named scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are both red and dry clean only.
+      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt> returns the number of garments
+      # for which these criteria obtain. Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
+      #
+      # All scopes are available as class methods on the ActiveRecord::Base descendent upon which the scopes were defined. But they are also available to
+      # <tt>has_many</tt> associations. If,
+      #
+      #   class Person < ActiveRecord::Base
+      #     has_many :shirts
+      #   end
+      #
+      # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of Elton's red, dry clean
+      # only shirts.
+      #
+      # Named scopes can also be procedural.
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :colored, lambda { |color|
+      #       { :conditions => { :color => color } }
+      #     }
+      #   end
+      #
+      # In this example, <tt>Shirt.colored('puce')</tt> finds all puce shirts.
+      #
+      # Named scopes can also have extensions, just as with <tt>has_many</tt> declarations:
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :red, :conditions => {:color => 'red'} do
+      #       def dom_id
+      #         'red_shirts'
+      #       end
+      #     end
+      #   end
+      #
+      #
+      # For testing complex named scopes, you can examine the scoping options using the
+      # <tt>proxy_options</tt> method on the proxy itself.
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     named_scope :colored, lambda { |color|
+      #       { :conditions => { :color => color } }
+      #     }
+      #   end
+      #
+      #   expected_options = { :conditions => { :colored => 'red' } }
+      #   assert_equal expected_options, Shirt.colored('red').proxy_options
+      def named_scope(name, options = {}, &block)
+        name = name.to_sym
+        scopes[name] = lambda do |parent_scope, *args|
+          Scope.new(parent_scope, case options
+            when Hash
+              options
+            when Proc
+              options.call(*args)
+          end, &block)
+        end
+        (class << self; self end).instance_eval do
+          define_method name do |*args|
+            scopes[name].call(self, *args)
+          end
+        end
+      end
+    end
+    
+    class Scope
+      attr_reader :proxy_scope, :proxy_options
+
+      [].methods.each do |m|
+        unless m =~ /(^__|^nil\?|^send|^object_id$|class|extend|^find$|count|sum|average|maximum|minimum|paginate|first|last|empty\?|respond_to\?)/
+          delegate m, :to => :proxy_found
+        end
+      end
+
+      delegate :scopes, :with_scope, :to => :proxy_scope
+
+      def initialize(proxy_scope, options, &block)
+        [options[:extend]].flatten.each { |extension| extend extension } if options[:extend]
+        extend Module.new(&block) if block_given?
+        @proxy_scope, @proxy_options = proxy_scope, options.except(:extend)
+      end
+
+      def reload
+        load_found; self
+      end
+
+      def first(*args)
+        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
+          proxy_found.first(*args)
+        else
+          find(:first, *args)
+        end
+      end
+
+      def last(*args)
+        if args.first.kind_of?(Integer) || (@found && !args.first.kind_of?(Hash))
+          proxy_found.last(*args)
+        else
+          find(:last, *args)
+        end
+      end
+
+      def empty?
+        @found ? @found.empty? : count.zero?
+      end
+
+      def respond_to?(method, include_private = false)
+        super || @proxy_scope.respond_to?(method, include_private)
+      end
+
+      protected
+      def proxy_found
+        @found || load_found
+      end
+
+      private
+      def method_missing(method, *args, &block)
+        if scopes.include?(method)
+          scopes[method].call(self, *args)
+        else
+          with_scope :find => proxy_options do
+            proxy_scope.send(method, *args, &block)
+          end
+        end
+      end
+
+      def load_found
+        @found = find(:all)
+      end
+    end
+  end
+end

data/test/lib/named_scope/named_scope_patch_1.2.rb

@@ -0,0 +1,85 @@
+
+ActiveRecord::Associations::AssociationProxy.class_eval do
+  protected
+  def with_scope(*args, &block)
+    @reflection.klass.send :with_scope, *args, &block
+  end
+end
+
+class ActiveRecord::Base
+  class << self
+    def find(*args)
+      options = extract_options_from_args!(args)
+      validate_find_options(options)
+      set_readonly_option!(options)
+      case args.first
+        when :first then find_initial(options)
+        when :last  then find_last(options)
+        when :all   then find_every(options)
+        else             find_from_ids(args, options)
+      end
+    end
+    private
+    def attribute_condition_with_named_scope(argument)
+      case argument
+        when ActiveRecord::Associations::AssociationCollection, ActiveRecord::NamedScope::Scope then "IN (?)"
+        else attribute_condition_without_named_scope(argument)
+      end
+    end
+    alias_method_chain :attribute_condition, :named_scope
+  end
+end
+
+ActiveRecord::Associations::HasManyAssociation.class_eval do
+  protected
+  def method_missing(method, *args, &block)
+    if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
+      super
+    elsif @reflection.klass.scopes.include?(method)
+      @reflection.klass.scopes[method].call(self, *args)
+    else
+      create_scoping = {}
+      set_belongs_to_association_for(create_scoping)
+
+      @reflection.klass.with_scope(
+        :create => create_scoping,
+        :find => {
+          :conditions => @finder_sql, 
+          :joins      => @join_sql, 
+          :readonly   => false
+        }
+      ) do
+        @reflection.klass.send(method, *args, &block)
+      end
+    end
+  end
+end
+
+ActiveRecord::Associations::HasManyThroughAssociation.class_eval do
+  protected
+  def method_missing(method, *args, &block)
+    if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
+      super
+    elsif @reflection.klass.scopes.include?(method)
+      @reflection.klass.scopes[method].call(self, *args)
+    else
+      @reflection.klass.with_scope(construct_scope) { @reflection.klass.send(method, *args, &block) }
+    end
+  end
+end
+
+ActiveRecord::Associations::HasAndBelongsToManyAssociation.class_eval do
+  protected
+  def method_missing(method, *args, &block)
+    if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
+      super
+    elsif @reflection.klass.scopes.include?(method)
+      @reflection.klass.scopes[method].call(self, *args)
+    else
+      @reflection.klass.with_scope(:find => { :conditions => @finder_sql, :joins => @join_sql, :readonly => false }) do
+        @reflection.klass.send(method, *args, &block)
+      end
+    end
+  end
+end
+