cohort_scope 0.1.5 → 0.2.0

data/.gitignore

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

data/README.rdoc

@@ -2,14 +2,18 @@
 
 Provides cohorts (in the form of ActiveRecord scopes) that dynamically widen until they contain a certain number of records.
 
-* <tt>big_cohort</tt> widens by finding the constraint that eliminates the most records and removing it.
-* <tt>strict_cohort</tt> widens by eliminating constraints in order.
+* <tt>big_cohort</tt> widens by successively removing what it finds to be the most restrictive constraint until it reaches the minimum number of records
+* <tt>strict_cohort</tt> widens by eliminating constraints in order until it reaches the minimum number of records
 
-= Real-world use
+== Changes 0.1.x vs. 0.2.x
+
+No longer "flattens" or "sanitizes" constraints by turning records into integer IDs, etc. You should pass in exactly what you would pass into a normal ActiveRecord relation/scope.
+
+== Real-world use
 
 This has been at use at http://carbon.brighterplanet.com since April 2010, where it helps sift through climate data to come up with meaningful emissions calculations.
 
-= Quick start
+== Quick start
 
 Let's pretend the U.S. Census provided information about birthday and favorite color:
 
@@ -28,20 +32,17 @@ Now I need to run a calculation that ideally uses birthday and favorite color, b
 
 What if my calculation privileges favorite color? In other words, if you can't give me a cohort of minimum size within the birthday constraint, at least give me one where everybody loves heliotrope:
 
-  ordered_constraints = ActiveSupport::OrderedHash.new
-  ordered_constraints[:favorite_color] = 'heliotrope'
-  ordered_constraints[:birthdate] = (Date.parse('1980-01-01')..Date.parse('1990-01-01'))
+  ordered_constraints = []
+  ordered_constraints << [:favorite_color, 'heliotrope']
+  ordered_constraints << [:birthdate, (Date.parse('1980-01-01')..Date.parse('1990-01-01'))]
 
-  Citizen.strict_cohort favorite_color_matters_most
+  Citizen.strict_cohort *favorite_color_matters_most
   # => [... a cohort of at least 1,000 records (otherwise it's empty),
             where everybody's favorite color IS heliotrope
             and everybody's birthday MAY be between 1980 and 1990 ...]
 
-= Wishlist
-
-* support for ruby 1.9's implicitly ordered hashes
-* support for constraining on <tt>IS NULL</tt> or <tt>IS NOT NULL</tt>
+== Wishlist
 
 == Copyright
 
-Copyright (c) 2010 Seamus Abshere and Andy Rossmeissl. See LICENSE for details.
+Copyright (c) 2011 Seamus Abshere and Andy Rossmeissl. See LICENSE for details.

data/cohort_scope.gemspec

@@ -19,8 +19,9 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  s.add_dependency "activesupport", "~> 3.0.0"
-  s.add_dependency "activerecord", "~> 3.0.0"
-  s.add_development_dependency "shoulda", ">= 2.10.3"
-  s.add_development_dependency 'sqlite3-ruby'
+  s.add_dependency "activesupport", "~> 3.0"
+  s.add_dependency "activerecord", "~> 3.0"
+  s.add_development_dependency 'test-unit'
+  s.add_development_dependency 'mysql'
+  # s.add_development_dependency 'ruby-debug'
 end

data/lib/cohort_scope.rb

@@ -1,44 +1,58 @@
 require 'active_record'
+
 require 'active_support'
 require 'active_support/version'
-
-require 'active_support/core_ext/module/delegation' if ActiveSupport::VERSION::MAJOR == 3
-
-require 'cohort_scope/version'
-require 'cohort_scope/cohort'
-require 'cohort_scope/big_cohort'
-require 'cohort_scope/strict_cohort'
+if ActiveSupport::VERSION::MAJOR == 3
+  require 'active_support/json'
+  require 'active_support/core_ext/hash'
+end
 
 module CohortScope
