cohort_scope 0.0.7 → 0.1.0

data/Rakefile

@@ -13,7 +13,7 @@ begin
     gem.add_dependency "activesupport", ">=3.0.0.beta4"
     gem.add_dependency "activerecord", ">=3.0.0.beta4"
     gem.add_development_dependency "shoulda", ">= 2.10.3"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+    gem.add_development_dependency 'sqlite3-ruby'
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.1.0

data/cohort_scope.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cohort_scope}
-  s.version = "0.0.7"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Seamus Abshere", "Andy Rossmeissl", "Derek Kastner"]
-  s.date = %q{2010-08-20}
+  s.date = %q{2010-10-15}
   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.email = %q{seamus@abshere.net}
   s.extra_rdoc_files = [
@@ -25,7 +25,11 @@ Gem::Specification.new do |s|
      "VERSION",
      "cohort_scope.gemspec",
      "lib/cohort_scope.rb",
+     "lib/cohort_scope/big_cohort.rb",
+     "lib/cohort_scope/cohort.rb",
+     "lib/cohort_scope/strict_cohort.rb",
      "test/helper.rb",
+     "test/test_cohort.rb",
      "test/test_cohort_scope.rb"
   ]
   s.homepage = %q{http://github.com/seamusabshere/cohort_scope}
@@ -35,6 +39,7 @@ Gem::Specification.new do |s|
   s.summary = %q{Provides cohorts (in the form of ActiveRecord scopes) that dynamically widen until they contain a certain number of records.}
   s.test_files = [
     "test/helper.rb",
+     "test/test_cohort.rb",
      "test/test_cohort_scope.rb"
   ]
 
@@ -46,15 +51,18 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<activesupport>, [">= 3.0.0.beta4"])
       s.add_runtime_dependency(%q<activerecord>, [">= 3.0.0.beta4"])
       s.add_development_dependency(%q<shoulda>, [">= 2.10.3"])
+      s.add_development_dependency(%q<sqlite3-ruby>, [">= 0"])
     else
       s.add_dependency(%q<activesupport>, [">= 3.0.0.beta4"])
       s.add_dependency(%q<activerecord>, [">= 3.0.0.beta4"])
       s.add_dependency(%q<shoulda>, [">= 2.10.3"])
+      s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
     end
   else
     s.add_dependency(%q<activesupport>, [">= 3.0.0.beta4"])
     s.add_dependency(%q<activerecord>, [">= 3.0.0.beta4"])
     s.add_dependency(%q<shoulda>, [">= 2.10.3"])
+    s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
   end
 end
 

data/lib/cohort_scope.rb

@@ -1,28 +1,12 @@
 require 'active_record'
 require 'active_support'
 require 'active_support/version'
-%w{
-  active_support/core_ext/module/delegation
-}.each do |active_support_3_requirement|
-  require active_support_3_requirement
-end if ActiveSupport::VERSION::MAJOR == 3
 
-module ActiveRecord
-  class Relation
-    def inspect_count_only!
-      @inspect_count_only = true
-    end
-    def inspect_count_only?
-      @inspect_count_only == true
-    end
-    def as_json(*)
-      inspect_count_only? ? { :members => count } : super
-    end
-    def inspect
-      inspect_count_only? ? "<Massive ActiveRecord scope with #{count} members>" : super
-    end
-  end
-end
+require 'active_support/core_ext/module/delegation' if ActiveSupport::VERSION::MAJOR == 3
+
+require 'cohort_scope/cohort'
+require 'cohort_scope/big_cohort'
+require 'cohort_scope/strict_cohort'
 
 module CohortScope
   def self.extended(klass)
@@ -31,9 +15,9 @@ module CohortScope
 
   # 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 = nil)
+  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)
-    _cohort_scope constraints, custom_minimum_cohort_size
+    BigCohort.create self, constraints, custom_minimum_cohort_size
   end
 
   # Find the first acceptable scope by removing constraints <b>in strict order</b>, starting with the last constraint.
@@ -52,107 +36,8 @@ module CohortScope
   #
   # 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 = nil)
