polymorpheus 2.0.0 → 2.0.1

data/lib/polymorpheus/interface.rb

@@ -67,14 +67,21 @@ module Polymorpheus
 
         class_name = options[:class_name] || association.to_s.classify
 
-        options[:conditions] = proc {
+        options[:conditions] = proc do
           keys = class_name.constantize
                   .const_get('POLYMORPHEUS_ASSOCIATIONS')
                   .map(&:foreign_key)
           keys.delete(fkey)
 
-          keys.reduce({}) { |hash, key| hash.merge!(key => nil) }
-        }
+          nil_columns = keys.reduce({}) { |hash, key| hash.merge!(key => nil) }
+
+
+          if self.is_a?(ActiveRecord::Associations::JoinDependency::JoinAssociation)
+            { aliased_table_name => nil_columns }
+          else
+            { association => nil_columns }
+          end
+        end
 
         has_many association, options
       end

data/lib/polymorpheus/version.rb

@@ -1,3 +1,3 @@
 module Polymorpheus
-  VERSION = '2.0.0'
+  VERSION = '2.0.1'
 end

data/spec/interface_spec.rb

@@ -1,201 +1,200 @@
 require 'active_record'
 require 'polymorpheus'
 require 'spec_helper'
+require 'support/class_defs'
 
-# this is normally done via a Railtie in non-testing situations
-ActiveRecord::Base.send :include, Polymorpheus::Interface
+describe '.belongs_to_polymorph' do
+  let(:hero) { Hero.create! }
+  let(:villain) { Villain.create! }
+  let(:superhero) { Superhero.create! }
+  let(:alien_demigod) { AlienDemigod.create! }
 
-class Shoe < ActiveRecord::Base
-  belongs_to_polymorphic :man, :woman, :as => :wearer
-  validates_polymorph :wearer
-end
-
-class Man < ActiveRecord::Base
-  has_many_as_polymorph :shoes
-end
-
-class Woman < ActiveRecord::Base
-  has_many_as_polymorph :shoes, order: 'id DESC'
-end
-
-class Dog < ActiveRecord::Base
-end
-
-class Glove < ActiveRecord::Base
-  belongs_to_polymorphic :gentleman, :gentlewoman, :as => :wearer
-  validates_polymorph :wearer
-end
-
-class Gentleman < Man
-end
-
-class Knight < Gentleman
-end
-
-class Gentlewoman < Woman
-end
-
-describe '.belongs_to_polymorphic' do
-  it 'sets conditions on association to ensure we retrieve correct result' do
-    man = Man.create!
-    man.shoes.to_sql.squish
-      .should == %{SELECT `shoes`.* FROM `shoes`
-                   WHERE `shoes`.`man_id` = 1
-                   AND `shoes`.`woman_id` IS NULL}.squish
-  end
-
-  it 'supports existing conditions on the association' do
-    woman = Woman.create!
-    woman.shoes.to_sql.squish
-      .should == %{SELECT `shoes`.* FROM `shoes`
-                   WHERE `shoes`.`woman_id` = 1
-                   AND `shoes`.`man_id` IS NULL
-                   ORDER BY id DESC}.squish
-  end
-
-  it 'returns the correct result when used with new records' do
-    woman = Woman.create!
-    shoe = Shoe.create!(woman: woman, other_id: 10)
-    Man.new.shoes.where(other_id: 10).should == []
-  end
-end
-
-describe "polymorphic interface" do
-
-  let(:man) { Man.create! }
-  let(:woman) { Woman.create! }
-  let(:gentleman) { Gentleman.create! }
-  let(:knight) { Knight.create! }
-
-  specify { Shoe::POLYMORPHEUS_ASSOCIATIONS.should == %w[man woman] }
-  specify { Glove::POLYMORPHEUS_ASSOCIATIONS.should == %w[gentleman
-                                                          gentlewoman] }
+  specify { StoryArc::POLYMORPHEUS_ASSOCIATIONS.should == %w[hero villain] }
+  specify { Superpower::POLYMORPHEUS_ASSOCIATIONS.should == %w[superhero
+                                                               supervillain] }
 
   describe "setter methods for ActiveRecord objects" do