+  autoload :Cohort, 'cohort_scope/cohort'
+  autoload :BigCohort, 'cohort_scope/big_cohort'
+  autoload :StrictCohort, 'cohort_scope/strict_cohort'
+  
   def self.extended(klass)
-    klass.cattr_accessor :minimum_cohort_size, :instance_writer => false
+    klass.class_eval do
+      class << self
+        attr_accessor :minimum_cohort_size
+      end
+    end
   end
-
+  
+  def self.conditions_for(constraints)
+    case constraints
+    when ::Array
+      constraints.inject({}) { |memo, (k, v)| memo[k] = v; memo }
+    when ::Hash
+      constraints.dup
+    end
+  end
+  
   # Find the biggest scope possible by removing constraints <b>in any order</b>.
   # Returns an empty scope if it can't meet the minimum scope size.
-  def big_cohort(constraints = {}, custom_minimum_cohort_size = self.minimum_cohort_size)
-    raise ArgumentError, "You can't give a big_cohort an OrderedHash; do you want strict_cohort?" if constraints.is_a?(ActiveSupport::OrderedHash)
-    BigCohort.create self, constraints, custom_minimum_cohort_size
+  def big_cohort(constraints, options = {})
+    BigCohort.create self, constraints, (options[:minimum_cohort_size] || minimum_cohort_size)
   end
 
   # Find the first acceptable scope by removing constraints <b>in strict order</b>, starting with the last constraint.
   # Returns an empty scope if it can't meet the minimum scope size.
   #
-  # <tt>constraints</tt> must be an <tt>ActiveSupport::OrderedHash</tt> (no support for ruby 1.9's natively ordered hashes yet).
+  # <tt>constraints</tt> must be key/value pairs (splat if it's an array)
   #
   # Note that the first constraint is implicitly required.
   #
   # Take this example, where favorite color is considered to be "more important" than birthdate:
   #
-  #   ordered_constraints = ActiveSupport::OrderedHash.new
-  #   ordered_constraints[:favorite_color] = 'heliotrope'
-  #   ordered_constraints[:birthdate] = '1999-01-01'
-  #   Citizen.strict_cohort(ordered_constraints) #=> [...]
+  #   ordered_constraints = [ [:favorite_color, 'heliotrope'], [:birthdate, '1999-01-01'] ]
+  #   Citizen.strict_cohort(*ordered_constraints) #=> [...]
   #
   # If the original constraints don't meet the minimum scope size, then the only constraint that can be removed is birthdate.
   # In other words, this would never return a scope that was constrained on birthdate but not on favorite_color.
-  def strict_cohort(constraints, custom_minimum_cohort_size = self.minimum_cohort_size)
-    raise ArgumentError, "You need to give strict_cohort an OrderedHash" unless constraints.is_a?(ActiveSupport::OrderedHash)
-    StrictCohort.create self, constraints, custom_minimum_cohort_size
+  def strict_cohort(*args)
+    args = args.dup
+    options = args.last.is_a?(::Hash) ? args.pop : {}
+    constraints = args
+    StrictCohort.create self, constraints, (options[:minimum_cohort_size] || minimum_cohort_size)
   end
 end

data/lib/cohort_scope/big_cohort.rb

@@ -1,21 +1,14 @@
 module CohortScope
   class BigCohort < Cohort
-
     # Reduce constraints by removing them one by one and counting the results.
     #
     # The constraint whose removal leads to the highest record count is removed from the overall constraint set.
-    def self.reduce_constraints(model, constraints)
-      highest_count_after_removal = nil
-      losing_key = nil
-      constraints.keys.each do |key|
-        test_constraints = constraints.except(key)
-        count_after_removal = model.scoped.where(sanitize_constraints(model, test_constraints)).count
-        if highest_count_after_removal.nil? or count_after_removal > highest_count_after_removal
-          highest_count_after_removal = count_after_removal
-          losing_key = key
-        end
+    def self.reduce_constraints(active_record, constraints)
+      most_restrictive_constraint = constraints.keys.max_by do |key|
+        conditions = CohortScope.conditions_for constraints.except(key)
+        active_record.scoped.where(conditions).count
       end
