weighted_average 0.0.6 → 1.0.0

data/.gitignore

@@ -20,3 +20,4 @@ pkg
 
 ## PROJECT::SPECIFIC
 test/test.log
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Rakefile

@@ -1,26 +1,6 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "weighted_average"
-    gem.summary = %Q{Perform weighted averages. Rails 3 only.}
-    gem.description = %Q{Perform weighted averages, even across associations. Rails 3 only because it uses ARel.}
-    gem.email = "seamus@abshere.net"
-    gem.homepage = "http://github.com/seamusabshere/weighted_average"
-    gem.authors = ["Seamus Abshere", "Andy Rossmeissl", "Ian Hough", "Matt Kling"]
-    gem.add_dependency 'activerecord', '~>3'
-    gem.add_dependency 'arel', '~>2'
-    gem.add_development_dependency 'cohort_scope', '>=0.0.2'
-    gem.add_development_dependency "shoulda", ">= 2.10.3"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
+require "bundler/gem_tasks"
 
+require 'rake'
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
@@ -28,29 +8,4 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
-
-task :test => :check_dependencies
-
 task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "weighted_average #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/lib/weighted_average.rb

@@ -1,4 +1,6 @@
+require 'active_support/core_ext'
 require 'active_record'
+require "weighted_average/version"
 
 module WeightedAverage
   # Returns a number.
@@ -8,12 +10,12 @@ module WeightedAverage
 
   # 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?)
+    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)
+      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
@@ -27,9 +29,9 @@ module WeightedAverage
     end
       
     # `airline_aircraft_seat_classes`.`weighting`
-    weighted_by_column_name = if association_class and options[:weighted_by].is_a?(Array)
+    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))
+    elsif !association_class and (options[:weighted_by].is_a?(::String) or options[:weighted_by].is_a?(::Symbol))
       options[:weighted_by].to_s
     else
       'weighting'
@@ -42,7 +44,7 @@ module WeightedAverage
     end
 
     # [ `aircraft`.`foo`, `aircraft`.`baz` ]
-    data_column_names = Array.wrap(data_column_names).map do |data_column_name|
+    data_column_names = ::Array.wrap(data_column_names).map do |data_column_name|
       [ quoted_table_name, connection.quote_column_name(data_column_name) ].join '.'
     end
 
@@ -50,13 +52,18 @@ module WeightedAverage
     data_column_names.each do |data_column_name|
       relation = relation.where("#{data_column_name} IS NOT NULL")
     end
+
+    # 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
 
-ActiveRecord::Associations::AssociationCollection.class_eval do
+(defined?(::ActiveRecord::Associations::CollectionProxy) ? ::ActiveRecord::Associations::CollectionProxy : ::ActiveRecord::Associations::AssociationCollection).class_eval do
   def self.weighted_average(*args) # :nodoc:
     scoped.weighted_average(*args)
   end
@@ -65,7 +72,7 @@ ActiveRecord::Associations::AssociationCollection.class_eval do
     scoped.weighted_average_relation(*args)
   end
 end
-ActiveRecord::Base.class_eval do
+::ActiveRecord::Base.class_eval do
   def self.weighted_average(*args) # :nodoc:
     scoped.weighted_average(*args)
   end
@@ -75,4 +82,4 @@ ActiveRecord::Base.class_eval do
   end
 end
 
-ActiveRecord::Relation.send :include, WeightedAverage
+::ActiveRecord::Relation.send :include, ::WeightedAverage

data/lib/weighted_average/version.rb

@@ -0,0 +1,3 @@
+module WeightedAverage
+  VERSION = '1.0.0'
+end

data/test/helper.rb

@@ -1,19 +1,19 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-unless RUBY_VERSION >= '1.9'
-  require 'ruby-debug'
-end
-require 'logger'
+require 'bundler/setup'
+require 'minitest/spec'
+require 'minitest/autorun'
 require 'cohort_scope'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'weighted_average'
 
-class Test::Unit::TestCase
+class MiniTest::Unit::TestCase
 end
 
+# require 'logger'
+# ActiveRecord::Base.logger = Logger.new($stderr)
+# ActiveRecord::Base.logger.level = Logger::DEBUG
+
 $logger = Logger.new STDOUT #'test/test.log'
 $logger.level = Logger::INFO
 