+  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)
-    _cohort_scope constraints, custom_minimum_cohort_size
-  end
-
-  protected
-
-  # Recursively look for a scope that meets the constraints and is at least <tt>minimum_cohort_size</tt>.
-  def _cohort_scope(constraints, custom_minimum_cohort_size)
-    raise RuntimeError, "You need to set #{name}.minimum_cohort_size = X" unless minimum_cohort_size.present?
-    
-    if constraints.values.none? # failing base case
-      empty_cohort = scoped.where '1 = 2'
-      empty_cohort.inspect_count_only!
-      return empty_cohort
-    end
-    
-    this_hash = _cohort_constraints constraints
-    this_count = scoped.where(this_hash).count
-    
-    if this_count >= (custom_minimum_cohort_size || minimum_cohort_size) # successful base case
-      cohort = scoped.where this_hash
-    else
-      cohort = _cohort_scope _cohort_reduce_constraints(constraints), custom_minimum_cohort_size
-    end
-    cohort.inspect_count_only!
-    cohort
-  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 _cohort_constraints(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)
-        condition = { _cohort_association_primary_key(k) => v.to_param }
-      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 integer primary keys.
-  #
-  # Only works for <tt>belongs_to</tt> relationships.
-  #
-  # For example, :car => <#Car> might get translated into :car_id => 44.
-  def _cohort_association_primary_key(name)
-    @_cohort_association_primary_keys ||= {}
-    return @_cohort_association_primary_keys[name] if @_cohort_association_primary_keys.has_key? name
-    a = reflect_on_association name
-    raise "can't use cohort scope on :through associations (#{self.name} #{name})" if a.options.has_key? :through
-    if !a.primary_key_name.blank?
-      @_cohort_association_primary_keys[name] = a.primary_key_name
-    else
-      raise "we need some other way to find primary key"
-    end
-  end
-  
-  # Choose how to reduce constraints based on whether we're looking for a big cohort or a strict cohort.
-  def _cohort_reduce_constraints(constraints)
-    case constraints
-    when ActiveSupport::OrderedHash
-      _cohort_reduce_constraints_in_order constraints
-    when Hash
-      _cohort_reduce_constraints_seeking_maximum_count constraints
-    else
-      raise "what did you pass me? #{constraints}"
-    end
-  end
-  
-  # (Used by <tt>big_cohort</tt>)
-  #
-  # 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 _cohort_reduce_constraints_seeking_maximum_count(constraints)
-    highest_count_after_removal = nil
-    losing_key = nil
-    constraints.keys.each do |key|
-      test_constraints = constraints.except(key)
-      count_after_removal = scoped.where(_cohort_constraints(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
-    end
-    constraints.except losing_key
-  end
-
-  # (Used by <tt>strict_cohort</tt>)
-  #
-  # Reduce constraints by removing the least important one.
-  def _cohort_reduce_constraints_in_order(constraints)
-    reduced_constraints = constraints.dup
-    reduced_constraints.delete constraints.keys.last
-    reduced_constraints
+    StrictCohort.create self, constraints, custom_minimum_cohort_size
   end
 end

data/lib/cohort_scope/big_cohort.rb

@@ -0,0 +1,21 @@
+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
+      end
+      constraints.except losing_key
+    end
+  end
+end

data/lib/cohort_scope/cohort.rb

@@ -0,0 +1,81 @@
+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(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)
+        end
+
+        constraint_hash = sanitize_constraints model, constraints
+        constrained_scope = model.scoped.where(constraint_hash)
+
+        if constrained_scope.count >= custom_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)
+            primary_key = association_primary_key(model, k)
+            param = v.respond_to?(primary_key) ? v.send(primary_key) : v.to_param
+            condition = { primary_key => param }
+          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 integer primary keys.
+      #
+      # Only works for <tt>belongs_to</tt> relationships.
+      #
+      # For example, :car => <#Car> might get translated into :car_id => 44.
+      def association_primary_key(model, name)
+        @_cohort_association_primary_keys ||= {}
+        return @_cohort_association_primary_keys[name] if @_cohort_association_primary_keys.has_key? name
+        a = model.reflect_on_association name
+        raise "there is no association #{name.inspect} on #{model}" if a.nil?
+        raise "can't use cohort scope on :through associations (#{self.name} #{name})" if a.options.has_key? :through
+        if !a.primary_key_name.blank?
+          @_cohort_association_primary_keys[name] = a.primary_key_name
+        else
+          raise "we need some other way to find primary key"
+        end
+      end
+    end
+
+    def initialize(obj)
+      @_ch_obj = obj
+    end
+    def __getobj__
+      @_ch_obj
+    end
+
+    def as_json(*)
+      { :members => count }
+    end
+
+    def inspect
+      "<Massive ActiveRecord scope with #{count} members>"
+    end
+  end
+end

data/lib/cohort_scope/strict_cohort.rb

@@ -0,0 +1,13 @@
+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
+    end
+  end
+end

data/test/helper.rb

@@ -18,10 +18,8 @@ ActiveSupport::Notifications.subscribe do |*args|
 end
 
 ActiveRecord::Base.establish_connection(
-  'adapter' => 'mysql',
-  'database' => 'cohort_scope_test',
-  'username' => 'root',
-  'password' => 'password'
+  'adapter' => 'sqlite3',
+  'database' => ':memory:'
 )
 
 ActiveRecord::Schema.define(:version => 20090819143429) do
@@ -30,6 +28,19 @@ ActiveRecord::Schema.define(:version => 20090819143429) do
     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
 end
 
 class Citizen < ActiveRecord::Base
@@ -54,3 +65,28 @@ end
 ].each do |birthdate, favorite_color, teeth|
   Citizen.create! :birthdate => birthdate, :favorite_color => favorite_color, :teeth => teeth
 end
