weighted_average 1.1.0 → 2.0.0

data/.gitignore

@@ -21,3 +21,6 @@ pkg
 ## PROJECT::SPECIFIC
 test/test.log
 Gemfile.lock
+
+.yardoc
+doc/

data/.yardopts

@@ -0,0 +1,2 @@
+--no-private
+--readme README.markdown

data/CHANGELOG

@@ -1,3 +1,12 @@
+2.0.0 / 2012-05-29
+
+* Enhancements
+
+  * Add Arel::SelectManager#weighted_average[_relation]
+  * Add Arel::Table#weighted_average[_relation]
+  * Simpler SQL output
+  * Per-method documentation
+
 1.1.0 / 2012-05-21
 
 * Bug fixes

data/{README.rdoc → README.markdown}

@@ -1,8 +1,8 @@
-= weighted_average
+# weighted_average
 
-Do weighted averages in ActiveRecord.
+Do weighted averages in ARel.
 
-== Rationale
+## Rationale
 
 You have a bunch of flight records with passenger count and distance.
 
@@ -13,9 +13,9 @@ The average distance is <tt>(10_000 + 500) / 2 = 5250</tt>.
 
 The average distance weighted by passenger count is <tt>(30_000 * 500 + 15 * 10_000) / (10_500) = 1442</tt>.
 
-== Usage
+## Usage
 