-      constraints.except losing_key
+      constraints.except most_restrictive_constraint
     end
   end
 end

data/lib/cohort_scope/cohort.rb

@@ -1,80 +1,22 @@
 require 'delegate'
 
 module CohortScope
-  class Cohort < Delegator
+  class Cohort < ::Delegator
 
     class << self
       # Recursively look for a scope that meets the constraints and is at least <tt>minimum_cohort_size</tt>.
-      def create(model, constraints, custom_minimum_cohort_size)
-        raise RuntimeError, "You need to set #{name}.minimum_cohort_size = X" unless model.minimum_cohort_size.present?
-        
-        if constraints.values.none? # failing base case
-          empty_cohort = model.scoped.where '1 = 2'
-          return new(empty_cohort)
+      def create(active_record, constraints, minimum_cohort_size)
+        if constraints.none? # failing base case
+          empty_scope = active_record.scoped.where '1 = 2'
+          return new(empty_scope)
         end
 
-        constraint_hash = sanitize_constraints model, constraints
-        constrained_scope = model.scoped.where(constraint_hash)
+        constrained_scope = active_record.scoped.where CohortScope.conditions_for(constraints)
 
-        if constrained_scope.count >= custom_minimum_cohort_size
+        if constrained_scope.count >= minimum_cohort_size
           new constrained_scope
         else
-          reduced_constraints = reduce_constraints(model, constraints)
-          create(model, reduced_constraints, custom_minimum_cohort_size)
-        end
-      end
-      
-      # Sanitize constraints by
-      # * removing nil constraints (so constraints like "X IS NULL" are impossible, sorry)
-      # * converting ActiveRecord::Base objects into integer foreign key constraints
-      def sanitize_constraints(model, constraints)
-        new_hash = constraints.is_a?(ActiveSupport::OrderedHash) ? ActiveSupport::OrderedHash.new : Hash.new
-        conditions = constraints.inject(new_hash) do |memo, tuple|
-          k, v = tuple
-          if v.kind_of?(ActiveRecord::Base)
-            foreign_key = association_foreign_key model, k
-            lookup_value = association_lookup_value model, k, v
-            condition = { foreign_key => lookup_value }
-          elsif !v.nil?
-            condition = { k => v }
-          end
-          memo.merge! condition if condition.is_a? Hash
-          memo
-        end
-        conditions
-      end
-      
-      # Convert constraints that are provided as ActiveRecord::Base objects into their corresponding primary keys.
-      #
-      # Only works for <tt>belongs_to</tt> relationships.
-      #
-      # For example, :car => <#Car> might get translated into :car_id => 44 or :car_type => 44 if :foreign_key option is given.
-      def association_foreign_key(model, name)
-        @association_foreign_key ||= {}
-        return @association_foreign_key[name] if @association_foreign_key.has_key? name
-        association = model.reflect_on_association name
-        raise "there is no association #{name.inspect} on #{model}" if association.nil?
-        raise "can't use cohort scope on :through associations (#{self.name} #{name})" if association.options.has_key? :through
-        foreign_key = association.instance_variable_get(:@options)[:foreign_key]
-        if !foreign_key.blank?
-          @association_foreign_key[name] = foreign_key
-        else
-          @association_foreign_key[name] = association.primary_key_name
-        end
-      end
-      
-      # Convert constraints that are provided as ActiveRecord::Base objects into their corresponding lookup values
-      #
-      # Only works for <tt>belongs_to</tt> relationships.
-      #
-      # For example, :car => <#Car> might get translated into :car_id => 44 or :car_id => 'JHK123' if :primary_key option is given.
-      def association_lookup_value(model, name, value)
-        association = model.reflect_on_association name
-        primary_key = association.instance_variable_get(:@options)[:primary_key]
-        if primary_key.blank?
-          value.to_param
-        else
-          value.send primary_key
+          create active_record, reduce_constraints(active_record, constraints), minimum_cohort_size
         end
       end
     end
