aggregate_columns 0.9.8 → 0.9.9

data/lib/aggregate_columns.rb

@@ -1,135 +1,14 @@
 module AggregateColumns
-
-  module MethodsRails2
-
-    def aggregate_columns_options( *aggregates )
-      all_joins = []
-      all_selects = ["#{table_name}.*"]
-      all_orders = []
-      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
-        assoc_reflection = reflect_on_association( association )
-        foreign_key = assoc_reflection.primary_key_name # As stupid as it looks, this is actually correct
-        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
-        all_joins << "#{join_type.to_s.upcase} JOIN (SELECT #{foreign_key}, #{function}(#{field}) AS #{result_column} FROM #{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}"
-        all_selects << result_column.to_s
-        all_orders << "#{result_column} #{order.to_s.upcase}"
-      end
-      return { :joins => all_joins.join( "\n" ), :select => all_selects.join( ', ' ), :order => all_orders.join( ', ' ) }
-    end
-
-    def aggregate_columns_scope( *aggregates )
-      scoped( aggregate_columns_options( *aggregates ))
-    end
-
-  end
-
-  module MethodsRails3
-
-    def aggregate_columns( options )
-      rel = self.select( "#{table_name}.*" )
-      # Process options
-      options.assert_valid_keys( :association, :column, :function, :result_column, :join_type, :expression )
-      association = options[:association]
-      unless association
-        raise ArgumentError, "No association given" 
-      end
-      #field = options[:column] || '*'
-      #function = options[:function] || :count
-      aggregate_expression = options[:expression]
-      result_column = options[:result_column]
-      unless aggregate_expression
-        field = options[:column] || '*'
-        function = options[:function] || :count
-        aggregate_expression = "#{function}(#{field})"
-        # 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 )
-      # TODO: this only handles single :through association
-      through_reflection = assoc_reflection.through_reflection
-      foreign_key = assoc_reflection.foreign_key
-      aggregate_table_name = assoc_reflection.table_name
-      klass = assoc_reflection.klass
-      join_type = options[:join_type] # TODO: check if within allowed values
-
-      # This is the reflection to use to "join" with main table
-      join_reflection = through_reflection || assoc_reflection
-      join_foreign_key = join_reflection.foreign_key
-      aggregate_rel = klass.select( "#{aggregate_expression} AS #{result_column}" ).from( aggregate_table_name )
-      if through_reflection
-        aggregate_rel = aggregate_rel.joins( "INNER JOIN #{through_reflection.table_name} ON #{through_reflection.table_name}.id = #{aggregate_table_name}.#{assoc_reflection.foreign_key}" )
-      end
-
-      # TODO: this only handles :conditions and in a specific way - it should
-      # really handle other options as well
-      assoc_conditions = assoc_reflection.conditions.first.first
-      if assoc_conditions
-        aggregate_rel = aggregate_rel.where( klass.send( :sanitize_sql, assoc_conditions ))
-      end
-      if through_reflection
-        through_conditions = through_reflection.conditions.first.first
-        if through_conditions
-          aggregate_rel = aggregate_rel.where( through_reflection.klass.send( :sanitize_sql, through_conditions ))
-        end
-      end
-
-      if join_type
-        aggregate_rel = aggregate_rel.select( join_foreign_key ).group( join_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.#{join_foreign_key}" ).
-          select( result_column.to_s ).
-          order( "#{result_column} DESC" ) # You might reorder if you want to have it differently
-      else
-        aggregate_rel = aggregate_rel.where( "#{table_name}.id = #{join_reflection.quoted_table_name}.#{join_reflection.foreign_key}" )
-        aggregate_rel = yield( aggregate_rel ) if block_given?
-        rel = rel.
-          select( "(#{aggregate_rel.to_sql}) AS #{result_column}" ).
-          order( "#{result_column} DESC" ) # You might reorder if you want to have it differently
-      end
-      return rel
-    end
-  end
-
 end
 
-if defined?( ActiveRecord::Relation ) # Rails 3
-  ActiveRecord::Base.send( :extend, AggregateColumns::MethodsRails3 )
-else # Rails 2
+case ActiveRecord::VERSION::MAJOR
+when 2
+  require 'aggregate_columns/methods_rails_2'
   ActiveRecord::Base.send( :extend, AggregateColumns::MethodsRails2 )
+when 3
+  require 'aggregate_columns/methods_rails_3'
+  ActiveRecord::Base.send( :extend, AggregateColumns::MethodsRails3 )
+when 4
+  require 'aggregate_columns/methods_rails_4'
+  ActiveRecord::Base.send( :extend, AggregateColumns::MethodsRails4 )
 end
-
-## Rails 2
-#if defined?( ActiveRecord::NamedScope )
-#  ActiveRecord::Associations::AssociationCollection.send( :include, AggregateColumns::MethodsRails2 )
-#  ActiveRecord::NamedScope::Scope.send( :include, AggregateColumns::MethodsRails2 ) 
-## Rails 3
-#ActiveRecord::Associations::CollectionProxy.send( :include, AggregateColumns::Methods ) if defined?( ActiveRecord::Associations::CollectionProxy )
-#ActiveRecord::Relation.send( :include, AggregateColumns::Methods ) if defined?( ActiveRecord::Relation )

data/lib/aggregate_columns/methods_rails_2.rb

@@ -0,0 +1,47 @@
+module AggregateColumns
+
+  module MethodsRails2
+
+    def aggregate_columns_options( *aggregates )
+      all_joins = []
+      all_selects = ["#{table_name}.*"]
+      all_orders = []
+      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
+        assoc_reflection = reflect_on_association( association )
+        foreign_key = assoc_reflection.primary_key_name # As stupid as it looks, this is actually correct
+        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
+        all_joins << "#{join_type.to_s.upcase} JOIN (SELECT #{foreign_key}, #{function}(#{field}) AS #{result_column} FROM #{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}"
+        all_selects << result_column.to_s
+        all_orders << "#{result_column} #{order.to_s.upcase}"
+      end
+      return { :joins => all_joins.join( "\n" ), :select => all_selects.join( ', ' ), :order => all_orders.join( ', ' ) }
+    end
+
+    def aggregate_columns_scope( *aggregates )
+      scoped( aggregate_columns_options( *aggregates ))
+    end
+
+  end
+end

data/lib/aggregate_columns/methods_rails_3.rb

@@ -0,0 +1,76 @@
+module AggregateColumns
+
+  module MethodsRails3
+
+    def aggregate_columns( options )
+      rel = self.select( "#{table_name}.*" )
+      # Process options
+      options.assert_valid_keys( :association, :column, :function, :result_column, :join_type, :expression )
+      association = options[:association]
+      unless association
+        raise ArgumentError, "No association given" 
+      end
+      #field = options[:column] || '*'
+      #function = options[:function] || :count
+      aggregate_expression = options[:expression]
+      result_column = options[:result_column]
+      unless aggregate_expression
+        field = options[:column] || '*'
+        function = options[:function] || :count
+        aggregate_expression = "#{function}(#{field})"
+        # 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 )
+      # TODO: this only handles single :through association
+      through_reflection = assoc_reflection.through_reflection
+      foreign_key = assoc_reflection.foreign_key
+      aggregate_table_name = assoc_reflection.table_name
+      klass = assoc_reflection.klass
+      join_type = options[:join_type] # TODO: check if within allowed values
+
+      # This is the reflection to use to "join" with main table
+      join_reflection = through_reflection || assoc_reflection
+      join_foreign_key = join_reflection.foreign_key
+      aggregate_rel = klass.select( "#{aggregate_expression} AS #{result_column}" ).from( aggregate_table_name )
+      if through_reflection
+        aggregate_rel = aggregate_rel.joins( "INNER JOIN #{through_reflection.table_name} ON #{through_reflection.table_name}.id = #{aggregate_table_name}.#{assoc_reflection.foreign_key}" )
+      end
+
+      # TODO: this only handles :conditions and in a specific way - it should
+      # really handle other options as well
+      assoc_conditions = assoc_reflection.conditions.first.first
+      if assoc_conditions
+        aggregate_rel = aggregate_rel.where( klass.send( :sanitize_sql, assoc_conditions ))
+      end
+      if through_reflection
+        through_conditions = through_reflection.conditions.first.first
+        if through_conditions
+          aggregate_rel = aggregate_rel.where( through_reflection.klass.send( :sanitize_sql, through_conditions ))
+        end
+      end
+
+      if join_type
+        aggregate_rel = aggregate_rel.select( join_foreign_key ).group( join_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.#{join_foreign_key}" ).
+          select( result_column.to_s ).
+          order( "#{result_column} DESC" ) # You might reorder if you want to have it differently
+      else
+        aggregate_rel = aggregate_rel.where( "#{table_name}.id = #{join_reflection.quoted_table_name}.#{join_reflection.foreign_key}" )
+        aggregate_rel = yield( aggregate_rel ) if block_given?
+        rel = rel.
+          select( "(#{aggregate_rel.to_sql}) AS #{result_column}" ).
+          order( "#{result_column} DESC" ) # You might reorder if you want to have it differently
+      end
+      return rel
+    end
+  end
+
+end

data/lib/aggregate_columns/methods_rails_4.rb

@@ -0,0 +1,71 @@
+module AggregateColumns
+
+  module MethodsRails4
+
+    def aggregate_columns( options )
+      rel = self.select( "#{table_name}.*" )
+      # Process options
+      options.assert_valid_keys( :association, :column, :function, :result_column, :join_type, :expression )
+      association = options[:association]
+      unless association
+        raise ArgumentError, "No association given" 
+      end
+      #field = options[:column] || '*'
+      #function = options[:function] || :count
+      aggregate_expression = options[:expression]
+      result_column = options[:result_column]
+      unless aggregate_expression
+        field = options[:column] || '*'
+        function = options[:function] || :count
+        aggregate_expression = "#{function}(#{field})"
+        # 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 )
+      # TODO: this only handles single :through association
+      through_reflection = assoc_reflection.through_reflection
+      foreign_key = assoc_reflection.foreign_key
+      aggregate_table_name = assoc_reflection.table_name
+      klass = assoc_reflection.klass
+      join_type = options[:join_type] # TODO: check if within allowed values
+
+      # This is the reflection to use to "join" with main table
+      join_reflection = through_reflection || assoc_reflection
+      join_foreign_key = join_reflection.foreign_key
+      aggregate_rel = klass.select( "#{aggregate_expression} AS #{result_column}" ).from( aggregate_table_name )
+      if through_reflection
+        aggregate_rel = aggregate_rel.joins( "INNER JOIN #{through_reflection.table_name} ON #{through_reflection.table_name}.id = #{aggregate_table_name}.#{assoc_reflection.foreign_key}" )
+      end
+
+      # TODO: I never needed this part, so it's completely untested
+      if assoc_reflection.scope
+        aggregate_rel = aggregate_rel.merge( assoc_reflection.scope )
+      end
+      if through_reflection && through_reflection.scope
+        aggregate_rel = aggregate_rel.merge( through_reflection.scope )
+      end
+
+      if join_type
+        aggregate_rel = aggregate_rel.select( join_foreign_key ).group( join_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.#{join_foreign_key}" ).
+          select( result_column.to_s ).
+          order( "#{result_column} DESC" ) # You might reorder if you want to have it differently
+      else
+        aggregate_rel = aggregate_rel.where( "#{table_name}.id = #{join_reflection.quoted_table_name}.#{join_reflection.foreign_key}" )
+        aggregate_rel = yield( aggregate_rel ) if block_given?
+        rel = rel.
+          select( "(#{aggregate_rel.to_sql}) AS #{result_column}" ).
+          order( "#{result_column} DESC" ) # You might reorder if you want to have it differently
+      end
+      return rel
+    end
+  end
+
+end

data/lib/aggregate_columns/version.rb

@@ -1,3 +1,3 @@
 module AggregateColumns
-  VERSION = "0.9.8"
+  VERSION = "0.9.9"
 end

metadata

@@ -1,113 +1,153 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: aggregate_columns
-version: !ruby/object:Gem::Version
-  version: 0.9.8
+version: !ruby/object:Gem::Version 
+  hash: 41
   prerelease: 
+  segments: 
+  - 0
+  - 9
+  - 9
+  version: 0.9.9
 platform: ruby
-authors:
+authors: 
 - Marek Janukowicz/Starware
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2014-12-12 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: activerecord
-  requirement: &7078140 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '2'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
   type: :runtime
-  prerelease: false
-  version_requirements: *7078140
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: rake
-  requirement: &7077260 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *7077260
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: activerecord
-  requirement: &7075460 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '2'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
   type: :development
-  prerelease: false
-  version_requirements: *7075460
-- !ruby/object:Gem::Dependency
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: activesupport
-  requirement: &7073600 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '2'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
   type: :development
-  prerelease: false
-  version_requirements: *7073600
-- !ruby/object:Gem::Dependency
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
   name: activerecord-nulldb-adapter
-  requirement: &7072440 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - =
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 2
+        - 0
         version: 0.2.0
   type: :development
-  prerelease: false
-  version_requirements: *7072440
-description: ''
-email:
+  version_requirements: *id005
+description: ""
+email: 
 - marek@janukowicz.net
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .hgignore
 - Gemfile
 - README
 - Rakefile
 - aggregate_columns.gemspec
 - lib/aggregate_columns.rb
+- lib/aggregate_columns/methods_rails_2.rb
+- lib/aggregate_columns/methods_rails_3.rb
+- lib/aggregate_columns/methods_rails_4.rb
 - lib/aggregate_columns/version.rb
 - test/rails_2_test.rb
 - test/rails_3_test.rb
 - test/test_helper.rb
-homepage: ''
+has_rdoc: true
+homepage: ""
 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
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Create and use aggregate columns in Rails applications
-test_files:
+test_files: 
 - test/rails_2_test.rb
 - test/rails_3_test.rb
 - test/test_helper.rb