-Using <tt>FlightSegment</tt> from {Brighter Planet's}[http://brighterplanet.com] {earth gem}[http://rubygems.org/gems/earth]:
+Using <tt>FlightSegment</tt> from [Brighter Planet's earth library](http://rubygems.org/gems/earth):
 
     >> FlightSegment.weighted_average(:distance, :weighted_by => :passengers)
     => 2436.1959
@@ -25,6 +25,6 @@ You can also see the SQL that is generated:
     >> FlightSegment.weighted_average_relation(:distance, :weighted_by => :passengers).to_sql
     => "SELECT (SUM((`flight_segments`.`distance`) * `flight_segments`.`passengers`) / SUM(`flight_segments`.`passengers`)) AS weighted_average FROM `flight_segments` WHERE (`flight_segments`.`distance` IS NOT NULL)"
 
-== Copyright
+## Copyright
 
-Copyright (c) 2010 Seamus Abshere, Andy Rossmeissl, Ian Hough, and Matt Kling. See LICENSE for details.
+Copyright (c) 2012 Brighter Planet, Inc.

data/Rakefile

@@ -7,3 +7,8 @@ Rake::TestTask.new(:test) do |test|
 end
 
 task :default => :test
+
+require 'yard'
+YARD::Rake::YardocTask.new do |y|
+  y.options << '--no-private'
+end

data/lib/weighted_average/active_record_base_class_methods.rb

@@ -0,0 +1,17 @@
+module WeightedAverage
+  module ActiveRecordBaseClassMethods
+    # @see WeightedAverage::ActiveRecordRelationInstanceMethods#weighted_average
+    #
+    # @return [Float,nil]
+    def weighted_average(*args)
+      scoped.weighted_average(*args)
+    end
+    
+    # @see WeightedAverage::ActiveRecordRelationInstanceMethods#weighted_average_relation
+    #
+    # @return [Arel::SelectManager]
+    def weighted_average_relation(*args)
+      scoped.weighted_average_relation(*args)
+    end
+  end
+end

data/lib/weighted_average/active_record_relation_instance_methods.rb

@@ -0,0 +1,62 @@
+module WeightedAverage
+  module ActiveRecordRelationInstanceMethods
+    # Get the weighted average of column(s).
+    #
+    # In addition to the options available on WeightedAverage::ArelSelectManagerInstanceMethods#weighted_average, this ActiveRecord-specific method understands associations.
+    #
+    # @param [Symbol,Array<Symbol>] data_column_names One or more column names whose average should be calculated. Added together before being multiplied by the weighting if more than one.
+    # @param [Hash] options
+    #
+    # @option options [Symbol] :weighted_by The name of an association to weight against OR a column name just like in the pure ARel version.
+    # @option options [Array{Symbol,Symbol}] :weighted_by The name of an association and a weighting column inside that association table to weight against. Not available in the pure ARel version.
+    # @option options [Symbol] :disaggregate_by Same as its meaning in the pure ARel version.
+    #
+    # @example Get the average m3 of all aircraft, weighted by a column named :weighting in flight segments table. But wait... there is no column called :weighting! So see the next example.
+    #   Aircraft.weighted_average(:m3, :weighted_by => :segments)
+    #
+    # @example Get the average m3 of all aircraft, weighted by how many :passengers flew in a particular aircraft.
+    #   Aircraft.weighted_average(:m3, :weighted_by => [:segments, :passengers])
+    #
+    # @see WeightedAverage::ArelSelectManagerInstanceMethods#weighted_average The pure ARel version of this method, which doesn't know about associations
+    #
+    # @return [Float,nil]
+    def weighted_average(data_column_names, options = {})
+      weighted_average = connection.select_value weighted_average_relation(data_column_names, options).to_sql
+      weighted_average.nil? ? nil : weighted_average.to_f
+    end
+
+    # Same as WeightedAverage::ArelSelectManagerInstanceMethods#weighted_average, except it can interpret associations.
+    #
+    # @see WeightedAverage::ArelSelectManagerInstanceMethods#weighted_average_relation The pure ARel version of this method.
+    #
+    # @return [Arel::SelectManager]
+    def weighted_average_relation(data_column_names, options = {})
+      if weighted_by_option = options[:weighted_by]
+        case weighted_by_option
+        when Array
+          # :weighted_by specifies a custom column on an association table (least common)
+          unless association = reflect_on_association(weighted_by_option.first)
+            raise ArgumentError, "#{name} does not have association #{weighted_by_option.first.inspect}"
+          end
+          weighted_by_column = association.klass.arel_table[weighted_by_option.last]
+        when Symbol, String
+          if association = reflect_on_association(weighted_by_option)
+            # :weighted_by specifies an association table with a column named "weighting"
+            weighted_by_column = association.klass.arel_table[DEFAULT_WEIGHTED_BY_COLUMN_NAME]
+          else
+            # :weighted_by specifies a custom column on the same table
+            weighted_by_column = arel_table[weighted_by_option]
+          end
+        end
+        if association
+          joins(association.name).arel.weighted_average_relation data_column_names, options.merge(:weighted_by => weighted_by_column)
+        else
+          arel.weighted_average_relation data_column_names, options.merge(:weighted_by => weighted_by_column)
+        end
+      else
+        arel.weighted_average_relation data_column_names, options
+      end
+    end
+
+  end
+end

data/lib/weighted_average/arel_select_manager_instance_methods.rb

@@ -0,0 +1,72 @@
+module WeightedAverage
+  module ArelSelectManagerInstanceMethods
+    # Calculate the weighted average of column(s).
+    #
+    # @param [Symbol,Array<Symbol>] data_column_names One or more column names whose average should be calculated. Added together before being multiplied by the weighting if more than one.
+    # @param [Hash] options
+    #
+    # @option options [Symbol] :weighted_by The name of the weighting column if it's not :weighting (the default)
+    # @option options [Symbol] :disaggregate_by The name of a column to disaggregate by. Usually not necessary.
+    #
+    # @see WeightedAverage::ActiveRecordRelationInstanceMethods The ActiveRecord-specific version of this method, which knows about associations.
+    #
+    # @example Weighted average of load factor in flight stage data
+    #   Arel::Table.new(:flight_segments).weighted_average(:load_factor, :weighted_by => :passengers)
+    #
+    # @return [Float,nil]
+    def weighted_average(data_column_names, options = {})
+      weighted_average = @engine.connection.select_value(weighted_average_relation(data_column_names, options).to_sql)
+      weighted_average.nil? ? nil : weighted_average.to_f
+    end
+
+    # In case you want to get the relation and/or the SQL of the calculation query before actually runnnig it.
+    #
+    # @example Get the SQL
+    #   Arel::Table.new(:flight_segments).weighted_average_relation(:load_factor, :weighted_by => :passengers).to_sql
+    #
+    # @return [Arel::SelectManager] A relation you can play around with.
+    def weighted_average_relation(data_column_names, options = {})
+      left = self.source.left
+
+      weighted_by_column = case options[:weighted_by]
+      when Arel::Attribute
+        options[:weighted_by]
+      when Symbol, String
+        left[options[:weighted_by]]
+      when NilClass
+        left[DEFAULT_WEIGHTED_BY_COLUMN_NAME]
+      else
+        raise ArgumentError, ":weighted_by => #{options[:weighted_by].inspect} must be a column on #{left.inspect}"
+      end
+      
+      disaggregate_by_column = if options[:disaggregate_by]
+        left[options[:disaggregate_by]]
+      end
+
+      data_columns = ::Array.wrap(data_column_names).map do |data_column_name|
+        left[data_column_name]
+      end
+
+      if disaggregate_by_column
+        self.projections = [Arel::Nodes::Division.new(Arel::Nodes::Sum.new(weighted_by_column * (data_columns.inject(:+)) / disaggregate_by_column * 1.0), Arel::Nodes::Sum.new([weighted_by_column]))]
+      else
+        self.projections = [Arel::Nodes::Division.new(Arel::Nodes::Sum.new(weighted_by_column * (data_columns.inject(:+)) * 1.0), Arel::Nodes::Sum.new([weighted_by_column]))]
+      end
+
+      data_columns_not_eq_nil = data_columns.inject(nil) do |memo, data_column|
+        if memo
+          memo.and(data_column.not_eq(nil))
+        else
+          data_column.not_eq(nil)
+        end
+      end
+
+      if disaggregate_by_column
+        where data_columns_not_eq_nil.and(weighted_by_column.gt(0)).and(disaggregate_by_column.gt(0))
+      else
+        where data_columns_not_eq_nil.and(weighted_by_column.gt(0))
+      end
+    end
+
+  end
+end

data/lib/weighted_average/arel_table_instance_methods.rb

@@ -0,0 +1,17 @@
+module WeightedAverage
+  module ArelTableInstanceMethods
+    # @see WeightedAverage::ArelSelectManagerInstanceMethods#weighted_average
+    #
+    # @return [Float,nil]
+    def weighted_average(*args)
+      from(self).weighted_average(*args)
+    end
+
+    # @see WeightedAverage::ArelSelectManagerInstanceMethods#weighted_average_relation
+    #
+    # @return [Arel::SelectManager]
+    def weighted_average_relation(*args)
+      from(self).weighted_average_relation(*args)
+    end
+  end
+end

data/lib/weighted_average/version.rb

@@ -1,3 +1,3 @@
 module WeightedAverage
-  VERSION = '1.1.0'
+  VERSION = '2.0.0'
 end

data/lib/weighted_average.rb

@@ -1,89 +1,22 @@
+require 'arel'
 require 'active_support/core_ext'
-require 'active_record'
-require "weighted_average/version"
 
 module WeightedAverage
-  # Returns a number.
-  def weighted_average(*args)
-    weighted_average = connection.select_value(weighted_average_relation(*args).to_sql, 'weighted_average')
-    weighted_average.nil? ? nil : weighted_average.to_f
-  end
-
-  # Returns the ARel relation for a weighted average query.
-  def weighted_average_relation(data_column_names, options = {})
-    raise ::ArgumentError, "Only use array form if the weighting column in the foreign table is not called 'weighting'" if options[:weighted_by].is_a?(::Array) and options[:weighted_by].length != 2
-    raise ::ArgumentError, "No nil values in weighted_by, please" if ::Array.wrap(options[:weighted_by]).any?(&:nil?)
-  
-    # :airline_aircraft_seat_class
-    association = if options[:weighted_by].present?
-      options[:weighted_by].is_a?(::Array) ? reflect_on_association(options[:weighted_by].first.to_sym) : reflect_on_association(options[:weighted_by].to_sym)
-    end
-  
-    # AirlineAircraftSeatClass
-    association_class = association.klass if association
-    
-    # `aircraft`
-    table_name = connection.quote_table_name table.name
-
-    # `airline_aircraft_seat_classes`
-    weighted_by_table_name = if association_class
-      association_class.quoted_table_name
-    else
-      table_name
-    end
-      
-    # `airline_aircraft_seat_classes`.`weighting`
-    weighted_by_column_name = if association_class and options[:weighted_by].is_a?(::Array)
-      options[:weighted_by].last.to_s
-    elsif !association_class and (options[:weighted_by].is_a?(::String) or options[:weighted_by].is_a?(::Symbol))
-      options[:weighted_by].to_s
-    else
-      'weighting'
-    end
-    weighted_by_column_name = [ weighted_by_table_name, connection.quote_column_name(weighted_by_column_name) ].join '.'
-    
-    # `aircraft`.`passengers`
-    disaggregate_by_column_name = if options[:disaggregate_by]
-      [ table_name, connection.quote_column_name(options[:disaggregate_by]) ].join '.'
-    end
+  DEFAULT_WEIGHTED_BY_COLUMN_NAME = :weighting
+end
 
-    # [ `aircraft`.`foo`, `aircraft`.`baz` ]
-    data_column_names = ::Array.wrap(data_column_names).map do |data_column_name|
-      [ table_name, connection.quote_column_name(data_column_name) ].join '.'
-    end
+require 'weighted_average/arel_select_manager_instance_methods'
+Arel::SelectManager.send :include, WeightedAverage::ArelSelectManagerInstanceMethods
 
-    relation = select("(SUM(1.0 * (#{data_column_names.join(' + ')}) #{"/ #{disaggregate_by_column_name} " if disaggregate_by_column_name}* #{weighted_by_column_name}) / SUM(#{weighted_by_column_name})) AS weighted_average")
-    data_column_names.each do |data_column_name|
-      relation = relation.where("#{data_column_name} IS NOT NULL")
-    end
+require 'weighted_average/arel_table_instance_methods'
+Arel::Table.send :include, WeightedAverage::ArelTableInstanceMethods
 
-    # avoid division by zero
-    relation = relation.where("#{weighted_by_column_name} > 0")
-    relation = relation.where("#{disaggregate_by_column_name} > 0") if disaggregate_by_column_name
-    
-    # FIXME this will break on through relationships, where it has to be :aircraft => :aircraft_class
-    relation = relation.joins(association.name) if association_class
-    relation
-  end
-end
+if defined?(ActiveRecord)
+  require 'weighted_average/active_record_base_class_methods'
+  ActiveRecord::Base.extend WeightedAverage::ActiveRecordBaseClassMethods
+  proxy_class = defined?(ActiveRecord::Associations::CollectionProxy) ? ActiveRecord::Associations::CollectionProxy : ActiveRecord::Associations::AssociationCollection
+  proxy_class.extend WeightedAverage::ActiveRecordBaseClassMethods
 
-(defined?(::ActiveRecord::Associations::CollectionProxy) ? ::ActiveRecord::Associations::CollectionProxy : ::ActiveRecord::Associations::AssociationCollection).class_eval do
-  def self.weighted_average(*args) # :nodoc:
-    scoped.weighted_average(*args)
-  end
-  
-  def self.weighted_average_relation(*args) # :nodoc:
-    scoped.weighted_average_relation(*args)
-  end
-end
-::ActiveRecord::Base.class_eval do
-  def self.weighted_average(*args) # :nodoc:
-    scoped.weighted_average(*args)
-  end
-  
-  def self.weighted_average_relation(*args) # :nodoc:
-    scoped.weighted_average_relation(*args)
-  end
+  require 'weighted_average/active_record_relation_instance_methods'
+  ActiveRecord::Relation.send :include, WeightedAverage::ActiveRecordRelationInstanceMethods
 end
-
-::ActiveRecord::Relation.send :include, ::WeightedAverage

data/test/helper.rb

@@ -1,6 +1,9 @@
+require 'rubygems'
 require 'bundler/setup'
 require 'minitest/spec'
 require 'minitest/autorun'
+
+require 'active_record'
 require 'cohort_analysis'
 
 require 'weighted_average'

data/test/test_weighted_average.rb

@@ -48,14 +48,14 @@ describe WeightedAverage do
 
   it "does default weighting" do
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (airline_aircraft_seat_classes.seats) * airline_aircraft_seat_classes.weighting) / SUM(airline_aircraft_seat_classes.weighting)) AS weighted_average FROM airline_aircraft_seat_classes WHERE (airline_aircraft_seat_classes.seats IS NOT NULL) AND (airline_aircraft_seat_classes.weighting > 0)",
+      "SELECT SUM(airline_aircraft_seat_classes.weighting * airline_aircraft_seat_classes.seats * 1.0) / SUM(airline_aircraft_seat_classes.weighting) FROM airline_aircraft_seat_classes WHERE airline_aircraft_seat_classes.seats IS NOT NULL AND airline_aircraft_seat_classes.weighting > 0",
       AirlineAircraftSeatClass.weighted_average_relation('seats')
     )
   end
   
   it "does custom weighting" do
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (segments.distance) * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM segments WHERE (segments.distance IS NOT NULL) AND (segments.passengers > 0)",
+      "SELECT SUM(segments.passengers * segments.distance * 1.0) / SUM(segments.passengers) FROM segments WHERE segments.distance IS NOT NULL AND segments.passengers > 0",
       Segment.weighted_average_relation('distance', :weighted_by => 'passengers')
     )
   end