@@ -22,12 +22,25 @@ ActiveSupport::Notifications.subscribe do |*args|
   $logger.debug "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
 end
 
-ActiveRecord::Base.establish_connection(
-  'adapter' => 'mysql',
-  'database' => 'weighted_average_test',
-  'username' => 'root',
-  'password' => 'password'
-)
+config = {
+  :host => '127.0.0.1',
+  :database => 'test_weighted_average'
+}
+
+extra = if ENV['WEIGHTED_AVERAGE_TEST_ADAPTER'] == 'postgresql'
+  {
+    :adapter => 'postgresql',
+    :username => `whoami`.chomp,
+  }
+else
+  {
+    :adapter => 'mysql',
+    :username => 'root',
+    :password => 'password'
+  }
+end
+
+ActiveRecord::Base.establish_connection config.merge(extra)
 
 ActiveSupport::Inflector.inflections do |inflect|
   inflect.uncountable %w{aircraft airline_aircraft aircraft_deux AircraftDeux}
@@ -40,7 +53,7 @@ ActiveSupport::Inflector.inflections do |inflect|
 end
 
 ActiveRecord::Schema.define(:version => 20090819143429) do
-  create_table "segments", :force => true, :options => 'ENGINE=InnoDB default charset=utf8', :id => false do |t|
+  create_table "segments", :force => true, :id => false do |t|
     t.integer  "aircraft_id" # should this be here?
     t.integer  "departures_performed"
     t.integer  "payload"
@@ -219,7 +232,7 @@ end
 (1..10).each do |i|
   a = Segment.new
   a.payload = i
-  a.row_hash = ActiveSupport::SecureRandom.hex(10)
+  a.row_hash = SecureRandom.hex(10)
   a.save!
 end
 

data/test/test_weighted_average.rb

@@ -1,70 +1,70 @@
 require 'helper'
 
-class TestWeightedAverage < Test::Unit::TestCase
-  # should "update all weighted averages, has_many through" do
+describe WeightedAverage do
+  # it "update all weighted averages, has_many through" do
   #   should_have_same_sql(
   #     AircraftClass.construct_update_all_weighted_averages_sql(:seats, :association => :airline_aircraft_seat_classes),
-  #     "UPDATE `aircraft_classes` SET `aircraft_classes`.seats = (SELECT (SUM((`airline_aircraft_seat_classes`.seats * `airline_aircraft_seat_classes`.weighting) / SUM(`airline_aircraft_seat_classes`.weighting)) AS weighted_average FROM `airline_aircraft_seat_classes`  LEFT OUTER JOIN `aircraft` ON `aircraft`.id = `airline_aircraft_seat_classes`.aircraft_id     WHERE ((`aircraft`.aircraft_class_id = `aircraft_classes`.id AND `airline_aircraft_seat_classes`.aircraft_id = `aircraft`.id) AND (`airline_aircraft_seat_classes`.seats IS NOT NULL)) )"
+  #     "UPDATE aircraft_classes SET aircraft_classes.seats = (SELECT (SUM((airline_aircraft_seat_classes.seats * airline_aircraft_seat_classes.weighting) / SUM(airline_aircraft_seat_classes.weighting)) AS weighted_average FROM airline_aircraft_seat_classes  LEFT OUTER JOIN aircraft ON aircraft.id = airline_aircraft_seat_classes.aircraft_id     WHERE ((aircraft.aircraft_class_id = aircraft_classes.id AND airline_aircraft_seat_classes.aircraft_id = aircraft.id) AND (airline_aircraft_seat_classes.seats IS NOT NULL)) )"
   #   )
   # end
   # 
-  # should "update all weighted averages" do
+  # it "update all weighted averages" do
   #   should_have_same_sql(
   #     Aircraft.construct_update_all_weighted_averages_sql(:seats, :association => :airline_aircraft_seat_classes),