+
+class Style < ActiveRecord::Base
+  extend CohortScope
+  self.minimum_cohort_size = 3
+  has_many :houses
+end
+class House < ActiveRecord::Base
+  belongs_to :style, :foreign_key => 'period', :primary_key => 'period'
+  has_one :resident
+end
+class Resident < ActiveRecord::Base
+  has_one :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
+Resident.create! :house => h1, :name => 'Bob'
+Resident.create! :house => h2, :name => 'Rob'
+Resident.create! :house => h3, :name => 'Gob'

data/test/test_cohort.rb

@@ -0,0 +1,44 @@
+require 'helper'
+
+class TestCohortScope < 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_primary_key' do
+    should 'include constraints that are models related by a primary key' do
+      gob = Resident.find_by_name('Gob')
+      key = CohortScope::Cohort.association_primary_key Resident, :house
+      assert_equal 'resident_id', key
+    end
+    should 'include constraints that are models related by a non-primary key' do
+      key = CohortScope::Cohort.association_primary_key House, :style
+      assert_equal 'period', key
+    end
+  end
+end

data/test/test_cohort_scope.rb

@@ -26,6 +26,12 @@ class TestCohortScope < Test::Unit::TestCase
     assert_equal "<Massive ActiveRecord scope with 9 members>", cohort.inspect
   end
 
+  should "retain the scope's original behavior" do
+    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) {
@@ -59,11 +65,6 @@ class TestCohortScope < Test::Unit::TestCase
         Citizen.big_cohort ActiveSupport::OrderedHash.new
       }
     end
-    
-    should "result in a relation that has inspect_count_only set" do
-      cohort = Citizen.big_cohort :favorite_color => 'heliotrope'
-      assert cohort.inspect_count_only?
-    end
   end
   
   context "strict_cohort" do
@@ -104,13 +105,5 @@ class TestCohortScope < Test::Unit::TestCase
       cohort = Citizen.strict_cohort birthdate_matters_most
       assert_equal 9, cohort.count
     end
-    
-    should "result in a relation that has inspect_count_only set" do
-      ordered_attributes = ActiveSupport::OrderedHash.new
-      ordered_attributes[:favorite_color] = 'heliotrope'
-    
-      cohort = Citizen.strict_cohort ordered_attributes
-      assert cohort.inspect_count_only?
-    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cohort_scope
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 7
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors: 
 - Seamus Abshere
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-20 00:00:00 -04:00
+date: 2010-10-15 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -70,6 +70,20 @@ dependencies:
         version: 2.10.3
   type: :development
   version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
 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.
 email: seamus@abshere.net
 executables: []
@@ -88,7 +102,11 @@ files:
 - VERSION
 - cohort_scope.gemspec
 - lib/cohort_scope.rb
+- lib/cohort_scope/big_cohort.rb
+- lib/cohort_scope/cohort.rb
+- lib/cohort_scope/strict_cohort.rb
 - test/helper.rb
+- test/test_cohort.rb
 - test/test_cohort_scope.rb
 has_rdoc: true
 homepage: http://github.com/seamusabshere/cohort_scope
@@ -126,4 +144,5 @@ 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_cohort_scope.rb