@@ -71,7 +71,7 @@ describe WeightedAverage do
   
   it "adds multiple columns before averaging" do
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (airline_aircraft_seat_classes.seats + airline_aircraft_seat_classes.pitch) * airline_aircraft_seat_classes.weighting) / SUM(airline_aircraft_seat_classes.weighting)) AS weighted_average FROM airline_aircraft_seat_classes WHERE (airline_aircraft_seat_classes.seats IS NOT NULL) AND (airline_aircraft_seat_classes.pitch IS NOT NULL) AND (airline_aircraft_seat_classes.weighting > 0)",
+      "SELECT SUM(airline_aircraft_seat_classes.weighting * (airline_aircraft_seat_classes.seats + airline_aircraft_seat_classes.pitch) * 1.0) / SUM(airline_aircraft_seat_classes.weighting) FROM airline_aircraft_seat_classes WHERE airline_aircraft_seat_classes.seats IS NOT NULL AND airline_aircraft_seat_classes.pitch IS NOT NULL AND airline_aircraft_seat_classes.weighting > 0",
       AirlineAircraftSeatClass.weighted_average_relation(['seats', 'pitch'])
     )
   end
@@ -80,10 +80,10 @@ describe WeightedAverage do
   
   # a subquery used in Aircraft.update_all_seats
   it "does default weighting with conditions" do 
