Allow mapping to be supplied as polymorphic: option

This removes the need for the `integer_type:` option when specify a polymorphic integer type association. This simplifies the configuration of the interger type polymorphic association.

For example, here is a normal polymorphic association:

```ruby
class Picture < ActiveRecord::Base
  belongs_to :imageable, polymorphic: true
end

class Employee < ActiveRecord::Base
  has_many :pictures, as: :imageable
end

class Product < ActiveRecord::Base
  has_many :pictures, as: :imageable
end
```

And the same example using an integer type:

```ruby
class Picture < ActiveRecord::Base
  include PolymorphicIntegerType::Extensions

  belongs_to :imageable, polymorphic: {1 => "Employee", 2 => "Product"}
end

class Employee < ActiveRecord::Base
  include PolymorphicIntegerType::Extensions

  has_many :pictures, as: :imageable
end

class Product < ActiveRecord::Base
  include PolymorphicIntegerType::Extensions

  has_many :pictures, as: :imageable
end
```

The only difference between a normal polymorphic association and an integer type polymorphic relationship is that the integer-to-class mapping is passed directly to the `polymorphic:` option and the module is included in all associated models.

Author: jnraine

README.md

@@ -51,28 +51,29 @@ For Rails 3.2 use version < 2. Version >= 2 has been tested on Rails 4.2 and Rub
 
 ## Usage
 
-Include `PolymorphicIntegerType::Extensions` into each associated model class then set the `integer_type` option on the appropriate association.
-
-For the model where the `belongs_to` is defined, set `integer_type` to hash mapping integers to strings. This hash maps an integer in the database to a Ruby class.
+For the model where the `belongs_to` is defined, include `PolymorphicIntegerType::Extensions` and set the `polymorphic:` option to a hash that maps an integer stored in the database to the name of a Ruby class.
 
 ```ruby
 class Picture < ActiveRecord::Base
   include PolymorphicIntegerType::Extensions
-  belongs_to :imageable, polymorphic: true, integer_type: {1 => "Employee", 2 => "Product"}
+
+  belongs_to :imageable, polymorphic: {1 => "Employee", 2 => "Product"}
 end
 ```
 