-    let(:shoe) { Shoe.new(attributes) }
+    let(:story_arc) { StoryArc.new(attributes) }
     let(:attributes) { {} }
 
     it "sets the correct attribute value for the setter" do
-      shoe.wearer = man
-      shoe.man_id.should == man.id
-      shoe.woman_id.should == nil
+      story_arc.character = hero
+      story_arc.hero_id.should == hero.id
+      story_arc.villain_id.should == nil
     end
 
     it "sets competing associations to nil" do
-      shoe.wearer = man
-      shoe.man_id.should == man.id
-      shoe.wearer = woman
-      shoe.woman_id.should == woman.id
-      shoe.man_id.should == nil
+      story_arc.character = hero
+      story_arc.hero_id.should == hero.id
+      story_arc.character = villain
+      story_arc.villain_id.should == villain.id
+      story_arc.hero_id.should == nil
     end
 
     it "throws an error if the assigned object isn't a valid type" do
-      dog = Dog.create!
-      expect { shoe.wearer = dog }
+      tree = Tree.create!
+      expect { story_arc.character = tree }
         .to raise_error(Polymorpheus::Interface::InvalidTypeError,
-                        "Invalid type. Must be one of {man, woman}")
+                        "Invalid type. Must be one of {hero, villain}")
     end
 
     it "does not throw an error if the assigned object is a subclass of a
     valid type" do
-      expect { shoe.wearer = gentleman }.not_to raise_error
-      shoe.man_id.should == gentleman.id
+      expect { story_arc.character = superhero }.not_to raise_error
+      story_arc.hero_id.should == superhero.id
     end
 
     it "does not throw an error if the assigned object is a descendant of a
     valid type" do
-      expect { shoe.wearer = knight }.not_to raise_error
-      shoe.man_id.should == knight.id
+      expect { story_arc.character = alien_demigod }.not_to raise_error
+      story_arc.hero_id.should == alien_demigod.id
     end
   end
 
   describe "setter methods for objects inheriting from ActiveRecord objects" do
-    let(:glove) { Glove.new }
+    let(:superpower) { Superpower.new }
 
     it "throws an error if the assigned object is an instance of the parent
     ActiveRecord class" do