-    conditions = 'aircraft_id = 1'
+    conditions = "aircraft_id = #{rand(1e11)}"
     
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (airline_aircraft_seat_classes.seats) * airline_aircraft_seat_classes.weighting) / SUM(airline_aircraft_seat_classes.weighting)) AS weighted_average FROM airline_aircraft_seat_classes WHERE (#{conditions}) AND (airline_aircraft_seat_classes.seats IS NOT NULL) AND (airline_aircraft_seat_classes.weighting > 0)",
+      "SELECT SUM(airline_aircraft_seat_classes.weighting * airline_aircraft_seat_classes.seats * 1.0) / SUM(airline_aircraft_seat_classes.weighting) FROM airline_aircraft_seat_classes WHERE (#{conditions}) AND airline_aircraft_seat_classes.seats IS NOT NULL AND airline_aircraft_seat_classes.weighting > 0",
       AirlineAircraftSeatClass.where(conditions).weighted_average_relation('seats')
     )
   end
@@ -92,7 +92,7 @@ describe WeightedAverage do
   it "does custom weighting with conditions" do
     conditions = '456 = 456'
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (segments.load_factor) * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM segments WHERE (#{conditions}) AND (segments.load_factor IS NOT NULL) AND (segments.passengers > 0)",
+      "SELECT SUM(segments.passengers * segments.load_factor * 1.0) / SUM(segments.passengers) FROM segments WHERE (456 = 456) AND segments.load_factor IS NOT NULL AND segments.passengers > 0",
       Segment.where(conditions).weighted_average_relation('load_factor', :weighted_by => 'passengers')
     )
   end