@@ -109,7 +51,7 @@ module CohortScope
     end
 
     def inspect
-      "<Massive ActiveRecord scope with #{count} members>"
+      "<Cohort scope with #{count} members>"
     end
   end
 end

data/lib/cohort_scope/strict_cohort.rb

@@ -1,13 +1,8 @@
 module CohortScope
   class StrictCohort < Cohort
-    
-    # (Used by <tt>strict_cohort</tt>)
-    #
     # Reduce constraints by removing the least important one.
-    def self.reduce_constraints(model, constraints)
-      reduced_constraints = constraints.dup
-      reduced_constraints.delete constraints.keys.last
-      reduced_constraints
+    def self.reduce_constraints(active_record, constraints)
+      constraints[0..-2]
     end
   end
 end

data/lib/cohort_scope/version.rb

@@ -1,3 +1,3 @@
 module CohortScope
-  VERSION = '0.1.5'
+  VERSION = '0.2.0'
 end

data/test/helper.rb

@@ -2,8 +2,6 @@ require 'rubygems'
 require 'bundler'
 Bundler.setup
 require 'test/unit'
-require 'shoulda'
-require 'logger'
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'cohort_scope'
@@ -11,36 +9,39 @@ require 'cohort_scope'
 class Test::Unit::TestCase
 end
 
-$logger = Logger.new 'test/test.log' #STDOUT
-ActiveSupport::Notifications.subscribe do |*args|
-  event = ActiveSupport::Notifications::Event.new(*args)
-  $logger.debug "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
-end
+# require 'logger'
+# ActiveRecord::Base.logger = Logger.new($stderr)
 
 ActiveRecord::Base.establish_connection(
-  'adapter' => 'sqlite3',
-  'database' => ':memory:'
+  'adapter' => 'mysql',
+  'database' => 'test_cohort_scope',
+  'username' => 'root',
+  'password' => 'password'
 )
 
-ActiveRecord::Schema.define(:version => 20090819143429) do
-  create_table 'citizens', :force => true do |t|
-    t.date 'birthdate'
-    t.string 'favorite_color'
-    t.integer 'teeth'
-  end
-  create_table 'houses', :force => true do |t|
-    t.string 'period'
-    t.string 'address'
-    t.integer 'storeys'
-  end
-  create_table 'styles', :force => true do |t|
-    t.string 'period'
-    t.string 'name'
-  end
-  create_table 'residents', :force => true do |t|
-    t.integer 'house_id'
-    t.string 'name'
-  end
+c = ActiveRecord::Base.connection
+c.create_table 'citizens', :force => true do |t|
+  t.date 'birthdate'
+  t.string 'favorite_color'
+  t.integer 'teeth'
+end
+c.create_table 'houses', :force => true do |t|
+  t.string 'period_id'
+  t.string 'address'
+  t.integer 'storeys'
+end
+c.create_table 'periods', :force => true, :id => false do |t|
+  t.string 'name'
+end
+c.execute "ALTER TABLE periods ADD PRIMARY KEY (name)"
+c.create_table 'styles', :force => true, :id => false do |t|
+  t.string 'name'
+  t.string 'period_id'
+end
+c.execute "ALTER TABLE styles ADD PRIMARY KEY (name)"
+c.create_table 'residents', :force => true do |t|
+  t.integer 'house_id'
+  t.string 'name'
 end
 
 class Citizen < ActiveRecord::Base
@@ -66,27 +67,46 @@ end
   Citizen.create! :birthdate => birthdate, :favorite_color => favorite_color, :teeth => teeth
 end
 
+class Period < ActiveRecord::Base
+  set_primary_key :name
+  has_many :styles
+  has_many :houses
+  
+  # hack to make sure rails doesn't protect the foreign key columns
+  self._protected_attributes = BlackList.new
+end
+
 class Style < ActiveRecord::Base
+  set_primary_key :name
   extend CohortScope
   self.minimum_cohort_size = 3
