Merge pull request #18 from jnraine/master

Add inline mappings and simplify configuration

Author: Kyle d'Oliveira

README.md

@@ -1,6 +1,7 @@
 # PolymorphicIntegerType
 
 Rails' polymorphic associations are pretty useful. The example they give to set it up looks like:
+
 ```ruby
 class Picture < ActiveRecord::Base
   belongs_to :imageable, polymorphic: true
@@ -16,6 +17,7 @@ end
 ```
 
 With a migration that looks like:
+
 ```ruby
 class CreatePictures < ActiveRecord::Migration
   def change
@@ -49,38 +51,48 @@ 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.
+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.
 
-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.)
 ```ruby
 class Picture < ActiveRecord::Base
   include PolymorphicIntegerType::Extensions
-  belongs_to :imageable, polymorphic: true, integer_type: true
+
+  belongs_to :imageable, polymorphic: {1 => "Employee", 2 => "Product"}
 end
+```
 
+ 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
 ```
 
-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`)
-```ruby
-PolymorphicIntegerType::Mapping.configuration do |config|
+### External mappings
 
-  config.add :imageable, {1 => "Employee", 2 => "Product" }  	
+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" }
 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
 class PictureToPolymorphicIntegerType < ActiveRecord::Migration
 
@@ -125,8 +137,18 @@ end
 ```
 
 Lastly, you will need to be careful of any place where you are doing raw SQL queries with the string (`imageable_type = 'Employee'`). They should use the integer instead.
-  
 
+## Setup
+
+You'll need to have git, Ruby, and MySQL. Then get up and running with a few commands:
+
+```bash
+$ git clone ...
+$ bundle install
+$ vim spec/support/database.yml # Update username and password
+$ bin/setup
+$ bundle exec rspec
+```
 
 ## Contributing
 

Rakefile

@@ -1 +1,39 @@
 require "bundler/gem_tasks"
+require "yaml"
+require "active_record"
+
+namespace :db do
+  database_config = YAML.load(File.open("./spec/support/database.yml"))
+  admin_database_config = database_config.merge(database: "mysql")
+  migration_path = File.expand_path("./spec/support/migrations")
+
+  desc "Create the database"
+  task :create do
+    ActiveRecord::Base.establish_connection(admin_database_config)
+    ActiveRecord::Base.connection.create_database(database_config.fetch(:database))
+    puts "Database created."
+  end
+
+  desc "Migrate the database"
+  task :migrate do
+    ActiveRecord::Base.establish_connection(database_config)
+    ActiveRecord::Migrator.migrate(migration_path)
+    Rake::Task["db:schema"].invoke
+    puts "Database migrated."
+  end
+
+  desc "Drop the database"
+  task :drop do
+    ActiveRecord::Base.establish_connection(admin_database_config)
+    ActiveRecord::Base.connection.drop_database(database_config.fetch(:database))
+    puts "Database deleted."
+  end
+
+  desc "Reset the database"
+  task reset: [:drop, :create, :migrate]
+    desc 'Create a db/schema.rb file that is portable against any DB supported by AR'
+
+  task :schema do
+    # Noop to make ActiveRecord happy
+  end
+end

bin/setup

@@ -0,0 +1,2 @@
+#!/bin/bash
+bundle exec rake db:drop db:create db:migrate

lib/polymorphic_integer_type/extensions.rb

@@ -7,10 +7,22 @@ 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
-          mapping = PolymorphicIntegerType::Mapping[name]
+        if options[:polymorphic] && (integer_type || options[:polymorphic].is_a?(Hash))
+          mapping =
+            case integer_type
+            when true then PolymorphicIntegerType::Mapping[name]
+            when nil then options[:polymorphic]
+            else
+              raise ArgumentError, "Unknown integer_type value: #{integer_type.inspect}"
+            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 +52,23 @@ 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
+        polymorphic_type_mapping = retrieve_polymorphic_type_mapping(
+          polymorphic_type: options[:as],
+          class_name: options[:class_name] || name.to_s.classify
+        )
+
+        if options[:as] && (polymorphic_type_mapping || 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
+          polymorphic_type_mapping ||= PolymorphicIntegerType::Mapping[poly_type]
+          if polymorphic_type_mapping == nil
+            raise "Polymorphic type mapping missing for #{poly_type.inspect}"
+          end
+
+          klass_mapping = (polymorphic_type_mapping || {}).key(sti_name)
+
+          if klass_mapping == nil
+            raise "Class not found for #{sti_name.inspect} in polymorphic type mapping: #{polymorphic_type_mapping}"
+          end
 
           options[:foreign_key] ||= "#{poly_type}_id"
           foreign_type = options.delete(:foreign_type) || "#{poly_type}_type"
@@ -59,6 +83,17 @@ 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 = class_name.safe_constantize
+        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

polymorphic_integer_type.gemspec

@@ -24,5 +24,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "activerecord", "4.2.0"
   spec.add_development_dependency "mysql2", "0.3.16"
   spec.add_development_dependency "byebug"
-
 end