@@ -102,7 +102,7 @@ describe WeightedAverage do
   # fake! we would never calc seats this way
   it "does foreign default weighting" do
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (aircraft.seats) * airline_aircraft_seat_classes.weighting) / SUM(airline_aircraft_seat_classes.weighting)) AS weighted_average FROM aircraft INNER JOIN airline_aircraft_seat_classes ON airline_aircraft_seat_classes.aircraft_id = aircraft.id WHERE (aircraft.seats IS NOT NULL) AND (airline_aircraft_seat_classes.weighting > 0)",
+      "SELECT SUM(airline_aircraft_seat_classes.weighting * aircraft.seats * 1.0) / SUM(airline_aircraft_seat_classes.weighting) FROM aircraft INNER JOIN airline_aircraft_seat_classes ON airline_aircraft_seat_classes.aircraft_id = aircraft.id WHERE aircraft.seats IS NOT NULL AND airline_aircraft_seat_classes.weighting > 0",
       Aircraft.weighted_average_relation('seats', :weighted_by => :airline_aircraft_seat_classes)
     )
   end
@@ -111,14 +111,14 @@ describe WeightedAverage do
   # a subquery used in Aircraft.update_all_m3s
   it "does foreign custom weighting" do
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (aircraft.m3) * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM aircraft INNER JOIN segments ON segments.bts_aircraft_type = aircraft.bts_aircraft_type WHERE (aircraft.m3 IS NOT NULL) AND (segments.passengers > 0)",
+      "SELECT SUM(segments.passengers * aircraft.m3 * 1.0) / SUM(segments.passengers) FROM aircraft INNER JOIN segments ON segments.bts_aircraft_type = aircraft.bts_aircraft_type WHERE aircraft.m3 IS NOT NULL AND segments.passengers > 0",
       Aircraft.weighted_average_relation(:m3, :weighted_by => [:segments, :passengers])
     )
   end
   
   it "does foreign custom weighting with custom join keys" do
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (aircraft_deux.m3) * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM aircraft_deux INNER JOIN segments ON segments.bts_aircraft_type = aircraft_deux.my_bts_aircraft_type_code WHERE (aircraft_deux.m3 IS NOT NULL) AND (segments.passengers > 0)",
+      "SELECT SUM(segments.passengers * aircraft_deux.m3 * 1.0) / SUM(segments.passengers) FROM aircraft_deux INNER JOIN segments ON segments.bts_aircraft_type = aircraft_deux.my_bts_aircraft_type_code WHERE aircraft_deux.m3 IS NOT NULL AND segments.passengers > 0",
       AircraftDeux.weighted_average_relation(:m3, :weighted_by => [:segments, :passengers])
     )
   end
@@ -128,7 +128,7 @@ describe WeightedAverage do
   it "does default weighting, scoped" do
     conditions = '456 = 456'
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (airline_aircraft_seat_classes.seats) * airline_aircraft_seat_classes.weighting) / SUM(airline_aircraft_seat_classes.weighting)) AS weighted_average FROM airline_aircraft_seat_classes WHERE (#{conditions}) AND (airline_aircraft_seat_classes.seats IS NOT NULL) AND (airline_aircraft_seat_classes.weighting > 0)",
+      "SELECT SUM(airline_aircraft_seat_classes.weighting * airline_aircraft_seat_classes.seats * 1.0) / SUM(airline_aircraft_seat_classes.weighting) FROM airline_aircraft_seat_classes WHERE (#{conditions}) AND airline_aircraft_seat_classes.seats IS NOT NULL AND airline_aircraft_seat_classes.weighting > 0",
       AirlineAircraftSeatClass.scoped(:conditions => conditions).weighted_average_relation(:seats)
     )
   end
@@ -136,17 +136,17 @@ describe WeightedAverage do
   it "does custom weighting, scoped" do
     conditions = '999 = 999'
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (segments.load_factor) * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM segments WHERE (#{conditions}) AND (segments.load_factor IS NOT NULL) AND (segments.passengers > 0)",
+      "SELECT SUM(segments.passengers * segments.load_factor * 1.0) / SUM(segments.passengers) FROM segments WHERE (#{conditions}) AND segments.load_factor IS NOT NULL AND segments.passengers > 0",
       Segment.scoped(:conditions => conditions).weighted_average_relation(:load_factor, :weighted_by => :passengers)
     )
   end
   