-  has_many :houses
+  belongs_to :period
+  has_many :houses, :through => :period, :foreign_key => 'name'
+  
+  # hack to make sure rails doesn't protect the foreign key columns
+  self._protected_attributes = BlackList.new
 end
+
 class House < ActiveRecord::Base
-  belongs_to :style, :foreign_key => 'period', :primary_key => 'period'
+  belongs_to :period
+  has_many :styles, :through => :period
   has_one :resident
 end
+
 class Resident < ActiveRecord::Base
-  has_one :house
+  belongs_to :house
 end
 
-Style.create! :period => 'arts and crafts', :name => 'classical revival'
-Style.create! :period => 'arts and crafts', :name => 'gothic'
-Style.create! :period => 'arts and crafts', :name => 'art deco'
-Style.create! :period => 'victorian', :name => 'stick-eastlake'
-Style.create! :period => 'victorian', :name => 'queen anne'
-h1 = House.create! :period => 'arts and crafts', :address => '123 Maple', :storeys => 1
-h2 = House.create! :period => 'arts and crafts', :address => '223 Walnut', :storeys => 2
-h3 = House.create! :period => 'victorian', :address => '323 Pine', :storeys => 2
+p1 = Period.create! :name => 'arts and crafts'
+p2 = Period.create! :name => 'victorian'
+Style.create! :period => p1, :name => 'classical revival'
+Style.create! :period => p1, :name => 'gothic'
+Style.create! :period => p1, :name => 'art deco'
+Style.create! :period => p2, :name => 'stick-eastlake'
+Style.create! :period => p2, :name => 'queen anne'
+h1 = House.create! :period => p1, :address => '123 Maple', :storeys => 1
+h2 = House.create! :period => p1, :address => '223 Walnut', :storeys => 2
+h3 = House.create! :period => p2, :address => '323 Pine', :storeys => 2
 Resident.create! :house => h1, :name => 'Bob'
 Resident.create! :house => h2, :name => 'Rob'
 Resident.create! :house => h3, :name => 'Gob'

data/test/test_big_cohort.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+class TestBigCohort < Test::Unit::TestCase
+  def setup
+    Citizen.minimum_cohort_size = 3
+    @date_range = (Date.parse('1980-01-01')..Date.parse('1990-01-01'))
+  end
+
+  def test_001_empty
+    cohort = Citizen.big_cohort :favorite_color => 'heliotrope'
+    assert_equal 0, cohort.count
+  end
+  
+  def test_002_optional_minimum_cohort_size_at_runtime
+    cohort = Citizen.big_cohort({:favorite_color => 'heliotrope'}, :minimum_cohort_size => 0)
+    assert_equal 1, cohort.count
+  end
+
+  def test_003_seek_cohort_of_maximum_size
+    cohort = Citizen.big_cohort :birthdate => @date_range, :favorite_color => 'heliotrope'
+    assert_equal 9, cohort.count
+    assert cohort.any? { |m| m.favorite_color != 'heliotrope' }
+    assert cohort.all? { |m| @date_range.include? m.birthdate }
+  end
+  
+  def test_004_unsurprising_treatment_of_arrays
+    assert_equal 3, Citizen.big_cohort({:favorite_color => 'blue'}, :minimum_cohort_size => 0).count
+    assert_equal 1, Citizen.big_cohort({:favorite_color => 'heliotrope'}, :minimum_cohort_size => 0).count
+    assert_equal 4, Citizen.big_cohort({:favorite_color => ['heliotrope', 'blue']}, :minimum_cohort_size => 0).count
+  end
+end

data/test/test_cohort_scope.rb

@@ -6,14 +6,41 @@ class TestCohortScope < Test::Unit::TestCase
     @date_range = (Date.parse('1980-01-01')..Date.parse('1990-01-01'))
   end
 
