polymorpheus 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b35be425d188561def6ede1eef462b1d3dee4835
-  data.tar.gz: 5f509e7b56f2966e2062b75640ac73d56a9e32c9
+  metadata.gz: e181e9294980f79aa4b50efdd7edb588de1c390a
+  data.tar.gz: 317c3f2e0da8513874d57955042e547a2077c3bb
 SHA512:
-  metadata.gz: a70e7b2ef8f96e16b57e295d1285743053bb1719f82d68983fb9a12ac69e3003c26f1c2aeb4cfb806893dceac1e548e86f5e1a740ba630d474788888d01dd0ce
-  data.tar.gz: d542e42e2cac59818dd0f3469032b95234e875667825d9e9b4557cd48f6becbab45c43ebf344b6d76d5d6611ef454d57d121ffbc2faa92937ef35bb9efea251c
+  metadata.gz: b5ccb72b1c3a0ed0d247b67a5c2dbf71b04a46d6947c64b71e16a4212960acc60cf1b8771e8768b04967c1a8b64df9238aa7102febf67c5fe95ce36facbd0f3c
+  data.tar.gz: 5ef3e30327eaab0914ea2731cf3d5699ea1f058320ebfc2ada4704e8e4b497db556d112dcca7f8a694efb8cc74b7b1bf7d3f7307ed35ceb532e89acc2ccbe8ae

data/lib/polymorpheus.rb

@@ -25,6 +25,7 @@ module Polymorpheus
   end
 
   def self.require_foreigner?
+    ActiveRecord::VERSION::MAJOR < 5 &&
     !(::ActiveRecord::VERSION::MAJOR >= 4 &&
       ::ActiveRecord::VERSION::MINOR >= 2)
   end

data/lib/polymorpheus/mysql_adapter.rb

@@ -89,7 +89,7 @@ module Polymorpheus
       end
 
       def triggers
-        execute("show triggers").collect {|t| Trigger.new(t) }
+        execute("show triggers").collect {|t| Polymorpheus::Trigger.new(t) }
       end
 
       #

data/lib/polymorpheus/schema_dumper.rb

@@ -3,14 +3,15 @@ module Polymorpheus
     extend ActiveSupport::Concern
 
     included do
-      alias_method_chain :tables, :triggers
+      alias_method :tables_without_triggers, :tables
+      alias_method :tables, :tables_with_triggers
     end
 
     def tables_with_triggers(stream)
       tables_without_triggers(stream)
 
       if @connection.respond_to?(:triggers)
-        @connection.triggers.collect(&:schema_statement).each do |statement|
+        @connection.triggers.collect(&:schema_statement).uniq.each do |statement|
           stream.puts statement
         end
       end

data/lib/polymorpheus/trigger.rb

@@ -1,29 +1,30 @@
-class Trigger
+module Polymorpheus
+  class Trigger
 
-  attr_accessor :name, :event, :table, :statement, :timing, :created, :sql_mode,
-                :definer, :charset, :collation_connection, :db_collation
+    attr_accessor :name, :event, :table, :statement, :timing, :created, :sql_mode,
+                  :definer, :charset, :collation_connection, :db_collation
 
-  def initialize(arr)
-    raise ArgumentError unless arr.is_a?(Array) && arr.length == 11
-    [:name, :event, :table, :statement, :timing, :created, :sql_mode,
-      :definer, :charset, :collation_connection, :db_collation].
-    each_with_index do |attr, ind|
-      self.send("#{attr}=", arr[ind])
+    def initialize(arr)
+      raise ArgumentError unless arr.is_a?(Array) && arr.length == 11
+      [:name, :event, :table, :statement, :timing, :created, :sql_mode,
+        :definer, :charset, :collation_connection, :db_collation].
+      each_with_index do |attr, ind|
+        self.send("#{attr}=", arr[ind])
+      end
     end
-  end
 
-  def columns
-    /IF\((.*)\) \<\> 1/.match(self.statement) do |match|
-      match[1].split(' + ').collect do |submatch|
-        /NEW\.([^ ]*)/.match(submatch)[1]
+    def columns
+      /IF\((.*)\) \<\> 1/.match(self.statement) do |match|
+        match[1].split(' + ').collect do |submatch|
+          /NEW\.([^ ]*)/.match(submatch)[1]
+        end
       end
     end
