polymorpheus 2.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2b4fa428b1261c05072970feddd72eca1d4e0d70
-  data.tar.gz: 189801e622b209426bb6e39b86a32b7c34bbc954
+SHA256:
+  metadata.gz: 4ab6587aad06136dbdf95584bba576349fc9731187a60dd6945d74bcb400b025
+  data.tar.gz: b83008d22a38740f1ef2909971e5fd662ed8ac5297449ddd1dd405af43a4d792
 SHA512:
-  metadata.gz: 1624b4a33ce2a7875acda4688ebad9662e2f6201e01d329196cee018acfcbec0bafe86f3d07c732c383525e13b96e3fda65b510f29201615aa7637803300b32c
-  data.tar.gz: f207481aef2d8e20c22c7efb2d86691c2d9ed6ba241356e7eb977a27c3d7c90c1f9aceab5f3b4972956f730ca0baa850d6c5b3e0a38866f54a478e6b8daaeb29
+  metadata.gz: 476c715b239796573c7a2de566a4dd52507445c68227c4559cb7ec9a443ab707f48d31ad1477edfcfa52183e18634eac329bbe7d7c4bdbf006d620544c9d88b8
+  data.tar.gz: a778788d64292837ad5ed6e4a4a4b4fbc9e2fcdd5f38d1c99088c3fa2e7d838b07e20e1df3cae0cb0c7bf6c9e537c0c1d90c3c1ac17fcd8b5db2076def0194b0

data/README.md

@@ -5,6 +5,23 @@
 **Polymorphic relationships in Rails that keep your database happy with almost
 no setup**
 