-  #     "UPDATE `aircraft` SET `aircraft`.seats = (SELECT (SUM((`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`.aircraft_id = `aircraft`.id) AND (`airline_aircraft_seat_classes`.seats IS NOT NULL)) )"
+  #     "UPDATE aircraft SET aircraft.seats = (SELECT (SUM((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.aircraft_id = aircraft.id) AND (airline_aircraft_seat_classes.seats IS NOT NULL)) )"
   #   )
   # 
   #   should_have_same_sql(
   #     Aircraft.construct_update_all_weighted_averages_sql(:seats, :association => :airline_aircraft_seat_classes),
-  #     "UPDATE `aircraft` SET `aircraft`.seats = (#{AirlineAircraftSeatClass.construct_weighted_average_sql(:seats, {}, :conditions => '`airline_aircraft_seat_classes`.aircraft_id = `aircraft`.id')})"
+  #     "UPDATE aircraft SET aircraft.seats = (#{AirlineAircraftSeatClass.construct_weighted_average_sql(:seats, {}, :conditions => 'airline_aircraft_seat_classes.aircraft_id = aircraft.id')})"
   #   )
   # end
   # 
-  # should "update all weighted averages, custom weighting" do
+  # it "update all weighted averages, custom weighting" do
   #   should_have_same_sql(
   #     Aircraft.construct_update_all_weighted_averages_sql(:distance, :by => :passengers, :association => :segments),
-  #     "UPDATE `aircraft` SET `aircraft`.distance = (SELECT (SUM((`segments`.distance * `segments`.passengers) / SUM(`segments`.passengers)) AS weighted_average FROM `segments` WHERE ((`segments`.aircraft_id = `aircraft`.id) AND (`segments`.distance IS NOT NULL)) )"
+  #     "UPDATE aircraft SET aircraft.distance = (SELECT (SUM((segments.distance * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM segments WHERE ((segments.aircraft_id = aircraft.id) AND (segments.distance IS NOT NULL)) )"
   #   )
   # 
   #   should_have_same_sql(
   #     Aircraft.construct_update_all_weighted_averages_sql(:distance, :by => :passengers, :association => :segments),
-  #     "UPDATE `aircraft` SET `aircraft`.distance = (#{Segment.construct_weighted_average_sql(:distance, { :by => :passengers }, :conditions => '`segments`.aircraft_id = `aircraft`.id' )})"
+  #     "UPDATE aircraft SET aircraft.distance = (#{Segment.construct_weighted_average_sql(:distance, { :by => :passengers }, :conditions => 'segments.aircraft_id = aircraft.id' )})"
   #   )
   # end
   # 
-  # should "update all weighted averages, custom weighting and disaggregator" do
+  # it "update all weighted averages, custom weighting and disaggregator" do
   #   should_have_same_sql(
   #     Aircraft.construct_update_all_weighted_averages_sql(:payload, :by => :passengers, :association => :segments, :disaggregator => :departures_performed),
-  #     "UPDATE `aircraft` SET `aircraft`.payload = (SELECT (SUM((`segments`.payload / `segments`.departures_performed * `segments`.passengers) / SUM(`segments`.passengers)) AS weighted_average FROM `segments` WHERE ((`segments`.aircraft_id = `aircraft`.id) AND (`segments`.payload IS NOT NULL)) )"
+  #     "UPDATE aircraft SET aircraft.payload = (SELECT (SUM((segments.payload / segments.departures_performed * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM segments WHERE ((segments.aircraft_id = aircraft.id) AND (segments.payload IS NOT NULL)) )"
   #   )
   # 
   #   should_have_same_sql(
   #     Aircraft.construct_update_all_weighted_averages_sql(:payload, :by => :passengers, :association => :segments, :disaggregator => :departures_performed),
-  #     "UPDATE `aircraft` SET `aircraft`.payload = (#{Segment.construct_weighted_average_sql(:payload, { :by => :passengers, :disaggregator => :departures_performed }, :conditions => '`segments`.aircraft_id = `aircraft`.id')})"
+  #     "UPDATE aircraft SET aircraft.payload = (#{Segment.construct_weighted_average_sql(:payload, { :by => :passengers, :disaggregator => :departures_performed }, :conditions => 'segments.aircraft_id = aircraft.id')})"
   #   )
   # end
 
   # plain
 
