aggregate_columns 0.9 → 0.9.1

data/Rakefile

@@ -14,7 +14,7 @@ PKG_FILES = FileList[
 
 spec = Gem::Specification.new do |s|
   s.name = "aggregate_columns"
-  s.version = "0.9"
+  s.version = "0.9.1"
   s.author = "Marek Janukowicz"
   s.email = "marek@janukowicz.net"
   s.homepage = "http://www.bitbucket.org/starware/aggregate_columns"

data/lib/aggregate_columns.rb

@@ -47,42 +47,38 @@ module AggregateColumns
 
   module MethodsRails3
 
-    def aggregate_columns( *aggregates )
+    def aggregate_columns( options )
       rel = self.select( "#{table_name}.*" )
-      aggregates.each do |options|
-        # Process options
-        options.assert_valid_keys( :association, :column, :function, :result_column, :join_type, :conditions, :joins, :order )
-        association = options[:association]
-        unless association
-          raise ArgumentError, "No association given" 
-        end
-        field = options[:column] || '*'
-        function = options[:function] || :count
-        result_column = options[:result_column]
-        unless result_column
-          # Defaults:
-          # count(*) on comments => comment_count
-          # sum(votes) on comment => comments_votes_sum
-          result_column ||= field == '*' ? "#{association.to_s.singularize}_#{function}" : "#{association}_#{field}_#{function}"
-        end
-        # TODO: this only works on ActiveRecord::Base classes - would be nice
-        # (and not that complicated) to make it work on ActiveRecord::Relation
-        # instances
-        assoc_reflection = reflect_on_association( association )
-        foreign_key = assoc_reflection.primary_key_name # As stupid as it looks, this is actually correct
-        aggregate_table_name = assoc_reflection.table_name
-        klass = assoc_reflection.klass
-        join_type = options[:join_type] || "LEFT" # TODO: check if in range of allowed values
-        order = options[:order] || "DESC"
-        conditions = options[:conditions]
-        joins = options[:joins]
-
-        # Now gather params for aggregate
-        rel = rel.
-          joins( "#{join_type.to_s.upcase} JOIN (SELECT #{foreign_key}, #{function}(#{field}) AS #{result_column} FROM #{aggregate_table_name} #{joins}#{" WHERE " + klass.sanitize_sql( conditions ) if conditions } GROUP BY #{foreign_key}) #{result_column}_join ON #{table_name}.id = #{result_column}_join.#{foreign_key}" ).
-          select( result_column.to_s ).
-          order( "#{result_column} #{order.to_s.upcase}" )
+      # Process options
+      options.assert_valid_keys( :association, :column, :function, :result_column, :join_type )
+      association = options[:association]
+      unless association
+        raise ArgumentError, "No association given" 
+      end
+      field = options[:column] || '*'
+      function = options[:function] || :count
+      result_column = options[:result_column]
+      unless result_column
+        # Defaults:
+        # count(*) on comments => comment_count
+        # sum(votes) on comment => comments_votes_sum
+        result_column ||= field == '*' ? "#{association.to_s.singularize}_#{function}" : "#{association}_#{field}_#{function}"
       end
+      # TODO: this only works on ActiveRecord::Base classes - would be nice
+      # (and not that complicated) to make it work on ActiveRecord::Relation
+      # instances
+      assoc_reflection = reflect_on_association( association )
+      foreign_key = assoc_reflection.primary_key_name # As stupid as it looks, this is actually correct
+      aggregate_table_name = assoc_reflection.table_name
+      klass = assoc_reflection.klass
+      join_type = options[:join_type] || "LEFT" # TODO: check if within allowed values
+
+      aggregate_rel = klass.select( "#{foreign_key}, #{function}(#{field}) AS #{result_column}" ).from( aggregate_table_name ).group( foreign_key )
+      aggregate_rel = yield( aggregate_rel ) if block_given?
+      rel = rel.
+        joins( "#{join_type.to_s.upcase} JOIN (#{aggregate_rel.to_sql}) #{result_column}_join ON #{table_name}.id = #{result_column}_join.#{foreign_key}" ).
+        select( result_column.to_s ).
+        order( "#{result_column} DESC" ) # You might reorder if you want to have it differently
       return rel
     end
   end

data/test/aggregate_columns_test.rb

@@ -13,68 +13,68 @@ class AggregateColumnsTest < ActiveSupport::TestCase
     @user = User.new
   end
 
-  test "empty options" do
-    options = User.aggregate_columns_options
-    assert_equal "users.*", options[:select]
-    assert options[:order].blank?
-    assert options[:joins].blank?
-  end
+  #test "empty options" do
+  #  options = User.aggregate_columns_options
+  #  assert_equal "users.*", options[:select]
+  #  assert options[:order].blank?
+  #  assert options[:joins].blank?
+  #end
 
-  test "empty hash as options should fail" do
-    assert_raise( ArgumentError ) do
-      options = User.aggregate_columns_options( {} )
-    end
-  end
+  #test "empty hash as options should fail" do
+  #  assert_raise( ArgumentError ) do
+  #    options = User.aggregate_columns_options( {} )
+  #  end
+  #end
 
-  test "only association" do
-    options = User.aggregate_columns_options( :association => :posts )
-    assert_equal "users.*, post_count", options[:select]
-    assert_equal "post_count DESC", options[:order]
-    assert_equal "LEFT JOIN (SELECT user_id, count(*) AS post_count FROM posts  GROUP BY user_id) post_count_join ON posts.id = post_count_join.user_id", options[:joins]
-  end
+  #test "only association" do
+  #  options = User.aggregate_columns_options( :association => :posts )
+  #  assert_equal "users.*, post_count", options[:select]
+  #  assert_equal "post_count DESC", options[:order]
+  #  assert_equal "LEFT JOIN (SELECT user_id, count(*) AS post_count FROM posts  GROUP BY user_id) post_count_join ON posts.id = post_count_join.user_id", options[:joins]
+  #end
 
-  test "column function" do
-    options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max )
-    assert_equal "users.*, posts_created_at_max", options[:select]
-    assert_equal "posts_created_at_max DESC", options[:order]
-    assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
-  end
+  #test "column function" do
+  #  options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max )
+  #  assert_equal "users.*, posts_created_at_max", options[:select]
+  #  assert_equal "posts_created_at_max DESC", options[:order]
+  #  assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
+  #end
 