-      expect { glove.wearer = man }.to raise_error(
+      expect { superpower.wielder = hero }.to raise_error(
         Polymorpheus::Interface::InvalidTypeError,
-        "Invalid type. Must be one of {gentleman, gentlewoman}"
+        "Invalid type. Must be one of {superhero, supervillain}"
       )
     end
 
     it "works if the assigned object is of the specified class" do
-      expect { glove.wearer = gentleman }.not_to raise_error
-      glove.gentleman_id.should == gentleman.id
+      expect { superpower.wielder = superhero }.not_to raise_error
+      superpower.superhero_id.should == superhero.id
     end
 
     it "works if the assigned object is an instance of a child class" do
-      expect { glove.wearer = knight }.not_to raise_error
-      glove.gentleman_id.should == knight.id
-    end
-  end
-
-  describe '.validates_polymorph validation' do
-    specify { Shoe.new(wearer: man).valid?.should == true }
-    specify { Shoe.new(wearer: woman).valid?.should == true }
-    specify { Shoe.new(man_id: man.id).valid?.should == true }
-    specify { Shoe.new(man: man).valid?.should == true }
-    specify { Shoe.new(man: Man.new).valid?.should == true }
-
-    it 'is invalid if no association is specified' do
-      shoe = Shoe.new
-      shoe.valid?.should == false
-      shoe.errors[:base].should ==
-        ["You must specify exactly one of the following: {man, woman}"]
-    end
-
-    it 'is invalid if multiple associations are specified' do
-      shoe = Shoe.new(man_id: man.id, woman_id: woman.id)
-      shoe.valid?.should == false
-      shoe.errors[:base].should ==
-        ["You must specify exactly one of the following: {man, woman}"]
+      expect { superpower.wielder = alien_demigod }.not_to raise_error
+      superpower.superhero_id.should == alien_demigod.id
     end
   end
 
   describe '#polymorpheus exposed interface method' do
-    subject(:interface) { shoe.polymorpheus }
+    subject(:interface) { story_arc.polymorpheus }
 
     context 'when there is no relationship defined' do
-      let(:shoe) { Shoe.new }
+      let(:story_arc) { StoryArc.new }
 
-      its(:associations) { should match_associations(:man, :woman) }
+      its(:associations) { should match_associations(:hero, :villain) }
       its(:active_association) { should == nil }
       its(:query_condition) { should == nil }
     end
 
     context 'when there is are multiple relationships defined' do
-      let(:shoe) { Shoe.new(man_id: man.id, woman_id: woman.id) }
+      let(:story_arc) { StoryArc.new(hero_id: hero.id, villain_id: villain.id) }
 
-      its(:associations) { should match_associations(:man, :woman) }
+      its(:associations) { should match_associations(:hero, :villain) }
       its(:active_association) { should == nil }
       its(:query_condition) { should == nil }
     end
 
     context 'when there is one relationship defined through the id value' do
-      let(:shoe) { Shoe.new(man_id: man.id) }
+      let(:story_arc) { StoryArc.new(hero_id: hero.id) }
 
-      its(:associations) { should match_associations(:man, :woman) }
-      its(:active_association) { be_association(:man) }
-      its(:query_condition) { should == { 'man_id' => man.id } }
+      its(:associations) { should match_associations(:hero, :villain) }
+      its(:active_association) { be_association(:hero) }
+      its(:query_condition) { should == { 'hero_id' => hero.id } }
     end
 
     context 'when there is one relationship defined through the setter' do
-      let(:shoe) { Shoe.new(wearer: man) }
+      let(:story_arc) { StoryArc.new(character: hero) }
 
-      its(:associations) { should match_associations(:man, :woman) }
-      its(:active_association) { be_association(:man) }
-      its(:query_condition) { should == { 'man_id' => man.id } }
+      its(:associations) { should match_associations(:hero, :villain) }
+      its(:active_association) { be_association(:hero) }
+      its(:query_condition) { should == { 'hero_id' => hero.id } }
     end
 
     context 'when there is one association, to a new record' do
-      let(:new_man) { Man.new }
-      let(:shoe) { Shoe.new(wearer: new_man) }
+      let(:new_hero) { Hero.new }
+      let(:story_arc) { StoryArc.new(character: new_hero) }
 
-      its(:associations) { should match_associations(:man, :woman) }
-      its(:active_association) { be_association(:man) }
+      its(:associations) { should match_associations(:hero, :villain) }
+      its(:active_association) { be_association(:hero) }
       its(:query_condition) { should == nil }
     end
   end
+end
+
+describe '.has_many_as_polymorph' do
+  it 'sets conditions on association to ensure we retrieve correct result' do
+    hero = Hero.create!
+    hero.story_arcs.to_sql
+      .should match_sql(%{SELECT `story_arcs`.* FROM `story_arcs`
+                          WHERE `story_arcs`.`hero_id` = #{hero.id}
+                          AND `story_arcs`.`villain_id` IS NULL})
+  end
 
+  it 'supports existing conditions on the association' do
+    villain = Villain.create!
+    villain.story_arcs.to_sql
+      .should match_sql(%{SELECT `story_arcs`.* FROM `story_arcs`
+                          WHERE `story_arcs`.`villain_id` = #{villain.id}
+                          AND `story_arcs`.`hero_id` IS NULL
+                          ORDER BY id DESC})
+  end
+
+  it 'returns the correct result when used with new records' do
+    villain = Villain.create!
+    story_arc = StoryArc.create!(villain: villain, issue_id: 10)
+    Hero.new.story_arcs.where(issue_id: 10).should == []
+  end
+
+  it 'sets conditions on associations with enough specificity that they work
+  in conjunction with has_many :through relationships' do
+    hero = Hero.create!
+    hero.battles.to_sql
+      .should match_sql(%{SELECT `battles`.* FROM `battles`
+                          INNER JOIN `story_arcs`
+                          ON `battles`.`id` = `story_arcs`.`battle_id`
+                          WHERE `story_arcs`.`hero_id` = 16
+                          AND `story_arcs`.`villain_id` IS NULL})
+  end
+
+  it 'uses the correct association table name when used in conjunction with a
+  join condition' do
+    battle = Battle.create!
+    battle.heros.to_sql
+      .should match_sql(%{SELECT `heros`.* FROM `heros`
+                          INNER JOIN `story_arcs`
+                          ON `heros`.`id` = `story_arcs`.`hero_id`
+                          WHERE `story_arcs`.`battle_id` = #{battle.id}})
+
+    battle.heros.joins(:story_arcs).to_sql
+      .should match_sql(%{SELECT `heros`.* FROM `heros`
+                          INNER JOIN `story_arcs` `story_arcs_heros`
+                          ON `story_arcs_heros`.`hero_id` = `heros`.`id`
+                          AND `story_arcs_heros`.`villain_id` IS NULL
+                          INNER JOIN `story_arcs`
+                          ON `heros`.`id` = `story_arcs`.`hero_id`
+                          WHERE `story_arcs`.`battle_id` = #{battle.id}})
+  end
+end
+
+describe '.validates_polymorph' do
+  let(:hero) { Hero.create! }
+  let(:villain) { Villain.create! }
+
+  specify { StoryArc.new(character: hero).valid?.should == true }
+  specify { StoryArc.new(character: villain).valid?.should == true }
+  specify { StoryArc.new(hero_id: hero.id).valid?.should == true }
+  specify { StoryArc.new(hero: hero).valid?.should == true }
+  specify { StoryArc.new(hero: Hero.new).valid?.should == true }
+
+  it 'is invalid if no association is specified' do
+    story_arc = StoryArc.new
+    story_arc.valid?.should == false
+    story_arc.errors[:base].should ==
+      ["You must specify exactly one of the following: {hero, villain}"]
+  end
+
+  it 'is invalid if multiple associations are specified' do
+    story_arc = StoryArc.new(hero_id: hero.id, villain_id: villain.id)
+    story_arc.valid?.should == false
+    story_arc.errors[:base].should ==
+      ["You must specify exactly one of the following: {hero, villain}"]
+  end
 end

data/spec/spec_helper.rb

@@ -1,45 +1,2 @@
-ActiveRecord::Base.establish_connection({
-  adapter: 'mysql2',
-  username: 'root',
-  password: '',
-  host: 'localhost',
-  database: 'polymorphicTest'
-})
-
-ActiveRecord::Base.connection.tables.each do |table|
-  ActiveRecord::Base.connection.drop_table table
-end
-
-ActiveRecord::Schema.define do
-  create_table :shoes do |t|
-    t.integer :man_id
-    t.integer :woman_id
-    t.integer :other_id
-  end
-  create_table :gloves do |t|
-    t.integer :gentleman_id
-    t.integer :gentlewoman_id
-  end
-  create_table :men do |t|
-    t.string :type
-  end
-  create_table :women
-  create_table :dogs
-end
-
-
-RSpec::Matchers.define :be_association do |association_name|
-  match do |actual|
-    actual.should be_instance_of(Polymorpheus::InterfaceBuilder::Association)
-    actual.name.should == association_name.to_s
-  end
-end
-
-RSpec::Matchers.define :match_associations do |*association_names|
-  match do |actual|
-    actual.length.should == association_names.length
-    actual.each_with_index do |item, ind|
-      item.should be_association(association_names[ind])
-    end
-  end
-end
+require 'support/custom_matchers.rb'
+require 'support/db_setup.rb'

data/spec/support/class_defs.rb

@@ -0,0 +1,48 @@
+# this is normally done via a Railtie in non-testing situations
+ActiveRecord::Base.send :include, Polymorpheus::Interface
+
+# Han Solo is a hero, but not a superhero
+class Hero < ActiveRecord::Base
+  has_many_as_polymorph :story_arcs
+  has_many :battles, through: :story_arcs
+end
+
+# Hannibal Lecter is a villain, but not a supervillain
+class Villain < ActiveRecord::Base
+  has_many_as_polymorph :story_arcs, order: 'id DESC'
+  has_many :battles, through: :story_arcs
+end
+
+# Flash is a superhero but not an alien demigod
+class Superhero < Hero
+end
+
+# Superman is an alien demigod
+class AlienDemigod < Superhero
+end
+
+# Darkseid is a supervillain
+class Supervillain < Villain
+end
+
+# All heros and villains have story arcs
+class StoryArc < ActiveRecord::Base
+  belongs_to_polymorphic :hero, :villain, as: :character
+  belongs_to :battle
+  validates_polymorph :character
+end
+
+class Battle < ActiveRecord::Base
+  has_many :story_arcs
+  has_many :heros, through: :story_arcs
+end
+
+# But only super-people have superpowers
+class Superpower < ActiveRecord::Base
+  belongs_to_polymorphic :superhero, :supervillain, as: :wielder
+end
+
+# Trees, though, are masters of zen. They sway with the wind.
+# (Unless this is LOTR, but let's ignore that for now.)
+class Tree < ActiveRecord::Base
+end

data/spec/support/custom_matchers.rb

@@ -0,0 +1,31 @@
+RSpec::Matchers.define :be_association do |association_name|
+  match do |actual|
+    actual.should be_instance_of(Polymorpheus::InterfaceBuilder::Association)
+    actual.name.should == association_name.to_s
+  end
+end
+
+RSpec::Matchers.define :match_associations do |*association_names|
+  match do |actual|
+    actual.length.should == association_names.length
+    actual.each_with_index do |item, ind|
+      item.should be_association(association_names[ind])
+    end
+  end
+end
+
+RSpec::Matchers.define :match_sql do |expected|
+  match do |actual|
+    format(expected).should == format(actual)
+  end
+
+  failure_message_for_should do |actual|
+    "expected the following SQL statements to match:
+    #{format(actual)}
+    #{format(expected)}"
+  end
+
+  def format(sql)
+    sql.gsub(/\s+/, ' ')
+  end
+end

data/spec/support/db_setup.rb

@@ -0,0 +1,32 @@
+ActiveRecord::Base.establish_connection({
+  adapter: 'mysql2',
+  username: 'travis',
+  database: 'polymorpheus_test'
+})
+
+ActiveRecord::Base.connection.tables.each do |table|
+  ActiveRecord::Base.connection.drop_table table
+end
+
+ActiveRecord::Schema.define do
+  create_table :heros
+  create_table :villains
+  create_table :superheros
+  create_table :alien_demigods
+  create_table :supervillains
+  create_table :trees
+
+  create_table :story_arcs do |t|
+    t.integer :hero_id
+    t.integer :villain_id
+    t.integer :battle_id
+    t.integer :issue_id
+  end
+
+  create_table :battles
+
+  create_table :superpowers do |t|
+    t.integer :superhero_id
+    t.integer :supervillain_id
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: polymorpheus
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-19 00:00:00.000000000 Z
+date: 2013-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foreigner
@@ -100,6 +100,9 @@ files:
 - spec/shared_examples.rb
 - spec/spec_helper.rb
 - spec/sql_logger.rb
+- spec/support/class_defs.rb
+- spec/support/custom_matchers.rb
+- spec/support/db_setup.rb
 - spec/trigger_spec.rb
 - LICENSE.txt
 - README.md
@@ -126,7 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Provides a database-friendly method for polymorphic relationships