-  should "properly use blocks" do
+  def test_001_has_sane_associations
+    assert Period.first.styles.first
+    assert Period.first.houses.first
+    assert Style.first.period
+    assert Style.first.houses.first
+    assert House.first.period
+    assert House.first.styles.first
+    assert House.all.any? { |h| h.resident }
+    assert House.joins(:styles).where(:styles => { :name => [style] }).first.styles.include?(style)
+    assert Style.joins(:houses).where(:houses => { :id => [house1] }).first
+  end
+  
+  # confusing as hell because houses have styles according to periods, which is not accurate
+  def test_002a_complicated_cohorts_with_joins
+    assert_equal 3, Style.joins(:houses).big_cohort(:houses => { :id => [house1]}).length
+    assert_equal 3, Style.joins(:houses).big_cohort(:houses => { :id => [house1]}, :name => 'foooooooo').length
+    # these return 2, which is too small
+    assert_equal 0, Style.joins(:houses).big_cohort(:houses => { :id => [house3]}).length
+    assert_equal 0, Style.joins(:houses).big_cohort(:houses => { :id => [house3]}, :name => 'classical revival').length
+  end
+  
+  # should this even work in theory?
+  def test_002b_simplified_joins
+    flunk
+    assert_equal 3, Style.big_cohort(:houses => [house1]).length
+  end
+
+  def test_003_redefine_any_query_method
     cohort = Citizen.big_cohort(:birthdate => @date_range)
     assert cohort.all? { |c| true }
     assert cohort.any? { |c| true }
     assert !cohort.none? { |c| true }
   end
-
-  should "actually run blocks" do
+  
+  def test_004_really_run_blocks
     assert_raises(RuntimeError, 'A') do
       Citizen.big_cohort(:birthdate => @date_range).all? { |c| raise 'A' }
     end
@@ -24,110 +51,49 @@ class TestCohortScope < Test::Unit::TestCase
       Citizen.big_cohort(:birthdate => @date_range).none? { |c| raise 'C' }
     end
   end
-
-  should "only show the count in the json representation" do
+  
+  def test_005_short_to_json
     cohort = Citizen.big_cohort :birthdate => @date_range, :favorite_color => 'heliotrope'
     assert_equal({ :members => 9 }.to_json, cohort.to_json)
   end
   
-  should "not mess with normal as_json" do
+  def test_006_doesnt_mess_with_active_record_json
     non_cohort = Citizen.all
     assert_equal non_cohort.to_a.as_json, non_cohort.as_json
   end
   
-  should "not mess with normal inspect" do
+  def test_007_doesnt_mess_with_active_record_inspect
     non_cohort = Citizen.all
     assert_equal non_cohort.to_a.inspect, non_cohort.inspect
   end
   
-  should "inspect to a short string" do
+  def test_008_short_inspect
     cohort = Citizen.big_cohort :birthdate => @date_range, :favorite_color => 'heliotrope'
-    assert_equal "<Massive ActiveRecord scope with 9 members>", cohort.inspect
+    assert_equal "<Cohort scope with 9 members>", cohort.inspect
   end
   
-  should "not get fooled into revealing all of its members by a parent's #to_hash" do
+  def test_009_not_reveal_itself_in_to_hash
     cohort = Citizen.big_cohort :birthdate => @date_range, :favorite_color => 'heliotrope'
     assert_equal '{"c":{"members":9}}', { :c => cohort }.to_hash.to_json
   end
-
-  should "retain the scope's original behavior" do
+  
+  def test_010_work_as_delegator
     cohort = Citizen.big_cohort :birthdate => @date_range, :favorite_color => 'heliotrope'
     assert_kind_of Citizen, cohort.last
     assert_kind_of Citizen, cohort.where(:teeth => 31).first
   end
-
-  should "raise if no minimum_cohort_size is specified" do
-    Citizen.minimum_cohort_size = nil
-    assert_raises(RuntimeError) {
-      Citizen.big_cohort Hash.new
-    }
-    assert_raises(RuntimeError) {
-      Citizen.strict_cohort ActiveSupport::OrderedHash.new
-    }
-  end
-
-  context "big_cohort" do
-    should "return an empty cohort if it can't find one that meets size requirements" do
-      cohort = Citizen.big_cohort :favorite_color => 'heliotrope'
-      assert_equal 0, cohort.count
-    end
     
