Allow inline polymorphic mappings

This moves the mapping data into the model and allows different models that use the same relationship name to have different mappings.

This is how it used to work:
```ruby
class Picture < ActiveRecord::Base
  include PolymorphicIntegerType::Extensions
  belongs_to :imageable, polymorphic: true, integer_type: {1 => "Employee", 2 => "Product"}
end

class Employee < ActiveRecord::Base
  include PolymorphicIntegerType::Extensions
  has_many :pictures, as: :imageable, integer_type: true
end

class Product < ActiveRecord::Base
  include PolymorphicIntegerType::Extensions
  has_many :pictures, as: :imageable, integer_type: true
end

PolymorphicIntegerType::Mapping.configuration do |config|
  config.add :imageable, {1 => "Employee", 2 => "Product" }
end
```

This is how it works now:

```ruby
class Picture < ActiveRecord::Base
  include PolymorphicIntegerType::Extensions
  belongs_to :imageable, polymorphic: true, integer_type: {1 => "Employee", 2 => "Product"}
end

class Employee < ActiveRecord::Base
  include PolymorphicIntegerType::Extensions
  has_many :pictures, as: :imageable, integer_type: true
end

class Product < ActiveRecord::Base
  include PolymorphicIntegerType::Extensions
  has_many :pictures, as: :imageable, integer_type: true
end
```

The old way still works, allowing for smooth migration to the inline style.

Author: jnraine

README.md

@@ -51,16 +51,20 @@ For Rails 3.2 use version < 2. Version >= 2 has been tested on Rails 4.2 and Rub
 
 ## Usage
 
-The gem is pretty straightforward to use.
+Include `PolymorphicIntegerType::Extensions` into each associated model class then set the `integer_type` option on the appropriate association.
 
-First, include the extensions module and add the `integer_type`  option to the associations that are going to be using this. (That way it will play nicely with polymorphic associations whose type you would rather leave as a string.)
+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.
 
 ```ruby
 class Picture < ActiveRecord::Base
   include PolymorphicIntegerType::Extensions
-  belongs_to :imageable, polymorphic: true, integer_type: true
+  belongs_to :imageable, polymorphic: true, integer_type: {1 => "Employee", 2 => "Product"}
 end
+```
 
+ Next, set `integer_type` to true on any related `has_many` or `has_one` associations:
+
+```ruby
 class Employee < ActiveRecord::Base
   include PolymorphicIntegerType::Extensions
   has_many :pictures, as: :imageable, integer_type: true
@@ -72,18 +76,20 @@ class Product < ActiveRecord::Base
 end
 ```
 
-Second, you need to create a mapping for the polymorphic associations. This should be loaded before the models. Putting it in an initializer is good (`config/initializers/polymorphic_type_mapping.rb`)
+### External mappings
+
+You can also store polymorphic type mappings separate from your models. This should be loaded before the models. Putting it in an initializer is one way to do this (e.g., `config/initializers/polymorphic_type_mapping.rb`)
 
 ```ruby
 PolymorphicIntegerType::Mapping.configuration do |config|
-
-  config.add :imageable, {1 => "Employee", 2 => "Product" }  	
-
+  config.add :imageable, {1 => "Employee", 2 => "Product" }
 end 
 ```
 
 Note: The mapping here can start from whatever integer you wish, but I would advise not using 0. The reason being that if you had a new class, for instance `Avatar`, and also wanted to use this polymorphic association but forgot to include it in the mapping, it would effectively get `to_i` called on it and stored in the database. `"Avatar".to_i == 0`, so if your mapping included 0, this would create a weird bug. 
 
+### Migrating an existing association
+
 If you want to convert a polymorphic association that is already a string, you'll need to set up a migration. (Assuming SQL for the time being, but this should be pretty straightforward.)
 
 ```ruby

lib/polymorphic_integer_type/extensions.rb

@@ -8,9 +8,20 @@ def belongs_to(name, scope = nil, options = {})
         integer_type = options.delete :integer_type
         super
         if options[:polymorphic] && integer_type
-          mapping = PolymorphicIntegerType::Mapping[name]
+          mapping =
+            if integer_type == true
+              PolymorphicIntegerType::Mapping[name]
+            else
+              integer_type
+            end.dup
+
           foreign_type = reflections[name.to_s].foreign_type
-          self._polymorphic_foreign_types << foreign_type
+          _polymorphic_foreign_types << foreign_type
+
+          # Required way to dynamically define a class method on the model
+          singleton_class.__send__(:define_method, "#{foreign_type}_mapping") do
+            mapping
+          end
 
           define_method foreign_type do
             t = super()
@@ -40,11 +51,30 @@ def belongs_to(name, scope = nil, options = {})
 
       def remove_type_and_establish_mapping(name, options, scope)
         integer_type = options.delete :integer_type
+
         if options[:as] && integer_type
           poly_type = options.delete(:as)
-          mapping = PolymorphicIntegerType::Mapping[poly_type]
-          klass_mapping = (mapping||{}).key self.sti_name
-          raise "Polymorphic Class Mapping is missing for #{poly_type}" unless klass_mapping
+          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
+            raise "Polymorphic type mapping missing for #{poly_type.inspect}"
+          end
+
+          klass_mapping = (mapping || {}).key(sti_name)
+
+          if klass_mapping == nil
+            raise "Class not found for #{sti_name.inspect} in polymorphic type mapping: #{mapping}"
+          end
 
           options[:foreign_key] ||= "#{poly_type}_id"
           foreign_type = options.delete(:foreign_type) || "#{poly_type}_type"

spec/polymorphic_integer_type_spec.rb

@@ -148,5 +148,53 @@
     end
   end
 
-  context "when "
+  context "when mapping is given inline in the belongs_to model" do
+    class InlineLink < ActiveRecord::Base
+      include PolymorphicIntegerType::Extensions
+
+      self.table_name = "links"
+
+      belongs_to :source, polymorphic: true, integer_type: {10 => "Person", 11 => "InlineAnimal"}
+      belongs_to :target, polymorphic: true, integer_type: {10 => "Food", 13 => "InlineDrink"}
+    end
+
+    class InlineAnimal < ActiveRecord::Base
+      include PolymorphicIntegerType::Extensions
+
+      self.table_name = "animals"
+
+      belongs_to :owner, class_name: "Person"
+      has_many :source_links, as: :source, class_name: "InlineLink", integer_type: true
+    end
+
+    class InlineDrink < ActiveRecord::Base
+      include PolymorphicIntegerType::Extensions
+
+      self.table_name = "drinks"
+
+      has_many :inline_links, as: :target, integer_type: true
+    end
+
+    let!(:animal) { InlineAnimal.create!(name: "Lucy") }
+    let!(:drink) { InlineDrink.create!(name: "Water") }
+    let!(:link) { InlineLink.create!(source: animal, target: drink) }
+
+    let(:source) { animal }
+    let(:target) { drink }
+
+    include_examples "proper source"
+    include_examples "proper target"
+
+    it "creates foreign_type mapping method" do
+      expect(Link.source_type_mapping).to eq({0 => "Person", 1 => "Animal"})
+      expect(InlineLink.source_type_mapping).to eq({10 => "Person", 11 => "InlineAnimal"})
+    end
+
+    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
+  end
 end