cohort_scope 0.2.3 → 0.3.0

data/CHANGELOG

@@ -0,0 +1,13 @@
+0.3.0 / 2012-02-27
+
+* Now my_cohort = Person.cohort({:favorite_color => 'heliotrope', :birthdate => @date_range}, :importance => [:birthdate, :favorite_color]) will return a Arel::Nodes::Node which can be combined like Person.where(my_cohort.and("gender = 'male")) - it does NOT return a "scope" like before.
+
+* Refactor to take advantage of ARel.
+
+0.2.0
+
+* No longer "flattens" or "sanitizes" characteristics by turning records into integer IDs, etc. You should pass in exactly what you would pass into a normal ActiveRecord relation/scope.
+
+0.1.0
+
+* First version!

data/Gemfile

@@ -2,3 +2,8 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in cohort_scope.gemspec
 gemspec
+
+# gem 'ruby-debug19'
+gem 'test-unit'
+gem 'mysql2'
+gem 'rake'

data/README.rdoc

@@ -2,16 +2,12 @@
 
 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 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
-
-== 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.
+* <tt>big_cohort</tt> widens by successively removing what it finds to be the most restrictive characteristic until it reaches the minimum number of records
+* <tt>strict_cohort</tt> widens by eliminating characteristics in order until it reaches the minimum number of records
 
 == 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.
+This has been at use at http://impact.brighterplanet.com since April 2010, where it helps sift through climate data to come up with meaningful emissions calculations.
 
 == Quick start
 
@@ -28,13 +24,13 @@ Now I need to run a calculation that ideally uses birthday and favorite color, b
   # => [... a cohort of at least 1,000 records (otherwise it's empty),
             where everybody's favorite color MAY be heliotrope
             and everybody's birthday MAY be between 1980 and 1990
-            (at least one of those constraints will hold) ...]
+            (at least one of those characteristics will hold) ...]
 
-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:
+What if my calculation privileges favorite color? In other words, if you can't give me a cohort of minimum size within the birthday characteristic, at least give me one where everybody loves heliotrope:
 
-  ordered_constraints = []
-  ordered_constraints << [:favorite_color, 'heliotrope']
-  ordered_constraints << [:birthdate, (Date.parse('1980-01-01')..Date.parse('1990-01-01'))]
+  ordered_characteristics = []
+  ordered_characteristics << [:favorite_color, 'heliotrope']
+  ordered_characteristics << [:birthdate, (Date.parse('1980-01-01')..Date.parse('1990-01-01'))]
 
   Citizen.strict_cohort *favorite_color_matters_most
   # => [... a cohort of at least 1,000 records (otherwise it's empty),
@@ -45,4 +41,4 @@ What if my calculation privileges favorite color? In other words, if you can't g
 
 == Copyright
 
-Copyright (c) 2011 Seamus Abshere and Andy Rossmeissl. See LICENSE for details.
+Copyright (c) 2012 Brighter Planet, Inc. See LICENSE for details.

data/cohort_scope.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.email       = ["seamus@abshere.net"]
   s.homepage    = "https://github.com/seamusabshere/cohort_scope"
   s.summary     = %Q{Provides cohorts (in the form of ActiveRecord scopes) that dynamically widen until they contain a certain number of records.}
-  s.description = %Q{Provides big_cohort, which widens by finding the constraint that eliminates the most records and removing it. Also provides strict_cohort, which widens by eliminating constraints in order.}
+  s.description = %Q{Provides big_cohort, which widens by finding the characteristic that eliminates the most records and removing it. Also provides strict_cohort, which widens by eliminating characteristics in order.}
 
   s.rubyforge_project = "cohort_scope"
 
@@ -21,8 +21,4 @@ Gem::Specification.new do |s|
   
   s.add_runtime_dependency "activesupport", '>=3'
   s.add_runtime_dependency "activerecord", '>=3'
-  s.add_development_dependency 'test-unit'
-  s.add_development_dependency 'mysql2'
-  s.add_development_dependency 'rake'
-  # s.add_development_dependency 'ruby-debug'
 end

data/lib/cohort_scope.rb

@@ -1,3 +1,4 @@
+require 'arel'
 require 'active_record'
 require 'active_support/core_ext'
 