-    should "take minimum_cohort_size as an optional argument" do
-      cohort = Citizen.big_cohort({:favorite_color => 'heliotrope'}, 0)
-      assert_equal 1, cohort.count
-    end
+  private
   
-    should "seek a cohort of maximum size" do
-      cohort = Citizen.big_cohort :birthdate => @date_range, :favorite_color => 'heliotrope'
-      assert_equal 9, cohort.count
-      assert cohort.any? { |m| m.favorite_color != 'heliotrope' }
-      assert cohort.all? { |m| @date_range.include? m.birthdate }
-    end
-    
-    should "raise if an OrderedHash is given to big_cohort" do
-      assert_raises(ArgumentError) {
-        Citizen.big_cohort ActiveSupport::OrderedHash.new
-      }
-    end
+  def style
+    @style ||= Style.find 'classical revival'
   end
   
-  context "strict_cohort" do
-    should "raise if a non-OrderedHash is given to strict_cohort" do
-      assert_raises(ArgumentError) {
-        Citizen.strict_cohort Hash.new
-      }
-    end
-    
-    should "take minimum_cohort_size as an optional argument" do
-      ordered_attributes = ActiveSupport::OrderedHash.new
-      ordered_attributes[:favorite_color] = 'heliotrope'
-    
-      cohort = Citizen.strict_cohort ordered_attributes, 0
-      assert_equal 1, cohort.count
-    end
-  
-    should "return an empty cohort if it can't find one that meets size requirements" do
-      ordered_attributes = ActiveSupport::OrderedHash.new
-      ordered_attributes[:favorite_color] = 'heliotrope'
-    
-      cohort = Citizen.strict_cohort ordered_attributes
-      assert_equal 0, cohort.count
-    end
+  def house1
+    @house1 ||= House.find 2
+  end
   
-    should "seek a cohort by discarding attributes in order" do
-      favorite_color_matters_most = ActiveSupport::OrderedHash.new
-      favorite_color_matters_most[:favorite_color] = 'heliotrope'
-      favorite_color_matters_most[:birthdate] = @date_range
-    
-      birthdate_matters_most = ActiveSupport::OrderedHash.new
-      birthdate_matters_most[:birthdate] = @date_range
-      birthdate_matters_most[:favorite_color] = 'heliotrope'
-    
-      cohort = Citizen.strict_cohort favorite_color_matters_most
-      assert_equal 0, cohort.count
-    
-      cohort = Citizen.strict_cohort birthdate_matters_most
-      assert_equal 9, cohort.count
-    end
+  def house3
+    @house3 ||= House.find 3
   end
 end

data/test/test_strict_cohort.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+class TestStrictCohort < Test::Unit::TestCase
+  def setup
+    Citizen.minimum_cohort_size = 3
+    @date_range = (Date.parse('1980-01-01')..Date.parse('1990-01-01'))
+  end
+
+  def test_001_empty
+    cohort = Citizen.strict_cohort 
+    assert_equal 0, cohort.count
+  end
+  
+  def test_002_optional_minimum_cohort_size_at_runtime
+    cohort = Citizen.strict_cohort [:favorite_color, 'heliotrope'], :minimum_cohort_size => 0
+    assert_equal 1, cohort.count
+  end
+
+  def test_003_seek_cohort_by_discarding_constraints_in_order
+    favorite_color_matters_most = [ [:favorite_color, 'heliotrope'], [:birthdate, @date_range] ]
+    birthdate_matters_most =      [ [:birthdate, @date_range], [:favorite_color, 'heliotrope'] ]
+
+    cohort = Citizen.strict_cohort *favorite_color_matters_most
+    assert_equal 0, cohort.count
+
+    cohort = Citizen.strict_cohort *birthdate_matters_most
+    assert_equal 9, cohort.count
+  end
+end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: cohort_scope
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 5
-  version: 0.1.5
+  prerelease: 
+  version: 0.2.0
 platform: ruby
 authors: 
 - Seamus Abshere
