weighted_average 0.0.3 → 0.0.4

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/lib/weighted_average.rb

@@ -1,76 +1,74 @@
-require 'active_support'
 require 'active_record'
+require 'active_support'
+require 'active_support/version'
+%w{
+  active_support/core_ext/module
+}.each do |active_support_3_requirement|
+  require active_support_3_requirement
+end if ActiveSupport::VERSION::MAJOR == 3
 
-module ActiveRecord
-  module WeightedAverage
-    # Returns a number
-    def weighted_average(*args)
-      connection.select_value(weighted_average_relation(*args).to_sql, 'weighted_average').to_f
-    end
-    
-    # Returns the ARel relation
-    def weighted_average_relation(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?)
-      
-      # aircraft['seats'] or (aircraft['seats'] + aircraft['payload'])
-      columns = Array.wrap(column_names).map { |column_name| arel_table[column_name.to_s] }
-
-      # :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
-            
-      # AirlineAircraftSeatClass.arel_table
-      foreign_arel_table = association_class.arel_table if association_class
+module WeightedAverage
+  # Returns a number
+  def weighted_average(*args)
+    connection.select_value(weighted_average_relation(*args).to_sql, 'weighted_average').to_f
+  end
 
-      # set up join ON
-      join_on = if association_class
-        raise ArgumentError, "#{association.primary_key_name} isn't a column in the #{association_class.table_name} table" unless association_class.column_names.include?(association.primary_key_name)
-        join_key = association.options[:primary_key].present? ? association.options[:primary_key] : primary_key
-        foreign_arel_table[association.primary_key_name].eq arel_table[join_key]
-      end
-      
-      # 'weighting'
-      weighted_by_column = 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
-      
-      # [foreign_]arel_table['weighting']
-      weighted_by = if foreign_arel_table
-        foreign_arel_table[weighted_by_column]
-      else
-        arel_table[weighted_by_column]
-      end
+  # Returns the ARel relation
+  def weighted_average_relation(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?)
+  
+    # aircraft['seats'] or (aircraft['seats'] + aircraft['payload'])
+    columns = Array.wrap(column_names).map { |column_name| arel_table[column_name.to_s] }
 
-      disaggregate_by = if options[:disaggregate_by].present?
-        raise ArgumentError, "Disaggregating by a foreign table isn't supported right now" if options[:disaggregate_by].is_a?(Array)
-        arel_table[options[:disaggregate_by].to_s]
-      end
+    # :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
+        
+    # AirlineAircraftSeatClass.arel_table
+    foreign_arel_table = association_class.arel_table if association_class
+  
+    # 'weighting'
+    weighted_by_column = 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
+  
+    # [foreign_]arel_table['weighting']
+    weighted_by = if foreign_arel_table
+      foreign_arel_table[weighted_by_column]
+    else
+      arel_table[weighted_by_column]
+    end
 
-      # FIXME
-      # projecting "12345" so that we don't get any other fields back
-      if foreign_arel_table
-        foreign_arel_table = foreign_arel_table.project('12345')
-      end
+    disaggregate_by = if options[:disaggregate_by].present?
+      raise ArgumentError, "Disaggregating by a foreign table isn't supported right now" if options[:disaggregate_by].is_a?(Array)
+      arel_table[options[:disaggregate_by].to_s]
+    end
 