- Next, set `integer_type` to true on any related `has_many` or `has_one` associations:
+ Next, include `PolymorphicIntegerType::Extensions` into any of the models that point back to the polymorphic integer type association (e.g., `Picture#imageable`) and add a [polymorphic association using `as:`](http://guides.rubyonrails.org/association_basics.html#polymorphic-associations).
 
 ```ruby
 class Employee < ActiveRecord::Base
   include PolymorphicIntegerType::Extensions
-  has_many :pictures, as: :imageable, integer_type: true
+
+  has_many :pictures, as: :imageable
 end
 
 class Product < ActiveRecord::Base
   include PolymorphicIntegerType::Extensions
-  has_many :pictures, as: :imageable, integer_type: true
+
+  has_many :pictures, as: :imageable
 end
 ```
 

lib/polymorphic_integer_type/extensions.rb

@@ -7,10 +7,11 @@ def belongs_to(name, scope = nil, options = {})
         options = scope if scope.kind_of? Hash
         integer_type = options.delete :integer_type
         super
-        if options[:polymorphic] && integer_type
+        if options[:polymorphic] && (integer_type || options[:polymorphic].is_a?(Hash))
           mapping =
-            if integer_type == true
-              PolymorphicIntegerType::Mapping[name]
+            case integer_type
+            when true then PolymorphicIntegerType::Mapping[name]
+            when nil then options[:polymorphic]
             else
               integer_type
             end.dup
@@ -51,29 +52,22 @@ def belongs_to(name, scope = nil, options = {})
 
       def remove_type_and_establish_mapping(name, options, scope)
         integer_type = options.delete :integer_type
+        polymorphic_type_mapping = retrieve_polymorphic_type_mapping(
+          polymorphic_type: options[:as],
+          class_name: options[:class_name] || name.to_s.classify
+        )
 
-        if options[:as] && integer_type
+        if options[:as] && (polymorphic_type_mapping || integer_type)
           poly_type = options.delete(:as)
-          class_name = options[:class_name] || name.to_s.classify
-          mapping = begin
-            belongs_to_class = class_name.constantize
-            method_name = "#{poly_type}_type_mapping"
-            if belongs_to_class.respond_to?(method_name)
-              belongs_to_class.public_send(method_name)
-            end
-          rescue NameError => e
-            STDERR.puts "Failed to load belongs_to class: #{e.message}"
-          end
-
-          mapping ||= PolymorphicIntegerType::Mapping[poly_type]
-          if mapping == nil
+          polymorphic_type_mapping ||= PolymorphicIntegerType::Mapping[poly_type]
+          if polymorphic_type_mapping == nil
             raise "Polymorphic type mapping missing for #{poly_type.inspect}"
           end
 
-          klass_mapping = (mapping || {}).key(sti_name)
+          klass_mapping = (polymorphic_type_mapping || {}).key(sti_name)
 
           if klass_mapping == nil
-            raise "Class not found for #{sti_name.inspect} in polymorphic type mapping: #{mapping}"
+            raise "Class not found for #{sti_name.inspect} in polymorphic type mapping: #{polymorphic_type_mapping}"
           end
 
           options[:foreign_key] ||= "#{poly_type}_id"
@@ -89,6 +83,22 @@ def remove_type_and_establish_mapping(name, options, scope)
         end
       end
 
+      def retrieve_polymorphic_type_mapping(polymorphic_type:, class_name:)
+        return if polymorphic_type == nil
+
+        belongs_to_class = begin
+          class_name.constantize
+        rescue NameError
+          # Class not found
+        end
+
+        method_name = "#{polymorphic_type}_type_mapping"
+
+        if belongs_to_class && belongs_to_class.respond_to?(method_name)
+          belongs_to_class.public_send(method_name)
+        end
+      end
+
       def has_many(name, scope = nil, options = {}, &extension)
         if scope.kind_of? Hash
           options = scope

spec/polymorphic_integer_type_spec.rb

@@ -156,6 +156,7 @@ class InlineLink < ActiveRecord::Base
 
       belongs_to :source, polymorphic: true, integer_type: {10 => "Person", 11 => "InlineAnimal"}
       belongs_to :target, polymorphic: true, integer_type: {10 => "Food", 13 => "InlineDrink"}
+      belongs_to :normal_target, polymorphic: true
     end
 
     class InlineAnimal < ActiveRecord::Base
@@ -164,20 +165,20 @@ class InlineAnimal < ActiveRecord::Base
       self.table_name = "animals"
 
       belongs_to :owner, class_name: "Person"
-      has_many :source_links, as: :source, class_name: "InlineLink", integer_type: true
+      has_many :source_links, as: :source, class_name: "InlineLink"
     end
 
     class InlineDrink < ActiveRecord::Base
       include PolymorphicIntegerType::Extensions
 
       self.table_name = "drinks"
 
-      has_many :inline_links, as: :target, integer_type: true
+      has_many :inline_links, as: :target
     end
 
     let!(:animal) { InlineAnimal.create!(name: "Lucy") }
     let!(:drink) { InlineDrink.create!(name: "Water") }
-    let!(:link) { InlineLink.create!(source: animal, target: drink) }
+    let!(:link) { InlineLink.create!(source: animal, target: drink, normal_target: drink) }
 
     let(:source) { animal }
     let(:target) { drink }
@@ -196,5 +197,60 @@ class InlineDrink < ActiveRecord::Base
       expect(link.target_id).to eq(drink.id)
       expect(link[:target_type]).to eq(13)
     end
+
+    it "doesn't break string type polymorphic associations" do
+      expect(link.normal_target).to eq(drink)
+      expect(link.normal_target_type).to eq("InlineDrink")
+    end
+  end
+
+  context "when mapping assigned to `polymorphic` option on belongs_to model" do
+    class InlineLink2 < ActiveRecord::Base
+      include PolymorphicIntegerType::Extensions
+
+      self.table_name = "links"
+
+      belongs_to :source, polymorphic: {10 => "Person", 11 => "InlineAnimal2"}
+      belongs_to :target, polymorphic: {10 => "Food", 13 => "InlineDrink2"}
+      belongs_to :normal_target, polymorphic: true
+    end
+
+    class InlineAnimal2 < ActiveRecord::Base
+      include PolymorphicIntegerType::Extensions
+
+      self.table_name = "animals"
+
+      has_many :source_links, as: :source, class_name: "InlineLink2"
+    end
+
+    class InlineDrink2 < ActiveRecord::Base
+      include PolymorphicIntegerType::Extensions
+
+      self.table_name = "drinks"
+
+      has_many :inline_links2, as: :target
+    end
+
+    let!(:animal) { InlineAnimal2.create!(name: "Lucy") }
+    let!(:drink) { InlineDrink2.create!(name: "Water") }
+    let!(:link) { InlineLink2.create!(source: animal, target: drink, normal_target: drink) }
+
+    let(:source) { animal }
+    let(:target) { drink }
+
+    include_examples "proper source"
+    include_examples "proper target"
+
+    it "pulls mapping from given hash" do
+      expect(link.source_id).to eq(animal.id)
+      expect(link[:source_type]).to eq(11)
+      expect(link.target_id).to eq(drink.id)
+      expect(link[:target_type]).to eq(13)
+    end
+
+    it "doesn't break string type polymorphic associations" do
+      expect(link.normal_target).to eq(drink)
+      expect(link.normal_target_type).to eq("InlineDrink2")
+    end
   end
 end

spec/support/migrations/1_create_link_table.rb

@@ -4,6 +4,8 @@ def up
     create_table :links do |t|
       t.integer :target_id
       t.integer :target_type
+      t.integer :normal_target_id
+      t.string :normal_target_type
       t.integer :source_id
       t.integer :source_type
     end