@@ -16,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-04 00:00:00 -05:00
+date: 2011-05-17 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -27,11 +23,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 3
-        - 0
-        - 0
-        version: 3.0.0
+        version: "3.0"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -42,38 +34,28 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        segments: 
-        - 3
-        - 0
-        - 0
-        version: 3.0.0
+        version: "3.0"
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: shoulda
+  name: test-unit
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 2
-        - 10
-        - 3
-        version: 2.10.3
+        version: "0"
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: sqlite3-ruby
+  name: mysql
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :development
   version_requirements: *id004
@@ -100,8 +82,9 @@ files:
 - lib/cohort_scope/strict_cohort.rb
 - lib/cohort_scope/version.rb
 - test/helper.rb
-- test/test_cohort.rb
+- test/test_big_cohort.rb
 - test/test_cohort_scope.rb
+- test/test_strict_cohort.rb
 has_rdoc: true
 homepage: https://github.com/seamusabshere/cohort_scope
 licenses: []
@@ -116,25 +99,22 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: cohort_scope
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Provides cohorts (in the form of ActiveRecord scopes) that dynamically widen until they contain a certain number of records.
 test_files: 
 - test/helper.rb
-- test/test_cohort.rb
+- test/test_big_cohort.rb
 - test/test_cohort_scope.rb
+- test/test_strict_cohort.rb

data/test/test_cohort.rb

@@ -1,57 +0,0 @@
-require 'helper'
-
-class TestCohort < Test::Unit::TestCase
-  def setup
-    Citizen.minimum_cohort_size = 3
-    @date_range = (Date.parse('1980-01-01')..Date.parse('1990-01-01'))
-  end
-
-  def style
-    @style ||= Style.find_by_period 'arts and crafts'
-  end
-
-  context '.sanitize_constraints' do
-    should 'remove nil constraints' do
-      constraints = CohortScope::Cohort.sanitize_constraints Style, :eh => :tu, :bru => :te, :caesar => nil
-      assert_does_not_contain constraints.keys, :caesar
-    end
-    should 'keep normal constraints' do
-      constraints = CohortScope::Cohort.sanitize_constraints Style, :eh => :tu, :bru => :te, :caesar => nil
-      assert_equal :tu, constraints[:eh]
-    end
-    should 'include constraints that are models' do
-      gob = Resident.find_by_name 'Gob'
-      constraints = CohortScope::Cohort.sanitize_constraints House, :resident => gob
-      assert_equal gob.house_id, constraints[:house_id]
-    end
-    should 'include constraints that are models not related by primary key' do
-      constraints = CohortScope::Cohort.sanitize_constraints House, :style => style
-      assert_equal 'arts and crafts', constraints['period']
-    end
-  end
-
-  context '.association_foreign_key' do
-    should 'include constraints that are models related by a standard foreign key' do
-      gob = Resident.find_by_name('Gob')
-      key = CohortScope::Cohort.association_foreign_key Resident, :house
-      assert_equal 'resident_id', key
-    end
-    should 'include constraints that are models related by a non-standard foreign key' do
-      key = CohortScope::Cohort.association_foreign_key House, :style
-      assert_equal 'period', key
-    end
-  end
-
-  context '.association_lookup_value' do
-    should 'include constraints that are models related by a standard foreign key' do
-      gob = Resident.find_by_name('Gob')
-      lookup = CohortScope::Cohort.association_lookup_value Resident, :house, gob
-      assert_equal gob.to_param, lookup
-    end
-    should 'include constraints that are models related by a non-standard foreign key key' do
-      rev = Style.find_by_name 'classical revival'
-      lookup = CohortScope::Cohort.association_lookup_value House, :style, rev
-      assert_equal 'arts and crafts', lookup
-    end
-  end
-end