-  test "result_column" do
-    options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :result_column => "last_post_time" )
-    assert_equal "users.*, last_post_time", options[:select]
-    assert_equal "last_post_time DESC", options[:order]
-    assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS last_post_time FROM posts  GROUP BY user_id) last_post_time_join ON posts.id = last_post_time_join.user_id", options[:joins]
-  end
+  #test "result_column" do
+  #  options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :result_column => "last_post_time" )
+  #  assert_equal "users.*, last_post_time", options[:select]
+  #  assert_equal "last_post_time DESC", options[:order]
+  #  assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS last_post_time FROM posts  GROUP BY user_id) last_post_time_join ON posts.id = last_post_time_join.user_id", options[:joins]
+  #end
 
-  test "join_type" do
-    options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :join_type => "RIGHT" )
-    assert_equal "users.*, posts_created_at_max", options[:select]
-    assert_equal "posts_created_at_max DESC", options[:order]
-    assert_equal "RIGHT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
-  end
+  #test "join_type" do
+  #  options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :join_type => "RIGHT" )
+  #  assert_equal "users.*, posts_created_at_max", options[:select]
+  #  assert_equal "posts_created_at_max DESC", options[:order]
+  #  assert_equal "RIGHT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
+  #end
 
-  test "conditions" do
-    options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :conditions => { :active => true } )
-    assert_equal "users.*, posts_created_at_max", options[:select]
-    assert_equal "posts_created_at_max DESC", options[:order]
-    assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  WHERE posts.active = true GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
-  end
+  #test "conditions" do
+  #  options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :conditions => { :active => true } )
+  #  assert_equal "users.*, posts_created_at_max", options[:select]
+  #  assert_equal "posts_created_at_max DESC", options[:order]
+  #  assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts  WHERE posts.active = true GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
+  #end
 
-  test "joins" do
-    time = 2.days.ago
-    options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :joins => "INNER JOIN comments ON comments.post_id = posts.id", :conditions => ["comments.updated_at > ?", time] )
-    assert_equal "users.*, posts_created_at_max", options[:select]
-    assert_equal "posts_created_at_max DESC", options[:order]
-    assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts INNER JOIN comments ON comments.post_id = posts.id WHERE comments.updated_at > #{time} GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
-  end
+  #test "joins" do
+  #  time = 2.days.ago
+  #  options = User.aggregate_columns_options( :association => :posts, :column => :created_at, :function => :max, :joins => "INNER JOIN comments ON comments.post_id = posts.id", :conditions => ["comments.updated_at > ?", time] )
+  #  assert_equal "users.*, posts_created_at_max", options[:select]
+  #  assert_equal "posts_created_at_max DESC", options[:order]
+  #  assert_equal "LEFT JOIN (SELECT user_id, max(created_at) AS posts_created_at_max FROM posts INNER JOIN comments ON comments.post_id = posts.id WHERE comments.updated_at > #{time} GROUP BY user_id) posts_created_at_max_join ON posts.id = posts_created_at_max_join.user_id", options[:joins]
+  #end
 
-  test "order" do
-    options = User.aggregate_columns_options( :association => :posts, :order => :asc )
-    assert_equal "users.*, post_count", options[:select]
-    assert_equal "post_count ASC", options[:order]
-    assert_equal "LEFT JOIN (SELECT user_id, count(*) AS post_count FROM posts  GROUP BY user_id) post_count_join ON posts.id = post_count_join.user_id", options[:joins]
-  end
+  #test "order" do
+  #  options = User.aggregate_columns_options( :association => :posts, :order => :asc )
+  #  assert_equal "users.*, post_count", options[:select]
+  #  assert_equal "post_count ASC", options[:order]
+  #  assert_equal "LEFT JOIN (SELECT user_id, count(*) AS post_count FROM posts  GROUP BY user_id) post_count_join ON posts.id = post_count_join.user_id", options[:joins]
+  #end
 
   # TODO:
   # test multiple aggregates

data/test/test_helper.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'test/unit'
-gem 'activesupport', "< 3.0.0"
+gem 'activesupport'#, "< 3.0.0"
 require 'active_support/test_case'
 require 'active_record'
 require 'active_record/base'

metadata

@@ -1,70 +1,50 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: aggregate_columns
-version: !ruby/object:Gem::Version 
-  hash: 25
+version: !ruby/object:Gem::Version
+  version: 0.9.1
   prerelease: 
-  segments: 
-  - 0
-  - 9
-  version: "0.9"
 platform: ruby
-authors: 
+authors:
 - Marek Janukowicz
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-11-23 00:00:00 +01:00
-default_executable: 
+date: 2011-11-29 00:00:00.000000000 Z
 dependencies: []
-
 description: 
 email: marek@janukowicz.net
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README
-files: 
+files:
 - Rakefile
 - README
 - lib/aggregate_columns.rb
 - test/aggregate_columns_test.rb
 - test/test_helper.rb
-has_rdoc: true
 homepage: http://www.bitbucket.org/starware/aggregate_columns
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Create and use aggregate columns in Rails applications
 test_files: []
-