-  end
 
-  def schema_statement
-    # note that we don't need to worry about unique indices or foreign keys
-    # because separate schema statements will be generated for them
-    "  add_polymorphic_triggers(:#{table}, #{columns.to_s})"
+    def schema_statement
+      # note that we don't need to worry about unique indices or foreign keys
+      # because separate schema statements will be generated for them
+      "  add_polymorphic_triggers(:#{table}, #{columns.to_s})"
+    end
   end
-
 end

data/lib/polymorpheus/version.rb

@@ -1,3 +1,3 @@
 module Polymorpheus
-  VERSION = '3.1.0'
+  VERSION = '3.1.1'
 end

data/polymorpheus.gemspec

@@ -17,9 +17,8 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = ["README.md", "LICENSE.txt"]
   s.license = 'MIT'
 
-  s.add_dependency('activerecord', '>= 3.2', '< 5')
+  s.add_dependency('activerecord', '>= 3.2', '< 5.2')
 
   s.add_development_dependency('rake', '~> 10.4.2')
-  s.add_development_dependency('rspec-rails', '~> 2.14.0')
-  s.add_development_dependency('mysql2', '~> 0.3.10')
+  s.add_development_dependency('rspec', '~> 2.14.0')
 end

data/spec/interface/belongs_to_polymorphic_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Polymorpheus::Interface::BelongsToPolymorphic do
+  let(:hero) { Hero.create! }
+  let(:villain) { Villain.create! }
+  let(:superhero) { Superhero.create! }
+  let(:alien_demigod) { AlienDemigod.create! }
+
+  before do
+    create_table :story_arcs do |t|
+      t.references :hero
+      t.references :villain
+    end
+    create_table :heros
+    create_table :villains
+  end
+
+  specify { StoryArc::POLYMORPHEUS_ASSOCIATIONS.should == %w[hero villain] }
+  specify { Superpower::POLYMORPHEUS_ASSOCIATIONS.should == %w[superhero
+                                                               supervillain] }
+
+  describe "setter methods for ActiveRecord objects" do
+    let(:story_arc) { StoryArc.new(attributes) }
+    let(:attributes) { {} }
+
+    it "sets the correct attribute value for the setter" do
+      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
+      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
+      create_table :trees
+
+      tree = Tree.create!
+      expect { story_arc.character = tree }
+        .to raise_error(Polymorpheus::Interface::InvalidTypeError,
+                        "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 { 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 { 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(:superpower) { Superpower.new }
+
+    before do
+      create_table :superpowers do |t|
+        t.references :superhero
+        t.references :supervillain
+      end
+    end
+
+    it "throws an error if the assigned object is an instance of the parent
+    ActiveRecord class" do
+      expect { superpower.wielder = hero }.to raise_error(
+        Polymorpheus::Interface::InvalidTypeError,
+        "Invalid type. Must be one of {superhero, supervillain}"
+      )
+    end
+
+    it "works if the assigned object is of the specified class" do
+      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 { 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) { story_arc.polymorpheus }
+
+    context 'when there is no relationship defined' do
+      let(:story_arc) { StoryArc.new }
+
+      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(:story_arc) { StoryArc.new(hero_id: hero.id, villain_id: villain.id) }
+
+      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(:story_arc) { StoryArc.new(hero_id: hero.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(:story_arc) { StoryArc.new(character: hero) }
+
+      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_hero) { Hero.new }
+      let(:story_arc) { StoryArc.new(character: new_hero) }
+
+      its(:associations) { should match_associations(:hero, :villain) }
+      its(:active_association) { be_association(:hero) }
+      its(:query_condition) { should == nil }
+    end
+  end
+end

data/spec/interface/has_many_as_polymorph_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Polymorpheus::Interface::HasManyAsPolymorph do
+  before do
+    create_table :story_arcs do |t|
+      t.references :hero
+      t.references :villain
+      t.references :battle
+      t.references :issue
+    end
+    create_table :battles
+    create_table :heros
+    create_table :issues
+    create_table :villains
+  end
+
+  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` = #{hero.id}
+                          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

data/spec/interface/validates_polymorph_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Polymorpheus::Interface::ValidatesPolymorph do
+  let(:hero) { Hero.create! }
+  let(:villain) { Villain.create! }
+
+  before do
+    create_table(:story_arcs) do |t|
+      t.references :hero
+      t.references :villain
+    end
+    create_table(:heros)
+    create_table(:villains)
+  end
+
+  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/interface_spec.rb

@@ -1,215 +1,27 @@
-require 'active_record'
-require 'polymorpheus'
 require 'spec_helper'
-require 'support/class_defs'
 
-describe '.belongs_to_polymorph' do
-  let(:hero) { Hero.create! }
-  let(:villain) { Villain.create! }
-  let(:superhero) { Superhero.create! }
-  let(:alien_demigod) { AlienDemigod.create! }
+describe Polymorpheus::Interface do
+  describe 'association options' do
+    it 'without options' do
+      create_table :drawings
+      create_table :books
+      create_table :binders
 
-  specify { StoryArc::POLYMORPHEUS_ASSOCIATIONS.should == %w[hero villain] }
-  specify { Superpower::POLYMORPHEUS_ASSOCIATIONS.should == %w[superhero
-                                                               supervillain] }
-
-  describe "setter methods for ActiveRecord objects" do
-    let(:story_arc) { StoryArc.new(attributes) }
-    let(:attributes) { {} }
-
-    it "sets the correct attribute value for the setter" do
-      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
-      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
-      tree = Tree.create!
-      expect { story_arc.character = tree }
-        .to raise_error(Polymorpheus::Interface::InvalidTypeError,
-                        "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 { 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 { 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(:superpower) { Superpower.new }
-
-    it "throws an error if the assigned object is an instance of the parent
-    ActiveRecord class" do
-      expect { superpower.wielder = hero }.to raise_error(
-        Polymorpheus::Interface::InvalidTypeError,
-        "Invalid type. Must be one of {superhero, supervillain}"
-      )
+      Drawing.new.association(:book).reflection.inverse_of.should == nil
+      Drawing.new.association(:binder).reflection.inverse_of.should == nil
+      Book.new.association(:drawings).reflection.inverse_of.should == nil
+      Binder.new.association(:drawings).reflection.inverse_of.should == nil
     end
 
-    it "works if the assigned object is of the specified class" do
-      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 { 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) { story_arc.polymorpheus }
-
-    context 'when there is no relationship defined' do
-      let(:story_arc) { StoryArc.new }
-
-      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(:story_arc) { StoryArc.new(hero_id: hero.id, villain_id: villain.id) }
+    it 'with options' do
+      create_table :pictures
+      create_table :web_pages
+      create_table :printed_works
 
-      its(:associations) { should match_associations(:hero, :villain) }
-      its(:active_association) { should == nil }
-      its(:query_condition) { should == nil }
+      Picture.new.association(:web_page).reflection.inverse_of.name.should == :pictures
+      Picture.new.association(:printed_work).reflection.inverse_of.name.should == :pictures
+      WebPage.new.association(:pictures).reflection.inverse_of.name.should == :web_page
+      PrintedWork.new.association(:pictures).reflection.inverse_of.name.should == :printed_work
     end
-
-    context 'when there is one relationship defined through the id value' do
-      let(:story_arc) { StoryArc.new(hero_id: hero.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(:story_arc) { StoryArc.new(character: hero) }
-
-      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_hero) { Hero.new }
-      let(:story_arc) { StoryArc.new(character: new_hero) }
-
-      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
-
-describe 'association options' do
-  it 'without options' do
-    Drawing.new.association(:book).reflection.inverse_of.should == nil
-    Drawing.new.association(:binder).reflection.inverse_of.should == nil
-    Book.new.association(:drawings).reflection.inverse_of.should == nil
-    Binder.new.association(:drawings).reflection.inverse_of.should == nil
-  end
-  it 'with options' do
-    Picture.new.association(:web_page).reflection.inverse_of.name.should == :pictures
-    Picture.new.association(:printed_work).reflection.inverse_of.name.should == :pictures
-    WebPage.new.association(:pictures).reflection.inverse_of.name.should == :web_page
-    PrintedWork.new.association(:pictures).reflection.inverse_of.name.should == :printed_work
   end
 end