-  should "do default weighting" do
+  it "does default weighting" do
     should_have_same_sql(
-      "SELECT (SUM((`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)",
+      "SELECT (SUM((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)",
       AirlineAircraftSeatClass.weighted_average_relation('seats')
     )
   end
   
-  should "do custom weighting" do
+  it "does custom weighting" do
     should_have_same_sql(
-      "SELECT (SUM((`segments`.`distance`) * `segments`.`passengers`) / SUM(`segments`.`passengers`)) AS weighted_average FROM `segments` WHERE (`segments`.`distance` IS NOT NULL)",
+      "SELECT (SUM((segments.distance) * segments.passengers) / SUM(segments.passengers)) AS weighted_average FROM segments WHERE (segments.distance IS NOT NULL) AND (segments.passengers > 0)",
       Segment.weighted_average_relation('distance', :weighted_by => 'passengers')
     )
   end
   
   # multiple columns
   
-  should "add multiple columns before averaging" do
+  it "adds multiple columns before averaging" do
     should_have_same_sql(
-      "SELECT (SUM((`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)",
+      "SELECT (SUM((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)",
       AirlineAircraftSeatClass.weighted_average_relation(['seats', 'pitch'])
     )
   end
@@ -72,20 +72,20 @@ class TestWeightedAverage < Test::Unit::TestCase
   # conditions
   
   # a subquery used in Aircraft.update_all_seats
-  should "do default weighting with conditions" do 
+  it "does default weighting with conditions" do 
     conditions = 'aircraft_id = 1'
     
     should_have_same_sql(
-      "SELECT (SUM((`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)",
+      "SELECT (SUM((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)",
       AirlineAircraftSeatClass.where(conditions).weighted_average_relation('seats')
     )
   end
   
   # note fake condition
-  should "do custom weighting with conditions" do
+  it "does custom weighting with conditions" do
     conditions = '456 = 456'
     should_have_same_sql(
-      "SELECT (SUM((`segments`.`load_factor`) * `segments`.`passengers`) / SUM(`segments`.`passengers`)) AS weighted_average FROM `segments` WHERE (#{conditions}) AND (`segments`.`load_factor` IS NOT NULL)",
+      "SELECT (SUM((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)",
       Segment.where(conditions).weighted_average_relation('load_factor', :weighted_by => 'passengers')
     )
   end
@@ -93,83 +93,83 @@ class TestWeightedAverage < Test::Unit::TestCase
   # foreign weightings
   
   # fake! we would never calc seats this way
-  should "do foreign default weighting" do
+  it "does 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 FROM `aircraft` INNER 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) AND (airline_aircraft_seat_classes.weighting > 0)",
       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
+  it "does foreign custom weighting" do
     should_have_same_sql(
-      "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)",
+      "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) AND (segments.passengers > 0)",
       Aircraft.weighted_average_relation(:m3, :weighted_by => [:segments, :passengers])
     )
   end
   
-  should "do foreign custom weighting with custom join keys" do
+  it "does 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 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)",
+      "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) AND (segments.passengers > 0)",
       AircraftDeux.weighted_average_relation(:m3, :weighted_by => [:segments, :passengers])
     )
   end
   
   # scoped
   
-  should "do default weighting, scoped" do
+  it "does default weighting, scoped" do
     conditions = '456 = 456'
     should_have_same_sql(
-      "SELECT (SUM((`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)",
+      "SELECT (SUM((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)",
       AirlineAircraftSeatClass.scoped(:conditions => conditions).weighted_average_relation(:seats)
     )
   end
   
-  should "do custom weighting, scoped" do
+  it "does custom weighting, scoped" do
     conditions = '999 = 999'
     should_have_same_sql(
-      "SELECT (SUM((`segments`.`load_factor`) * `segments`.`passengers`) / SUM(`segments`.`passengers`)) AS weighted_average FROM `segments` WHERE (#{conditions}) AND (`segments`.`load_factor` IS NOT NULL)",
+      "SELECT (SUM((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)",
       Segment.scoped(:conditions => conditions).weighted_average_relation(:load_factor, :weighted_by => :passengers)
     )
   end
   
   # scoped foreign weightings
   