-      relation = select("(SUM((#{columns.map { |column| column.to_sql }.join(' + ')}) #{"/ #{disaggregate_by.to_sql} " if disaggregate_by}* #{weighted_by.to_sql}) / SUM(#{weighted_by.to_sql})) AS weighted_average")
-      columns.each do |column|
-        relation = relation.where("#{column.to_sql} IS NOT NULL")
-      end
-      relation = relation.outer_join(foreign_arel_table).on(join_on) if foreign_arel_table
-      relation
+    relation = select("(SUM((#{columns.map { |column| column.to_sql }.join(' + ')}) #{"/ #{disaggregate_by.to_sql} " if disaggregate_by}* #{weighted_by.to_sql}) / SUM(#{weighted_by.to_sql})) AS weighted_average")
+    columns.each do |column|
+      relation = relation.where("#{column.to_sql} IS NOT NULL")
     end
+    # 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
 
+ActiveRecord::Associations::AssociationCollection.class_eval do
+  delegate :weighted_average, :weighted_average_relation, :to => :scoped
+end
 ActiveRecord::Base.class_eval do
-  extend ActiveRecord::WeightedAverage
-end
+  class << self
+    delegate :weighted_average, :weighted_average_relation, :to => :scoped
+  end
+end
+ActiveRecord::Relation.send :include, WeightedAverage

data/test/helper.rb

@@ -13,6 +13,7 @@ class Test::Unit::TestCase
 end
 
 $logger = Logger.new STDOUT #'test/test.log'
+$logger.level = Logger::INFO
 
 ActiveSupport::Notifications.subscribe do |*args|
   event = ActiveSupport::Notifications::Event.new(*args)
@@ -209,6 +210,8 @@ class Segment < ActiveRecord::Base
   validates_presence_of :row_hash
   extend CohortScope
   self.minimum_cohort_size = 1
+  belongs_to :aircraft, :foreign_key => 'bts_aircraft_type', :primary_key => 'bts_aircraft_type'
+  has_one :aircraft_class, :through => :aircraft
 end
 
 (1..10).each do |i|
@@ -223,30 +226,23 @@ end
 # Segment.create! :payload => 6, :row_hash => 'dsiauhiluashdliufhalsidfhuailsd'
 
 class AirlineAircraftSeatClass < ActiveRecord::Base
-  # include CohortScope
-
-  # belongs_to :airline, :class_name => 'Airline', :foreign_key => 'airline_id'
-  belongs_to :aircraft, :class_name => 'Aircraft', :foreign_key => 'aircraft_id'
-  # belongs_to :seat_class, :class_name => 'SeatClass', :foreign_key => 'seat_class_id'
-  has_one :aircraft_class, :class_name => 'AircraftClass', :through => :aircraft
+  belongs_to :aircraft
+  has_one :aircraft_class, :through => :aircraft
 end
 
 
 class Aircraft < ActiveRecord::Base
-  belongs_to :aircraft_class, :class_name => 'AircraftClass', :foreign_key => 'aircraft_class_id'
-  # belongs_to :manufacturer, :class_name => 'Manufacturer', :foreign_key => 'manufacturer_id'
-  # has_many :airline_aircraft, :class_name => 'AirlineAircraft'
-  # has_many :seat_classes, :class_name => 'AircraftSeatClass'
-  has_many :segments, :class_name => "Segment"
-  has_many :airline_aircraft_seat_classes, :class_name => 'AirlineAircraftSeatClass'
+  has_many :segments, :foreign_key => 'bts_aircraft_type', :primary_key => 'bts_aircraft_type'
+  belongs_to :aircraft_class
+  has_many :airline_aircraft_seat_classes
 end
 
 class AircraftClass < ActiveRecord::Base
-  has_many :aircraft, :class_name => 'Aircraft'
+  has_many :aircraft
   has_many :airline_aircraft_seat_classes, :through => :aircraft
 end
 
 class AircraftDeux < ActiveRecord::Base
   set_primary_key 'icao_code'
-  has_many :segments, :class_name => "Segment", :primary_key => 'my_bts_aircraft_type_code', :foreign_key => 'bts_aircraft_type'
+  has_many :segments, :primary_key => 'my_bts_aircraft_type_code', :foreign_key => 'bts_aircraft_type'
 end

data/test/test_weighted_average.rb

@@ -95,23 +95,23 @@ class TestWeightedAverage < Test::Unit::TestCase
   # fake! we would never calc seats this way
   should "do foreign default weighting" do
     should_have_same_sql(
-      "SELECT (SUM((`aircraft`.`seats`) * `airline_aircraft_seat_classes`.`weighting`) / SUM(`airline_aircraft_seat_classes`.`weighting`)) AS weighted_average, 12345 FROM `aircraft` LEFT OUTER JOIN `airline_aircraft_seat_classes` ON `airline_aircraft_seat_classes`.`aircraft_id` = `aircraft`.`id` WHERE (`aircraft`.`seats` IS NOT NULL)",
+      "SELECT (SUM((`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)",
       Aircraft.weighted_average_relation('seats', :weighted_by => :airline_aircraft_seat_classes)
     )
   end
-  
+    
   # Aircraft#m3 fallback value
   # a subquery used in Aircraft.update_all_m3s
   should "do foreign custom weighting" do
     should_have_same_sql(
-      "SELECT (SUM((`aircraft`.`m3`) * `segments`.`passengers`) / SUM(`segments`.`passengers`)) AS weighted_average, 12345 FROM `aircraft` LEFT OUTER JOIN `segments` ON `segments`.`aircraft_id` = `aircraft`.`id` WHERE (`aircraft`.`m3` IS NOT NULL)",
+      "SELECT (SUM((`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)",
       Aircraft.weighted_average_relation(:m3, :weighted_by => [:segments, :passengers])
     )
   end
   
   should "do foreign custom weighting with custom join keys" do
     should_have_same_sql(
-      "SELECT (SUM((`aircraft_deux`.`m3`) * `segments`.`passengers`) / SUM(`segments`.`passengers`)) AS weighted_average, 12345 FROM `aircraft_deux` LEFT OUTER JOIN `segments` ON `segments`.`bts_aircraft_type` = `aircraft_deux`.`my_bts_aircraft_type_code` WHERE (`aircraft_deux`.`m3` IS NOT NULL)",
+      "SELECT (SUM((`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)",
       AircraftDeux.weighted_average_relation(:m3, :weighted_by => [:segments, :passengers])
     )
   end
@@ -139,7 +139,7 @@ class TestWeightedAverage < Test::Unit::TestCase
   should "do foreign default weighting, scoped" do
     conditions = '454 != 999'
     should_have_same_sql(
-      "SELECT (SUM((`aircraft`.`seats`) * `airline_aircraft_seat_classes`.`weighting`) / SUM(`airline_aircraft_seat_classes`.`weighting`)) AS weighted_average, 12345 FROM `aircraft` LEFT OUTER JOIN `airline_aircraft_seat_classes` ON `airline_aircraft_seat_classes`.`aircraft_id` = `aircraft`.`id` WHERE (#{conditions}) AND (`aircraft`.`seats` IS NOT NULL)",
+      "SELECT (SUM((`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)",
       Aircraft.scoped(:conditions => conditions).weighted_average_relation(:seats, :weighted_by => :airline_aircraft_seat_classes)
     )
   end
@@ -147,7 +147,7 @@ class TestWeightedAverage < Test::Unit::TestCase
   should "do foreign custom weighting, scoped" do
     conditions = '`aircraft`.`m3` > 1'
     should_have_same_sql(
-      "SELECT (SUM((`aircraft`.`m3`) * `segments`.`passengers`) / SUM(`segments`.`passengers`)) AS weighted_average, 12345 FROM `aircraft` LEFT OUTER JOIN `segments` ON `segments`.`aircraft_id` = `aircraft`.`id` WHERE (#{conditions}) AND (`aircraft`.`m3` IS NOT NULL)",
+      "SELECT (SUM((`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)",
       Aircraft.scoped(:conditions => conditions).weighted_average_relation(:m3, :weighted_by => [:segments, :passengers])
     )
   end
@@ -160,6 +160,20 @@ class TestWeightedAverage < Test::Unit::TestCase
       Segment.weighted_average_relation(:load_factor, :weighted_by => :passengers, :disaggregate_by => :departures_performed)
     )
   end
+  
+  # more complicated stuff
+  
+  should "construct weightings across has_many through associations (that can be used for updating all)" do
+    aircraft_class = AircraftClass.arel_table
+    aircraft = Aircraft.arel_table
+    segment = Segment.arel_table
+    
+    should_have_same_sql(
+      "SELECT (SUM((`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 (`segments`.`seats` IS NOT NULL) 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)
 

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Seamus Abshere
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-17 00:00:00 -04:00
+date: 2010-05-18 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency