ninjudd-model_set 0.9.2

data/lib/model_set/sql_base_query.rb

@@ -0,0 +1,52 @@
+class ModelSet
+  class SQLBaseQuery < Query
+    # SQL methods common to SQLQuery and RawSQLQuery.
+    def ids
+      @ids ||= fetch_id_set(sql)
+    end
+    
+    def size
+      @size ||= ids.size
+    end
+
+  private
+    
+    def ids_clause(ids, field = id_field_with_prefix)
+      db.ids_clause(ids, field)
+    end
+
+    def fetch_id_set(sql)
+      db.select_values(sql).collect {|id| id.to_i}.to_ordered_set
+    end
+
+    def db
+      model_class.connection
+    end
+    
+    def sanitize_condition(condition)
+      ActiveRecord::Base.send(:sanitize_sql, condition)
+    end
+    
+    def limit_clause
+      return unless limit
+      limit_clause = "LIMIT #{limit}"
+      limit_clause << " OFFSET #{offset}" if offset > 0
+      limit_clause
+    end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::AbstractAdapter
+  def ids_clause(ids, field)
+    # Make sure all ids are integers to prevent SQL injection attacks.
+    ids = ids.collect {|id| id.to_i}
+
+    if ids.empty?
+      "FALSE"
+    elsif kind_of?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+      "#{field} = ANY ('{#{ids.join(',')}}'::bigint[])"
+    else
+      "#{field} IN (#{ids.join(',')})"
+    end
+  end
+end

data/lib/model_set/sql_query.rb

@@ -0,0 +1,75 @@
+class ModelSet
+  class SQLQuery < SQLBaseQuery
+    include Conditioned
+
+    def anchor!(query)
+      if query.respond_to?(:sql)
+        sql = "#{id_field_with_prefix} IN (#{query.sql})"
+      else
+        sql = ids_clause(query.ids)
+      end
+      add_conditions!(sql)
+    end
+    
+    def aggregate(query, opts = {})
+      sql = "SELECT #{query} #{from_clause}"
+      sql << " LIMIT #{opts[:limit]}"       if opts[:limit]
+      sql << " GROUP BY #{opts[:group_by]}" if opts[:group_by]
+      result = db.select_rows(sql).first
+      result.size == 1 ? result.first : result
+    end
+
+    def add_joins!(*joins)
+      @joins ||= []
+
+      joins.each do |join|
+        @joins << sanitize_condition(join)
+      end
+      @joins.uniq!
+
+      clear_cache!
+    end
+
+    def in!(ids, field = id_field_with_prefix)
+      add_conditions!( ids_clause(ids, field) )
+    end
+
+    def order_by!(order, joins = nil)
+      @sort_order = order
+      @sort_joins = joins
+      clear_cache!
+    end
+  
+    def sql
+      "#{select_clause} #{from_clause} #{order_clause} #{limit_clause}"
+    end
+
+    def count
+      @count ||= limit ? aggregate("COUNT(DISTINCT #{id_field_with_prefix})").to_i : size
+    end
+    
+  private
+    
+    def select_clause
+      "SELECT #{id_field_with_prefix}"
+    end
+        
+    def from_clause
+      "FROM #{table_name} #{join_clause} WHERE #{conditions.to_s}"
+    end
+    
+    def order_clause
+      return unless @sort_order
+      # Prevent SQL injection attacks.
+      "ORDER BY #{@sort_order.gsub(/[^\w_, \.\(\)'\"]/, '')}"
+    end
+        
+    def join_clause
+      return unless @joins or @sort_joins
+      joins = []
+      joins << @joins      if @joins
+      joins << @sort_joins if @sort_joins      
+      joins.join(' ')
+    end
+  end
+end

data/lib/multi_set.rb

@@ -0,0 +1,67 @@
+class MultiSet
+  include Enumerable
+  deep_clonable
+  
+  attr_accessor :sets
+  
+  def initialize(*sets)
+    @sets = sets
+  end
+  
+  def add!(other)
+    if other.kind_of?(MultiSet)
+      sets.concat(other.sets)
+    else
+      sets << other
+    end
+    self
+  end
+
+  alias << add!
+  
+  def method_missing(method_name, *args)
+    method_name = method_name.to_s
+    if method_name =~ /\!$/
+      sets.each do |set|
+        set.send(method_name, *args)
+      end
+      self 
+    else
+      sets.collect do |set|
+        set.send(method_name, *args)
+      end
+    end
+  end
+  
+  def ids_by_class
+    ids_by_class = {}
+    sets.each do |set|
+      ids_by_class[set.model_class] ||= OrderedSet.new
+      ids_by_class[set.model_class].concat(set.ids)
+    end
+    ids_by_class.keys.each do |model_class|
+      ids_by_class[model_class] = ids_by_class[model_class].to_a
+    end
+    ids_by_class
+  end
+  
+  def ids
+    ids = OrderedSet.new
+    sets.each do |set|
+      ids.concat(set.ids)
+    end
+    ids.to_a
+  end
+  
+  def each
+    sets.each do |set|
+      set.each do |model|
+        yield model
+      end
+    end
+  end
+  
+  clone_method :+, :add!
+  clone_method :-, :subtract!
+  clone_method :&, :intersect!
+end

data/test/model_set_test.rb

@@ -0,0 +1,283 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ModelSetTest < Test::Unit::TestCase
+  class CreateTables < ActiveRecord::Migration    
+    def self.up
+      create_table :heroes do |t|
+        t.column :name, :string
+        t.column :universe, :string
+      end
+
+      create_table :superpowers do |t|
+        t.column :name, :string
+      end
+
+      create_table :mutations do |t|
+        t.column :name, :string
+      end
+
+      create_table :superpets do |t|
+        t.column :name, :string
+        t.column :species, :string
+        t.column :owner_id, :bigint
+      end
+
+      create_table :hero_superpowers do |t|
+        t.column :hero_id,    :bigint
+        t.column :power_type, :string
+        t.column :power_id,   :bigint
+      end
+
+      create_table :hero_birthdays do |t|
+        t.column :hero_id, :bigint
+        t.column :birthday, :date
+      end
+
+      create_table :robots do |t|
+        t.string :name
+        t.string :classification
+      end
+    end
+
+    def self.down
+      drop_table :heroes
+      drop_table :superpowers
+      drop_table :mutations
+      drop_table :superpets
+      drop_table :hero_superpowers
+      drop_table :hero_birthdays
+      drop_table :robots
+    end
+  end
+  
+  class Superpower < ActiveRecord::Base
+  end
+
+  class Mutation < ActiveRecord::Base
+  end
+
+  class Superpet < ActiveRecord::Base
+  end
+
+  class HeroSuperpower < ActiveRecord::Base
+  end
+
+  class Hero < ActiveRecord::Base
+    set_table_name 'heroes'
+    has_set :superpowers, :through => :hero_superpowers, :other_key => :power_id
+    has_set :pets, :class_name => 'Superpet', :own_key => :owner_id do
+      def dogs!
+        add_conditions!("species = 'dog'")
+      end
+    end
+  end
+  
+  class HeroSet < ModelSet
+    constructor  :with_universe
+    clone_method :with_universe
+    def with_universe!(universe)
+      add_conditions!("universe = '#{universe}'")
+    end    
+
+    clone_method :add_birthday
+    def add_birthday!
+      add_fields!( "hero_birthdays.birthday" => "LEFT OUTER JOIN hero_birthdays ON heroes.id = hero_birthdays.hero_id" )
+    end
+  end
+
+  context 'with a db connection' do
+    setup do
+      CreateTables.verbose = false
+      CreateTables.up
+    end
+  
+    teardown do
+      CreateTables.down
+    end
+  
+    should "construct a model set" do
+      captain  = Hero.create(:name => 'Captain America', :universe => 'Marvel')
+      spidey   = Hero.create(:name => 'Spider Man',      :universe => 'Marvel')
+      batman   = Hero.create(:name => 'Batman',          :universe => 'D.C.'  )
+      superman = Hero.create(:name => 'Superman',        :universe => 'D.C.'  )
+      ironman  = Hero.create(:name => 'Iron Man',        :universe => 'Marvel')
+      
+      set = HeroSet.with_universe('Marvel')
+      assert_equal [captain.id, spidey.id, ironman.id], set.ids
+    end
+  
+    should "have missing ids" do
+      missing_id = 5555
+      spidey = Hero.create(:name => 'Spider Man', :universe => 'Marvel')
+      set = HeroSet.new([spidey.id, missing_id])
+      
+      # Iterate through the profiles so the missing ones will be detected.
+      set.each {}
+      assert_equal [missing_id], set.missing_ids
+    end
+  
+    should "have missing ids with add_fields" do
+      missing_id = 5555
+      spidey = Hero.create(:name => 'Spider Man', :universe => 'Marvel')
+      set = HeroSet.new([spidey.id, missing_id]).add_birthday
+      
+      # Iterate through the profiles so the missing ones will be detected.
+      set.each {}
+      assert_equal [missing_id], set.missing_ids
+    end
+  
+    should "support has_set" do
+      hero = Hero.create(:name => 'Mr. Invisible')
+      mighty_mouse = Superpet.create(:name => 'Mighty Mouse', :owner_id => hero.id)
+      underdog     = Superpet.create(:name => 'Underdog', :owner_id => hero.id)
+      
+      set = hero.pets
+      assert_equal SuperpetSet, set.class
+      assert_equal [mighty_mouse.id, underdog.id], set.ids
+    end
+    
+    should "support has_set with through" do
+      hero = Hero.create(:name => 'Mr. Invisible')
+      invisibility = Superpower.create(:name => 'Invisibility')
+      flying       = Superpower.create(:name => 'Flying')
+      HeroSuperpower.create(:hero_id => hero.id, :power_id => invisibility.id)
+      HeroSuperpower.create(:hero_id => hero.id, :power_id => flying.id)
+      
+      set = hero.superpowers
+      assert_equal SuperpowerSet, set.class
+      assert_equal [invisibility.id, flying.id], set.ids
+    end
+  
+  
+    should "allow set extensions" do
+      hero = Hero.create(:name => 'Mr. Invisible')
+      mighty_mouse = Superpet.create(:name => 'Mighty Mouse', :owner_id => hero.id, :species => 'mouse')
+      sammy        = Superpet.create(:name => 'Sammy Davis Jr. Jr.', :owner_id => hero.id, :species => 'dog')
+      underdog     = Superpet.create(:name => 'Underdog', :owner_id => hero.id, :species => 'dog')
+      
+      set = hero.pets
+      assert_equal ['mouse', 'dog', 'dog'], set.collect {|pet| pet.species}
+      
+      assert_equal [sammy.id, underdog.id], set.dogs!.ids
+    end
+
+    class Robot < ActiveRecord::Base
+    end
+    
+    class RobotSet < ModelSet
+    end
+
+    setup do
+      @bender       = Robot.create(:name => 'Bender',     :classification => :smart_ass )
+      @r2d2         = Robot.create(:name => 'R2D2',       :classification => :droid     )
+      @c3po         = Robot.create(:name => 'C3PO',       :classification => :droid     )
+      @rosie        = Robot.create(:name => 'Rosie',      :classification => :domestic  )
+      @small_wonder = Robot.create(:name => 'Vicki',      :classification => :child     )
+      @t1000        = Robot.create(:name => 'Terminator', :classification => :assasin   )
+      @johnny5      = Robot.create(:name => 'Johnny 5',   :classification => :miltary   )
+      
+      @bot_set = RobotSet.new([@bender,@r2d2,@c3po,@rosie,@small_wonder,@t1000,@johnny5])
+      
+      @data    = Robot.create(:name => 'Data',       :classification => :positronic)
+      @number8 = Robot.create(:name => 'Boomer',     :classification => :cylon     )
+    end
+  
+    should "be empty" do
+      set = RobotSet.empty
+      assert_equal 0, set.size
+      assert set.empty?
+      
+      set = RobotSet.new(@bender)
+      assert !set.empty?
+    end
+
+    should "create a set with single model" do
+      set = RobotSet.new(@bender)
+      assert_equal [@bender.id], set.ids
+    end
+
+    should "include models" do
+      set = RobotSet.new([@bender, @r2d2.id, @c3po.id])
+      assert set.include?(@bender)
+      assert set.include?(@r2d2.id)
+      assert set.include?(@c3po)
+    end
+
+    should "delete models from a set" do
+      set = RobotSet.new([@rosie, @small_wonder, @c3po])
+      
+      set.delete(@c3po)
+      assert_equal [@rosie.id, @small_wonder.id], set.ids
+      
+      set.delete(@rosie.id)
+      assert_equal [@small_wonder.id], set.ids
+      
+      set.delete(@small_wonder)
+      assert_equal [], set.ids
+      assert set.empty?
+    end
+
+    should "select models from a set" do
+      assert_equal [@r2d2, @c3po], @bot_set.select {|bot| bot.classification == :droid}.to_a
+      assert_equal 7, @bot_set.size
+      
+      @bot_set.select! {|bot| bot.classification == :miltary}
+      assert_equal [@johnny5], @bot_set.to_a 
+    end
+    
+    should "sort a set" do
+      assert_equal [@bender,@c3po,@johnny5,@r2d2,@rosie,@t1000,@small_wonder], @bot_set.sort {|a,b| a.name <=> b.name}.to_a
+      assert_equal @johnny5, @bot_set.last
+      
+      @bot_set.sort! {|a,b| b.name <=> a.name}
+      assert_equal [@bender,@c3po,@johnny5,@r2d2,@rosie,@t1000,@small_wonder].reverse, @bot_set.to_a 
+    end
+    
+    should "sort a set by name" do
+      assert_equal [@bender,@c3po,@johnny5,@r2d2,@rosie,@t1000,@small_wonder], @bot_set.sort_by {|bot| bot.name}.to_a
+    end
+    
+    should "reject models from a set" do
+      @bot_set.reject! {|bot| bot.classification == :domestic}
+      assert !@bot_set.include?(@rosie)
+    end
+
+    should "do set arithmetic" do
+      droids    = RobotSet.new([@c3po, @r2d2])
+      womanoids = RobotSet.new([@rosie, @small_wonder, @number8])
+      humanoids = RobotSet.new([@small_wonder, @t1000, @data, @number8])
+      metalics  = RobotSet.new([@r2d2, @c3po, @johnny5])
+      cartoons  = RobotSet.new([@bender, @rosie])
+      
+      assert_equal ['C3PO', 'R2D2', 'Johnny 5'],                    (droids + metalics).collect {|bot| bot.name}
+      assert_equal ['Bender', 'Rosie', 'C3PO', 'R2D2', 'Johnny 5'], (cartoons + droids + metalics).collect {|bot| bot.name}
+      assert_equal 5, (cartoons + droids + metalics).size
+      assert_equal 5, (cartoons + droids + metalics).count
+      
+      assert_equal [],                     (droids - metalics).collect {|bot| bot.name}
+      assert_equal ['Johnny 5'],           (metalics - droids).collect {|bot| bot.name}
+      assert_equal ['Terminator', 'Data'], (humanoids - womanoids).collect {|bot| bot.name}
+      assert_equal ['Bender'],             (cartoons - womanoids).collect {|bot| bot.name}
+      assert_equal 2, (humanoids - womanoids).size
+      assert_equal 2, (humanoids - womanoids).count
+      
+      assert_equal ['C3PO', 'R2D2'],    (droids & metalics).collect {|bot| bot.name}
+      assert_equal ['R2D2', 'C3PO'],    (metalics & droids).collect {|bot| bot.name}
+      assert_equal ['Vicki', 'Boomer'], (humanoids & womanoids).collect {|bot| bot.name}
+      assert_equal ['Rosie'],           (cartoons & womanoids).collect {|bot| bot.name}
+      assert_equal 2, (humanoids & womanoids).size
+      assert_equal 2, (humanoids & womanoids).count
+
+      set = (droids + @johnny5)
+      assert_equal ['C3PO', 'R2D2', 'Johnny 5'], set.collect {|bot| bot.name}
+      set -= @r2d2
+      assert_equal ['C3PO', 'Johnny 5'], set.collect {|bot| bot.name}
+    end
+    
+    should "clone a set" do
+      set     = RobotSet.new([1])
+      new_set = set.clone
+      assert new_set.object_id != set.object_id
+    end
+  end
+end