-  # scoped foreign weightings
+  # # scoped foreign weightings
   
   it "does foreign default weighting, scoped" do
     conditions = '454 != 999'
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (aircraft.seats) * airline_aircraft_seat_classes.weighting) / SUM(airline_aircraft_seat_classes.weighting)) AS weighted_average FROM aircraft INNER JOIN airline_aircraft_seat_classes ON airline_aircraft_seat_classes.aircraft_id = aircraft.id WHERE (454 != 999) AND (aircraft.seats IS NOT NULL) AND (airline_aircraft_seat_classes.weighting > 0)",
+      "SELECT SUM(airline_aircraft_seat_classes.weighting * aircraft.seats * 1.0) / SUM(airline_aircraft_seat_classes.weighting) FROM aircraft INNER JOIN airline_aircraft_seat_classes ON airline_aircraft_seat_classes.aircraft_id = aircraft.id WHERE (#{conditions}) AND aircraft.seats IS NOT NULL AND airline_aircraft_seat_classes.weighting > 0",
       Aircraft.scoped(:conditions => conditions).weighted_average_relation(:seats, :weighted_by => :airline_aircraft_seat_classes)
     )
   end
@@ -154,21 +154,21 @@ describe WeightedAverage do
   it "does foreign custom weighting, scoped" do
     conditions = 'aircraft.m3 > 1'
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (aircraft.m3) * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM aircraft INNER JOIN segments ON segments.bts_aircraft_type = aircraft.bts_aircraft_type WHERE (aircraft.m3 > 1) AND (aircraft.m3 IS NOT NULL) AND (segments.passengers > 0)",
+      "SELECT SUM(segments.passengers * aircraft.m3 * 1.0) / SUM(segments.passengers) FROM aircraft INNER JOIN segments ON segments.bts_aircraft_type = aircraft.bts_aircraft_type WHERE (#{conditions}) AND aircraft.m3 IS NOT NULL AND segments.passengers > 0",
       Aircraft.scoped(:conditions => conditions).weighted_average_relation(:m3, :weighted_by => [:segments, :passengers])
     )
   end
   
-  # disaggregation
+  # # disaggregation
   
   it "does custom weighting with disaggregation" do
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (segments.load_factor) / segments.departures_performed * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM segments WHERE (segments.load_factor IS NOT NULL) AND (segments.passengers > 0) AND (segments.departures_performed > 0)",
+      "SELECT SUM(segments.passengers * segments.load_factor / segments.departures_performed * 1.0) / SUM(segments.passengers) FROM segments WHERE segments.load_factor IS NOT NULL AND segments.passengers > 0 AND segments.departures_performed > 0",
       Segment.weighted_average_relation(:load_factor, :weighted_by => :passengers, :disaggregate_by => :departures_performed)
     )
   end
   
-  # more complicated stuff
+  # # more complicated stuff
   
   it "construct weightings across has_many through associations (that can be used for updating all)" do
     aircraft_class = AircraftClass.arel_table
@@ -176,31 +176,41 @@ describe WeightedAverage do
     segment = Segment.arel_table
     
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (segments.seats) * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM segments INNER JOIN aircraft ON aircraft.bts_aircraft_type = segments.bts_aircraft_type INNER JOIN aircraft_classes ON aircraft_classes.id = aircraft.aircraft_class_id WHERE aircraft.aircraft_class_id = aircraft_classes.id AND (segments.seats IS NOT NULL) AND (segments.passengers > 0)",
+      "SELECT SUM(segments.passengers * segments.seats * 1.0) / SUM(segments.passengers) FROM segments INNER JOIN aircraft ON aircraft.bts_aircraft_type = segments.bts_aircraft_type INNER JOIN aircraft_classes ON aircraft_classes.id = aircraft.aircraft_class_id WHERE segments.seats IS NOT NULL AND segments.passengers > 0 AND aircraft.aircraft_class_id = aircraft_classes.id",
       Segment.joins(:aircraft => :aircraft_class).weighted_average_relation(:seats, :weighted_by => :passengers).where(aircraft[:aircraft_class_id].eq(aircraft_class[:id]))
     )
   end
   
 