-  should "do foreign default weighting, scoped" do
+  it "does 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 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)",
+      "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) AND (airline_aircraft_seat_classes.weighting > 0)",
       Aircraft.scoped(:conditions => conditions).weighted_average_relation(:seats, :weighted_by => :airline_aircraft_seat_classes)
     )
   end
   
-  should "do foreign custom weighting, scoped" do
-    conditions = '`aircraft`.`m3` > 1'
+  it "does 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 FROM `aircraft` INNER JOIN `segments` ON `segments`.`bts_aircraft_type` = `aircraft`.`bts_aircraft_type` WHERE (`aircraft`.`m3` > 1) 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) AND (segments.passengers > 0)",
       Aircraft.scoped(:conditions => conditions).weighted_average_relation(:m3, :weighted_by => [:segments, :passengers])
     )
   end
   
   # disaggregation
   
-  should "do custom weighting with disaggregation" do
+  it "does custom weighting with disaggregation" do
     should_have_same_sql(
-      "SELECT (SUM((`segments`.`load_factor`) / `segments`.`departures_performed` * `segments`.`passengers`) / SUM(`segments`.`passengers`)) AS weighted_average FROM `segments` WHERE (`segments`.`load_factor` IS NOT NULL)",
+      "SELECT (SUM((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)",
       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
+  it "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`)",
+      "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 aircraft.aircraft_class_id = aircraft_classes.id AND (segments.seats IS NOT NULL) AND (segments.passengers > 0)",
       Segment.joins(:aircraft => :aircraft_class).weighted_average_relation(:seats, :weighted_by => :passengers).where(aircraft[:aircraft_class_id].eq(aircraft_class[:id]))
     )
   end
@@ -177,25 +177,34 @@ class TestWeightedAverage < Test::Unit::TestCase
 
   # cohorts (requires the cohort_scope gem)
 
-  should "do custom weighting, with a cohort" do
+  it "does custom weighting, with a cohort" do
     should_have_same_sql(
-      "SELECT (SUM((`segments`.`load_factor`) * `segments`.`passengers`) / SUM(`segments`.`passengers`)) AS weighted_average FROM `segments` WHERE (`segments`.`payload` = 5) AND (`segments`.`load_factor` IS NOT NULL)",
+      "SELECT (SUM((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)",
       Segment.big_cohort(:payload => 5).weighted_average_relation(:load_factor, :weighted_by => :passengers)
     )
   end
 
   private
 
+  def database_field_quote_char
+    case ActiveRecord::Base.connection.adapter_name
+    when /mysql/i
+      '`'
+    when /postgres/i
+      '"'
+    end
+  end
+
   def should_have_same_sql(*args)
     # make sure everything is an SQL string
     args.map! { |arg| arg.is_a?(String) ? arg : arg.to_sql }
     # clean up whitespace
-    args.map! { |arg| arg.to_s.gsub /\s+/, ' ' }
+    args.map! { |arg| arg.to_s.gsub(/\s+/, ' ').gsub(database_field_quote_char, '') }
     # treat the first arg as the "known good"
     best = args.shift
+    # make sure the "best" SQL is valid
+    ActiveRecord::Base.connection.execute(best)
     # compare everything to the known good
-    args.each { |arg| assert_equal best, arg }
-    # make sure the SQL is valid
-    assert_nothing_raised { ActiveRecord::Base.connection.execute best }
+    args.each { |arg| best.must_equal arg }
   end
 end

data/weighted_average.gemspec

@@ -1,63 +1,32 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "weighted_average/version"
 
 Gem::Specification.new do |s|