+### Installation
+
+If you are using Bundler, you can add the gem to your Gemfile:
+
+```ruby
+# with Rails >= 4.2
+gem 'polymorpheus'
+```
+
+Or:
+
+```ruby
+# with Rails < 4.2
+gem 'foreigner'
+gem 'polymorpheus'
+```
+
 ### Background
 * **What is polymorphism?** [Rails Guides has a great overview of what
   polymorphic relationships are and how Rails handles them](
@@ -63,12 +80,14 @@ end
 
 ```ruby
 class Picture < ActiveRecord::Base
+  # takes same additional options as belongs_to
   belongs_to_polymorphic :employee, :product, :as => :imageable
   validates_polymorph :imageable
 end
 
 class Employee < ActiveRecord::Base
-  has_many_as_polymorph :pictures
+  # takes same additional options as has_many
+  has_many_as_polymorph :pictures, inverse_of: employee
 end
 
 class Product < ActiveRecord::Base
@@ -123,8 +142,6 @@ Now let's review what we've done.
 
 * Currently the gem only supports MySQL. Please feel free to fork and submit a
   (well-tested) pull request if you want to add Postgres support.
-* This gem is tested and has been tested for Rails 2.3.8, 3.0.x, 3.1.x, 3.2.x,
-  and 4.0.0
 * For Rails 3.1+, you'll still need to use `up` and `down` methods in your
   migrations.
 
@@ -196,7 +213,7 @@ pic.polymorpheus.query_condition
 
 * This gem was written by [Barun Singh](https://github.com/barunio)
 * It uses the [Foreigner gem](https://github.com/matthuhiggins/foreigner) under
-  the hood for a few things
+  the hood for Rails < 4.2.
 
 polymorpheus is Copyright © 2011-2015 Barun Singh and [WegoWise](
 http://wegowise.com). It is free software, and may be redistributed under the

data/lib/polymorpheus.rb

@@ -23,8 +23,16 @@ module Polymorpheus
   module ConnectionAdapters
     autoload :SchemaStatements, 'polymorpheus/schema_statements'
   end
+
+  def self.require_foreigner?
+    ActiveRecord::VERSION::MAJOR < 5 &&
+    !(::ActiveRecord::VERSION::MAJOR >= 4 &&
+      ::ActiveRecord::VERSION::MINOR >= 2)
+  end
 end
 
+require 'foreigner' if ::Polymorpheus.require_foreigner?
+
 Polymorpheus::Adapter.register 'mysql2', 'polymorpheus/mysql_adapter'
 Polymorpheus::Adapter.register 'postgresql', 'polymorpheus/postgresql_adapter'
 

data/lib/polymorpheus/interface/belongs_to_polymorphic.rb

@@ -2,9 +2,10 @@ module Polymorpheus
   module Interface
     module BelongsToPolymorphic
       def belongs_to_polymorphic(*association_names, options)
-        polymorphic_api = options[:as]
+        polymorphic_api = options.delete(:as)
         builder = Polymorpheus::InterfaceBuilder.new(polymorphic_api,
-                                                     association_names)
+                                                     association_names,
+                                                     options)
 
         # The POLYMORPHEUS_ASSOCIATIONS constant is useful for two reasons:
         #
@@ -20,7 +21,7 @@ module Polymorpheus
 
         # Set belongs_to associations
         builder.associations.each do |association|
-          belongs_to association.name.to_sym
+          belongs_to association.name.to_sym, association.options
         end
 
         # Exposed interface for introspection

data/lib/polymorpheus/interface_builder.rb

@@ -6,10 +6,10 @@ module Polymorpheus
     attr_reader :interface_name,
                 :associations
 
-    def initialize(interface_name, association_names)
+    def initialize(interface_name, association_names, options)
       @interface_name = interface_name
       @associations = association_names.map do |association_name|
-        Polymorpheus::InterfaceBuilder::Association.new(association_name)
+        Polymorpheus::InterfaceBuilder::Association.new(association_name, options)
       end
     end
 

data/lib/polymorpheus/interface_builder/association.rb

@@ -5,10 +5,11 @@ module Polymorpheus
       include ActiveSupport::Inflector
 
       attr_reader :name,
-                  :key
+                  :key,
+                  :options
 
-      def initialize(name)
-        @name = name.to_s.downcase
+      def initialize(name, options)
+        @name, @options = name.to_s.downcase, options
         @key = "#{@name}_id"
       end
 

data/lib/polymorpheus/mysql_adapter.rb

@@ -66,19 +66,22 @@ module Polymorpheus
         if options[:unique].present?
           poly_create_indexes(table, column_names, Array(options[:unique]))
         end
+
         column_names.each do |col_name|
           ref_table, ref_col = columns[col_name].to_s.split('.')
-          add_foreign_key table, ref_table,
-                                 :column => col_name,
-                                 :primary_key => (ref_col || 'id'),
-                                 :options => generate_constraints(options)
+          fk_options = {
+            :column => col_name,
+            :name => "#{table}_#{col_name}_fk",
+            :primary_key => (ref_col || 'id' )
+          }.merge(generate_constraints(options))
+          add_foreign_key(table, ref_table, fk_options)
         end
       end
 
       def remove_polymorphic_constraints(table, columns, options = {})
         poly_drop_triggers(table, columns.keys.sort)
         columns.each do |(col, reference)|
-          remove_foreign_key table, :column => col
+          remove_foreign_key table, :column => col, :name => "#{table}_#{col}_fk"
         end
         if options[:unique].present?
           poly_remove_indexes(table, columns.keys, Array(options[:unique]))
@@ -86,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
 
       #
@@ -191,26 +194,8 @@ module Polymorpheus
       end
 
       def generate_constraints(options)
-        constraints = []
-
-        ['delete', 'update'].each do |event|
-          option = "on_#{event}".to_sym
-          next unless options.has_key?(option) &&
-                      options[option].respond_to?(:to_sym)
-
-          action = case options[option].to_sym
-            when :nullify then 'SET NULL'
-            when :cascade then 'CASCADE'
-            when :restrict then 'RESTRICT'
-          end
-          next unless action
-
-          constraints << "ON #{event.upcase} #{action}"
-        end
-
-        constraints.join(' ')
+        options.slice(:on_delete, :on_update)
       end
-
     end
   end
 end
@@ -223,3 +208,8 @@ end
   rescue
   end
 end
+
+if ::Polymorpheus.require_foreigner?
+  require 'foreigner/connection_adapters/mysql2_adapter'
+  require 'polymorpheus/mysql_adapter/foreigner_constraints'
+end

data/lib/polymorpheus/mysql_adapter/foreigner_constraints.rb

@@ -0,0 +1,30 @@
+module Polymorpheus
+  module ConnectionAdapters
+    module MysqlAdapter
+      def generate_constraints(options)
+        constraints = []
+
+        ['delete', 'update'].each do |event|
+          option = "on_#{event}".to_sym
+          next unless options.has_key?(option) &&
+                      options[option].respond_to?(:to_sym)
+
+          action = case options[option].to_sym
+            when :nullify then 'SET NULL'
+            when :cascade then 'CASCADE'
+            when :restrict then 'RESTRICT'
+            else
+              fail ArgumentError, <<-EOS
+'#{options[option]}' is not supported for :on_update or :on_delete.
+Supported values are: :nullify, :cascade, :restrict
+              EOS
+          end
+
+          constraints << "ON #{event.upcase} #{action}"
+        end
+
+        { :options => constraints.join(' ') }
+      end
+    end
+  end
+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 = '2.2.0'
+  VERSION = '3.3.0'
 end

data/polymorpheus.gemspec

@@ -17,10 +17,8 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = ["README.md", "LICENSE.txt"]
   s.license = 'MIT'
 
-  s.add_dependency('foreigner')
-  s.add_dependency('activerecord', '>= 3.2', '< 4.2')
+  s.add_dependency('activerecord', '>= 3.2', '< 6.1')
 
-  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('rake', '~> 12.3.3')
+  s.add_development_dependency('rspec', '~> 3.9.0')
 end

data/spec/interface/belongs_to_polymorphic_spec.rb

@@ -0,0 +1,149 @@
+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 do
+    expect(StoryArc::POLYMORPHEUS_ASSOCIATIONS).to eq(%w[hero villain])
+  end
+  specify do
+    expect(Superpower::POLYMORPHEUS_ASSOCIATIONS).to eq(%w[superhero supervillain])
+  end
+
+  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
+      expect(story_arc.hero_id).to eq(hero.id)
+      expect(story_arc.villain_id).to eq(nil)
+    end
+
+    it "sets competing associations to nil" do
+      story_arc.character = hero
+      expect(story_arc.hero_id).to eq(hero.id)
+      story_arc.character = villain
+      expect(story_arc.villain_id).to eq(villain.id)
+      expect(story_arc.hero_id).to eq(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
+      expect(story_arc.hero_id).to eq(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
+      expect(story_arc.hero_id).to eq(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
+      expect(superpower.superhero_id).to eq(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
+      expect(superpower.superhero_id).to eq(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 }
+
+      specify do
+        expect(interface.associations).to match_associations(:hero, :villain)
+      end
+      specify { expect(interface.active_association).to eq nil }
+      specify { expect(interface.query_condition).to eq nil }
+    end
+
+    context 'when there is are multiple relationships defined' do
+      let(:story_arc) { StoryArc.new(hero_id: hero.id, villain_id: villain.id) }
+
+      specify do
+        expect(interface.associations).to match_associations(:hero, :villain)
+      end
+      specify { expect(interface.active_association).to eq nil }
+      specify { expect(interface.query_condition).to eq nil }
+    end
+
+    context 'when there is one relationship defined through the id value' do
+      let(:story_arc) { StoryArc.new(hero_id: hero.id) }
+
+      specify do
+        expect(interface.associations).to match_associations(:hero, :villain)
+      end
+      specify { expect(interface.active_association).to be_association(:hero) }
+      specify { expect(interface.query_condition).to eq('hero_id' => hero.id) }
+    end
+
+    context 'when there is one relationship defined through the setter' do
+      let(:story_arc) { StoryArc.new(character: hero) }
+
+      specify do
+        expect(interface.associations).to match_associations(:hero, :villain)
+      end
+      specify { expect(interface.active_association).to be_association(:hero) }
+      specify { expect(interface.query_condition).to eq('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) }
+
+      specify do
+        expect(interface.associations).to match_associations(:hero, :villain)
+      end
+      specify { expect(interface.active_association).to be_association(:hero) }
+      specify { expect(interface.query_condition).to eq nil }
+    end
+  end
+end