@@ -5,6 +6,10 @@ require 'cohort_scope/cohort'
 require 'cohort_scope/big_cohort'
 require 'cohort_scope/strict_cohort'
 
+require 'cohort_scope/active_record_base_class_methods'
+require 'cohort_scope/active_record_relation_instance_methods'
+require 'cohort_scope/arel_visitors_visitor_instance_methods'
+
 module CohortScope
   def self.extended(klass)
     klass.class_eval do
@@ -14,47 +19,16 @@ module CohortScope
     end
   end
   
-  def self.conditions_for(constraints)
-    case constraints
+  def self.conditions_for(characteristics)
+    case characteristics
     when ::Array
-      constraints.inject({}) { |memo, (k, v)| memo[k] = v; memo }
+      characteristics.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, 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 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 = [ [: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(*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
-  
-  module ActiveRecordRelationExt
-    def to_cohort
-      Cohort.new self
+      characteristics
     end
   end
 end
 
-::ActiveRecord::Relation.send :include, ::CohortScope::ActiveRecordRelationExt
+ActiveRecord::Base.extend CohortScope::ActiveRecordBaseClassMethods
+ActiveRecord::Relation.send :include, CohortScope::ActiveRecordRelationInstanceMethods
+Arel::Visitors::Visitor.send :include, CohortScope::ArelVisitorsVisitorInstanceMethods

data/lib/cohort_scope/active_record_base_class_methods.rb

@@ -0,0 +1,11 @@
+module CohortScope
+  module ActiveRecordBaseClassMethods
+    def big_cohort(*args)
+      scoped.big_cohort *args
+    end
+
+    def strict_cohort(*args)
+      scoped.strict_cohort *args
+    end
+  end
+end

data/lib/cohort_scope/active_record_relation_instance_methods.rb

@@ -0,0 +1,30 @@
+module CohortScope
+  module ActiveRecordRelationInstanceMethods
+    # Find the biggest scope possible by removing characteristics <b>in any order</b>.
+    # Returns an empty scope if it can't meet the minimum scope size.
+    def big_cohort(characteristics, options = {})
+      BigCohort.new self, characteristics, (options[:minimum_cohort_size] || (klass.respond_to?(:minimum_cohort_size) ? klass.minimum_cohort_size : nil))
+    end
+
+    # Find the first acceptable scope by removing characteristics <b>in strict order</b>, starting with the last characteristic.
+    # Returns an empty scope if it can't meet the minimum scope size.
+    #
+    # <tt>characteristics</tt> must be key/value pairs (splat if it's an array)
+    #
+    # Note that the first characteristic is implicitly required.
+    #
+    # Take this example, where favorite color is considered to be "more important" than birthdate:
+    #
+    #   ordered_characteristics = [ [:favorite_color, 'heliotrope'], [:birthdate, '1999-01-01'] ]
+    #   Citizen.strict_cohort(*ordered_characteristics) #=> [...]
+    #
+    # If the original characteristics don't meet the minimum scope size, then the only characteristic 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(*args)
+      args = args.dup
+      options = args.last.is_a?(::Hash) ? args.pop : {}
+      characteristics = args
+      StrictCohort.new self, characteristics, (options[:minimum_cohort_size] || (klass.respond_to?(:minimum_cohort_size) ? klass.minimum_cohort_size : nil))
+    end
+  end
+end

data/lib/cohort_scope/arel_visitors_visitor_instance_methods.rb

@@ -0,0 +1,7 @@
+module CohortScope
+  module ArelVisitorsVisitorInstanceMethods
+    def visit_CohortScope_Cohort(o)
+      o.expr
+    end
+  end
+end

data/lib/cohort_scope/big_cohort.rb

@@ -1,14 +1,17 @@
 module CohortScope
   class BigCohort < Cohort
-    # Reduce constraints by removing them one by one and counting the results.
+    # Reduce characteristics 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(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
+    # The characteristic whose removal leads to the highest record count is removed from the overall characteristic set.
+    def self.reduce_characteristics(active_record, characteristics)
+      if characteristics.keys.length < 2
+        return {}
       end
-      constraints.except most_restrictive_constraint
+      most_restrictive_characteristic = characteristics.keys.max_by do |key|
+        conditions = CohortScope.conditions_for characteristics.except(key)
+        active_record.where(conditions).count
+      end
+      characteristics.except most_restrictive_characteristic
     end
   end
 end

data/lib/cohort_scope/cohort.rb

@@ -1,105 +1,30 @@
-require 'delegate'
-
 module CohortScope
-  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(active_record, constraints, minimum_cohort_size)
-        if constraints.none? # failing base case
-          cohort = new active_record.scoped.where(IMPOSSIBLE_CONDITION)
-          cohort.count = 0
-          return cohort
-        end
-
-        constrained_scope = active_record.scoped.where CohortScope.conditions_for(constraints)
+  class Cohort < ::Arel::Nodes::Node
+    IMPOSSIBLE = '1 = 2'
 
-        if (count = constrained_scope.count) >= minimum_cohort_size
-          cohort = new constrained_scope
-          cohort.count = count
-          cohort
-        else
-          create active_record, reduce_constraints(active_record, constraints), minimum_cohort_size
-        end
-      end
+    def initialize(active_record, characteristics, minimum_cohort_size)
+      @active_record = active_record
+      @characteristics = characteristics
+      @minimum_cohort_size = minimum_cohort_size
     end
-    
-    IMPOSSIBLE_CONDITION = ::Arel::Nodes::Equality.new(1,2)
 
-    def initialize(obj)
-      super
-      @_ch_obj = obj
-    end
-    def __getobj__
-      @_ch_obj
-    end
-    def __setobj__(obj)
-      @_ch_obj = obj
+    def expr
+      @expr ||= resolve
     end
+    alias :to_sql :expr
 
-    def count=(int)
-      @count = int
-    end
-    
-    def count
-      @count ||= super
-    end
+    private
 
-    # sabshere 2/1/11 overriding as_json per usual doesn't seem to work
-    def to_json(*)
-      as_json.to_json
-    end
-    
-    def as_json(*)
-      { :members => count }
-    end
-    
-    def empty?
-      count == 0
-    end
-        
-    def any?
-      return false if count == 0
-      return true if !block_given? and count > 0
-      super
-    end
-
-    def none?(&blk)
-      return true if count == 0
-      return false if !block_given? and count > 0
-      if block_given?
-        # sabshere 2/1/11 ActiveRecord does this for #any? but not for #none?
-        to_a.none? &blk
+    # Recursively look for a scope that meets the characteristics and is at least <tt>minimum_cohort_size</tt>.
+    def resolve
+      if @characteristics.empty?
+        IMPOSSIBLE
+      elsif (current = @active_record.where(CohortScope.conditions_for(@characteristics))).count >= @minimum_cohort_size
+        current.constraints.inject(:and).to_sql
       else
-        super
+        @characteristics = self.class.reduce_characteristics(@active_record, @characteristics)
+        resolve
       end
     end
-    
-    def where_value_nodes
-      __getobj__.instance_variable_get(:@where_values)
-    end
-    
-    def active_record
-      __getobj__.klass
-    end
-    
-    def +(other)
-      case other
-      when Cohort
-        combined_conditions = (where_value_nodes + other.where_value_nodes).inject(nil) do |memo, node|
-          if memo.nil?
-            node
-          else
-            memo.or(node)
-          end
-        end
-        Cohort.new active_record.where(combined_conditions)
-      else
-        super
-      end
-    end
-
-    def inspect
-      "#<#{self.class.name} with #{count} members>"
-    end
   end
 end

data/lib/cohort_scope/strict_cohort.rb

@@ -1,8 +1,8 @@
 module CohortScope
   class StrictCohort < Cohort
-    # Reduce constraints by removing the least important one.
-    def self.reduce_constraints(active_record, constraints)
-      constraints[0..-2]
+    # Reduce characteristics by removing the least important one.
+    def self.reduce_characteristics(active_record, characteristics)
+      characteristics[0..-2]
     end
   end
 end

data/lib/cohort_scope/version.rb

@@ -1,3 +1,3 @@
 module CohortScope
-  VERSION = '0.2.3'
+  VERSION = '0.3.0'
 end

data/test/helper.rb

@@ -6,6 +6,10 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'cohort_scope'
 
+if ::Bundler.definition.specs['ruby-debug19'].first or ::Bundler.definition.specs['ruby-debug'].first
+  require 'ruby-debug'
+end
+  
 class Test::Unit::TestCase
 end
 

data/test/test_big_cohort.rb

@@ -8,24 +8,24 @@ class TestBigCohort < Test::Unit::TestCase
 
   def test_001_empty
     cohort = Citizen.big_cohort :favorite_color => 'heliotrope'
-    assert_equal 0, cohort.count
+    assert_equal 0, Citizen.where(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
+    assert_equal 1, Citizen.where(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 }
+    assert_equal 9, Citizen.where(cohort).count
+    assert Citizen.where(cohort).any? { |m| m.favorite_color != 'heliotrope' }
+    assert Citizen.where(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
+    assert_equal 3, Citizen.where(Citizen.big_cohort({:favorite_color => 'blue'}, :minimum_cohort_size => 0)).count
+    assert_equal 1, Citizen.where(Citizen.big_cohort({:favorite_color => 'heliotrope'}, :minimum_cohort_size => 0)).count
+    assert_equal 4, Citizen.where(Citizen.big_cohort({:favorite_color => ['heliotrope', 'blue']}, :minimum_cohort_size => 0)).count
   end
 end

data/test/test_cohort_scope.rb

@@ -18,103 +18,24 @@ class TestCohortScope < Test::Unit::TestCase
     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
-  #   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
-  
-  def test_004_really_run_blocks
-    assert_raises(RuntimeError, 'A') do
-      Citizen.big_cohort(:birthdate => @date_range).all? { |c| raise 'A' }
-    end
-    assert_raises(RuntimeError, 'B') do
-      Citizen.big_cohort(:birthdate => @date_range).any? { |c| raise 'B' }
-    end
-    assert_raises(RuntimeError, 'C') do
-      Citizen.big_cohort(:birthdate => @date_range).none? { |c| raise 'C' }
-    end
-  end
-  
-  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
-  
-  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
-  
-  def test_007_doesnt_mess_with_active_record_inspect
-    non_cohort = Citizen.all
-    assert_equal non_cohort.to_a.inspect, non_cohort.inspect
-  end
-  
-  def test_008_short_inspect
-    cohort = Citizen.big_cohort :birthdate => @date_range, :favorite_color => 'heliotrope'
-    assert_equal "#<CohortScope::BigCohort with 9 members>", cohort.inspect
-  end
-  
-  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
-  
-  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
+  def test_002_to_sql
+    assert %r{BETWEEN.*#{@date_range.first}.*#{@date_range.last}}.match(Citizen.big_cohort(:birthdate => @date_range).to_sql)
+    assert %r{.citizens...favorite_color. = 'heliotrope'}.match(Citizen.big_cohort({:favorite_color => 'heliotrope'}, :minimum_cohort_size => 1).to_sql)
+    assert_equal %{1 = 2}, Citizen.big_cohort(:favorite_color => 'osijdfosidfj').to_sql
   end
   
   def test_011_combine_scopes_with_or
     nobody = Citizen.big_cohort({:favorite_color => 'oaisdjaoisjd'}, :minimum_cohort_size => 1)
-    assert_equal 0, nobody.count
+    assert_equal 0, Citizen.where(nobody).count
     people_who_love_heliotrope_are_from_the_fifties = Citizen.big_cohort({:favorite_color => 'heliotrope'}, :minimum_cohort_size => 1)
-    assert_equal 1, people_who_love_heliotrope_are_from_the_fifties.count
-    assert people_who_love_heliotrope_are_from_the_fifties.none? { |c| @date_range.include? c.birthdate }
+    assert_equal 1, Citizen.where(people_who_love_heliotrope_are_from_the_fifties).count
+    assert Citizen.where(people_who_love_heliotrope_are_from_the_fifties).none? { |c| @date_range.include? c.birthdate }
     their_children_are_born_in_the_eighties = Citizen.big_cohort({:birthdate => @date_range}, :minimum_cohort_size => 1)
-    assert_equal 9, their_children_are_born_in_the_eighties.count
-    everybody = (people_who_love_heliotrope_are_from_the_fifties + their_children_are_born_in_the_eighties + nobody)
-    assert_kind_of CohortScope::Cohort, everybody
-    assert_equal 10, everybody.count
+    assert_equal 9, Citizen.where(their_children_are_born_in_the_eighties).count
+    everybody = people_who_love_heliotrope_are_from_the_fifties.or(their_children_are_born_in_the_eighties).or(nobody)
+    assert_equal 10, Citizen.where(everybody).count
   end
-  
-  def test_012_to_cohort
-    relation = Citizen.big_cohort({:favorite_color => 'heliotrope'}, :minimum_cohort_size => 1).where(:birthdate => @date_range)
-    assert_equal [], relation.as_json
-    assert_equal({ :members => 0 }, relation.to_cohort.as_json)
-  end
-  
-  def test_013_count_is_forced
-    cohort = Citizen.big_cohort(:birthdate => @date_range)
-
-    cohort.count = 0
-    assert !cohort.any?
-    assert cohort.none?
-    assert cohort.empty?
 
-    cohort.count = 1
-    assert cohort.any?
-    assert !cohort.none?
-    assert !cohort.empty?
-  end
-  
   private
   
   def style

data/test/test_strict_cohort.rb

@@ -8,22 +8,38 @@ class TestStrictCohort < Test::Unit::TestCase
 
   def test_001_empty
     cohort = Citizen.strict_cohort 
-    assert_equal 0, cohort.count
+    assert_equal 0, Citizen.where(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
+    assert_equal 1, Citizen.where(cohort).count
   end
 
-  def test_003_seek_cohort_by_discarding_constraints_in_order
+  def test_003_seek_cohort_by_discarding_characteristics_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
+    assert_equal 0, Citizen.where(cohort).count
 
     cohort = Citizen.strict_cohort *birthdate_matters_most
-    assert_equal 9, cohort.count
+    assert_equal 9, Citizen.where(cohort).count
   end
+
+  # TODO: undo the annoying splat thing
+  # characteristics = (args.first.is_a?(::Array) and not args.first.first.is_a?(::Symbol)) ? args.first : args
+  # def test_004_accepts_non_splat_array
+  #   cohort = Citizen.strict_cohort [[:favorite_color, 'heliotrope']], :minimum_cohort_size => 0
+  #   assert_equal 1, Citizen.where(cohort).count
+  # 
+  #   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, Citizen.where(cohort).count
+  # 
+  #   cohort = Citizen.strict_cohort birthdate_matters_most
+  #   assert_equal 9, Citizen.where(cohort).count
+  # end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cohort_scope
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,11 +11,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-22 00:00:00.000000000 Z
+date: 2012-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2152803180 !ruby/object:Gem::Requirement
+  requirement: &2152961320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -23,10 +23,10 @@ dependencies:
         version: '3'
   type: :runtime
   prerelease: false
-  version_requirements: *2152803180
+  version_requirements: *2152961320
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &2152802420 !ruby/object:Gem::Requirement
+  requirement: &2152960780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -34,43 +34,10 @@ dependencies:
         version: '3'
   type: :runtime
   prerelease: false
-  version_requirements: *2152802420
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: &2152801900 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2152801900
-- !ruby/object:Gem::Dependency
-  name: mysql2
-  requirement: &2152801240 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2152801240
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: &2152800640 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2152800640
-description: Provides big_cohort, which widens by finding the constraint that eliminates
-  the most records and removing it. Also provides strict_cohort, which widens by eliminating
-  constraints in order.
+  version_requirements: *2152960780
+description: Provides big_cohort, which widens by finding the characteristic that
+  eliminates the most records and removing it. Also provides strict_cohort, which
+  widens by eliminating characteristics in order.
 email:
 - seamus@abshere.net
 executables: []
@@ -79,12 +46,16 @@ extra_rdoc_files: []
 files:
 - .document
 - .gitignore
+- CHANGELOG
 - Gemfile
 - LICENSE
 - README.rdoc
 - Rakefile
 - cohort_scope.gemspec
 - lib/cohort_scope.rb
+- lib/cohort_scope/active_record_base_class_methods.rb
+- lib/cohort_scope/active_record_relation_instance_methods.rb
+- lib/cohort_scope/arel_visitors_visitor_instance_methods.rb
 - lib/cohort_scope/big_cohort.rb
 - lib/cohort_scope/cohort.rb
 - lib/cohort_scope/strict_cohort.rb