-  s.name = %q{weighted_average}
-  s.version = "0.0.6"
+  s.name        = "weighted_average"
+  s.version     = WeightedAverage::VERSION
+  s.authors     = ["Seamus Abshere", "Andy Rossmeissl", "Ian Hough", "Matt Kling"]
+  s.email       = ["seamus@abshere.net"]
+  s.homepage    = "https://github.com/seamusabshere/weighted_average"
+  s.summary = %Q{Perform weighted averages. Rails 3 only.}
+  s.description = %Q{Perform weighted averages, even across associations. Rails 3 only because it uses ARel.}
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Seamus Abshere", "Andy Rossmeissl", "Ian Hough", "Matt Kling"]
-  s.date = %q{2010-11-16}
-  s.description = %q{Perform weighted averages, even across associations. Rails 3 only because it uses ARel.}
-  s.email = %q{seamus@abshere.net}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "lib/weighted_average.rb",
-     "test/helper.rb",
-     "test/test_weighted_average.rb",
-     "weighted_average.gemspec"
-  ]
-  s.homepage = %q{http://github.com/seamusabshere/weighted_average}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Perform weighted averages. Rails 3 only.}
-  s.test_files = [
-    "test/helper.rb",
-     "test/test_weighted_average.rb"
-  ]
+  s.rubyforge_project = "weighted_average"
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, ["~> 3"])
-      s.add_runtime_dependency(%q<arel>, ["~> 2"])
-      s.add_development_dependency(%q<cohort_scope>, [">= 0.0.2"])
-      s.add_development_dependency(%q<shoulda>, [">= 2.10.3"])
-    else
-      s.add_dependency(%q<activerecord>, ["~> 3"])
-      s.add_dependency(%q<arel>, ["~> 2"])
-      s.add_dependency(%q<cohort_scope>, [">= 0.0.2"])
-      s.add_dependency(%q<shoulda>, [">= 2.10.3"])
-    end
-  else
-    s.add_dependency(%q<activerecord>, ["~> 3"])
-    s.add_dependency(%q<arel>, ["~> 2"])
-    s.add_dependency(%q<cohort_scope>, [">= 0.0.2"])
-    s.add_dependency(%q<shoulda>, [">= 2.10.3"])
-  end
+  s.add_runtime_dependency 'activerecord', '~>3'
+  s.add_runtime_dependency 'activesupport', '~>3'
+  s.add_runtime_dependency 'arel', '~>2'
+  
+  s.add_development_dependency 'cohort_scope', '>=0.0.2'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'mysql'
+  s.add_development_dependency 'pg'
 end
 
+

metadata

@@ -1,15 +1,10 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: weighted_average
-version: !ruby/object:Gem::Version 
-  hash: 19
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 6
-  version: 0.0.6
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Seamus Abshere
 - Andy Rossmeissl
 - Ian Hough
@@ -17,124 +12,139 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-11-16 00:00:00 -06:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-09-23 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activerecord
+  requirement: &2153895000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: *2153895000
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2153894500 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 5
-        segments: 
-        - 3
-        version: "3"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: arel
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *2153894500
+- !ruby/object:Gem::Dependency
+  name: arel
+  requirement: &2153894040 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 2
-        version: "2"
+      - !ruby/object:Gem::Version
+        version: '2'
   type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: cohort_scope
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: *2153894040
+- !ruby/object:Gem::Dependency
+  name: cohort_scope
+  requirement: &2153893580 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 0
-        - 0
-        - 2
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.0.2
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: shoulda
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: *2153893580
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &2153893200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153893200
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2153892740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153892740
+- !ruby/object:Gem::Dependency
+  name: mysql
+  requirement: &2153892320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153892320
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: &2153891900 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 33
-        segments: 
-        - 2
-        - 10
-        - 3
-        version: 2.10.3
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id004
-description: Perform weighted averages, even across associations. Rails 3 only because it uses ARel.
-email: seamus@abshere.net
+  prerelease: false
+  version_requirements: *2153891900
+description: Perform weighted averages, even across associations. Rails 3 only because
+  it uses ARel.
+email:
+- seamus@abshere.net
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- LICENSE
-- README.rdoc
-files: 
+extra_rdoc_files: []
+files:
 - .document
 - .gitignore
+- Gemfile
 - LICENSE
 - README.rdoc
 - Rakefile
-- VERSION
 - lib/weighted_average.rb
+- lib/weighted_average/version.rb
 - test/helper.rb
 - test/test_weighted_average.rb
 - weighted_average.gemspec
-has_rdoc: true
-homepage: http://github.com/seamusabshere/weighted_average
+homepage: https://github.com/seamusabshere/weighted_average
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+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.3.7
+rubyforge_project: weighted_average
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Perform weighted averages. Rails 3 only.
-test_files: 
+test_files:
 - test/helper.rb
 - test/test_weighted_average.rb

data/VERSION

@@ -1 +0,0 @@
-0.0.6