-  # cohorts (requires the cohort_scope gem)
+  # # cohorts (requires the cohort_analysis gem)
 
   it "does custom weighting, with a cohort" do
     should_have_same_sql(
-      "SELECT (SUM(1.0 * (segments.load_factor) * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM segments WHERE (segments.payload = 5) AND (segments.load_factor IS NOT NULL) AND (segments.passengers > 0)",
+      "SELECT SUM(segments.passengers * segments.load_factor * 1.0) / SUM(segments.passengers) FROM segments WHERE (segments.payload = 5) AND segments.load_factor IS NOT NULL AND segments.passengers > 0",
       Segment.cohort(:payload => 5).weighted_average_relation(:load_factor, :weighted_by => :passengers)
     )
   end
 
-  it "properly picks up table name" do
-    c = Segment.connection
-    c.execute %{
-      CREATE TEMPORARY TABLE moo LIKE #{Segment.quoted_table_name}
-    }
-    relation = ActiveRecord::Relation.new(Segment, Arel::Table.new(:moo))
-    should_have_same_sql(
-      "SELECT (SUM(1.0 * (moo.distance) * moo.passengers) / SUM(moo.passengers)) AS weighted_average FROM moo WHERE (moo.distance IS NOT NULL) AND (moo.passengers > 0)",
-      relation.weighted_average_relation('distance', :weighted_by => 'passengers')
-    )
+  describe "on Arel::Table" do
+    it "works on plain tables" do
+      c = Segment.connection
+      table_name = "plain_arel_table_#{rand(1e11).to_s}"
+      c.execute %{
+        CREATE TEMPORARY TABLE #{table_name} AS SELECT * FROM #{Segment.quoted_table_name} LIMIT 1
+      }
+      table = Arel::Table.new(table_name)
+      should_have_same_sql(
+        "SELECT SUM(#{table_name}.passengers * #{table_name}.distance * 1.0) / SUM(#{table_name}.passengers) FROM #{table_name} WHERE #{table_name}.distance IS NOT NULL AND #{table_name}.passengers > 0",
+        table.weighted_average_relation('distance', :weighted_by => 'passengers')
+      )
+    end
+
+    it "takes complex args" do
+      should_have_same_sql(
+        "SELECT SUM(airline_aircraft_seat_classes.weighting * (airline_aircraft_seat_classes.seats + airline_aircraft_seat_classes.pitch) * 1.0) / SUM(airline_aircraft_seat_classes.weighting) FROM airline_aircraft_seat_classes WHERE airline_aircraft_seat_classes.seats IS NOT NULL AND airline_aircraft_seat_classes.pitch IS NOT NULL AND airline_aircraft_seat_classes.weighting > 0",
+        AirlineAircraftSeatClass.arel_table.weighted_average_relation(['seats', 'pitch'])
+      )
+    end
   end
 
   private

data/weighted_average.gemspec

@@ -17,7 +17,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'activerecord', '~>3'
   s.add_runtime_dependency 'activesupport', '~>3'
   s.add_runtime_dependency 'arel', '>= 2'
   
@@ -26,6 +25,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake'
   s.add_development_dependency 'mysql'
   s.add_development_dependency 'pg'
+  s.add_development_dependency 'activerecord', '~>3'
+  s.add_development_dependency 'yard'
 end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: weighted_average
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -12,24 +12,8 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-21 00:00:00.000000000 Z
+date: 2012-05-29 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '3'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -142,6 +126,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Perform weighted averages, even across associations. Rails 3 only because
   it uses ARel.
 email:
@@ -151,12 +167,17 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .yardopts
 - CHANGELOG
 - Gemfile
 - LICENSE
-- README.rdoc
+- README.markdown
 - Rakefile
 - lib/weighted_average.rb
+- lib/weighted_average/active_record_base_class_methods.rb
+- lib/weighted_average/active_record_relation_instance_methods.rb
+- lib/weighted_average/arel_select_manager_instance_methods.rb
+- lib/weighted_average/arel_table_instance_methods.rb
 - lib/weighted_average/version.rb
 - test/helper.rb
 - test/test_weighted_average.rb