immigrant 0.2.0 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 083bc4d18b381bf62146a71c000495a4b108fed2
+  data.tar.gz: b096073f024d41aa6362c2d3db3a3014aa8016ba
+SHA512:
+  metadata.gz: e1fe3e50d541c96400fbb476bcac1ac9176aa51e19b8d7e373398307aa34c0cabbea3a9353f932dd47d39439558fb367418b82eae651cac1fe7368c0d7d35e79
+  data.tar.gz: ce45456a29ebf673ea5a6b987990c70c784387db86804555edebe16812322d31534ff877aae37c071419dae0b26ba6052db2a51b31b5ebd1652f4282b8cbb7a8

data/lib/generators/immigration_generator.rb

@@ -3,7 +3,7 @@ require 'rails/generators/active_record'
 class ImmigrationGenerator < ActiveRecord::Generators::Base
   def create_immigration_file
     Rails.application.eager_load!
-    @keys, warnings = Immigrant.infer_keys
+    @keys, warnings = Immigrant::KeyFinder.new.infer_keys
     warnings.values.each{ |warning| $stderr.puts "WARNING: #{warning}" }
     @keys.each do |key|
       next unless key.options[:dependent] == :delete

data/lib/immigrant/compat/3.0.rb

@@ -1,11 +1,12 @@
-module Immigrant
-  ForeignKeyDefinition = ::Foreigner::ConnectionAdapters::ForeignKeyDefinition
+require_relative 'foreigner'
 
+module Immigrant
   TEMPLATE = 'immigration-pre-3.1.rb.erb'
   FOREIGN_KEY = :primary_key_name
-  ON_DELETE = :dependent
 
-  def self.qualified_reflection?(reflection, klass)
-    reflection.options[:conditions].present?
+  class KeyFinder
+    def qualified_reflection?(reflection, klass)
+      reflection.options[:conditions].present?
+    end
   end
 end

data/lib/immigrant/compat/3.1.rb

@@ -1,12 +1,13 @@
-module Immigrant
-  ForeignKeyDefinition = ::Foreigner::ConnectionAdapters::ForeignKeyDefinition
+require_relative 'foreigner'
 
+module Immigrant
   TEMPLATE = 'immigration.rb.erb'
   FOREIGN_KEY = :foreign_key
-  ON_DELETE = :dependent
 
-  def self.qualified_reflection?(reflection, klass)
-    reflection.options[:conditions].present?
+  class KeyFinder
+    def qualified_reflection?(reflection, klass)
+      reflection.options[:conditions].present?
+    end
   end
 end
 

data/lib/immigrant/compat/4.0.rb

@@ -1,22 +1,21 @@
-module Immigrant
-  ForeignKeyDefinition = ::Foreigner::ConnectionAdapters::ForeignKeyDefinition
+require_relative 'foreigner'
 
+module Immigrant
   TEMPLATE = 'immigration.rb.erb'
   FOREIGN_KEY = :foreign_key
-  ON_DELETE = :dependent
 
-  def self.qualified_reflection?(reflection, klass)
-    scope = reflection.scope
-    if scope.nil?
-      false
-    elsif scope.respond_to?(:options)
-      scope.options[:where].present?
-    else
-      klass.instance_exec(*([nil]*scope.arity), &scope).where_values.present?
+  class KeyFinder
+    def qualified_reflection?(reflection, klass)
+      scope = reflection.scope
+      if scope.nil?
+        false
+      else
+        klass.instance_exec(*([nil]*scope.arity), &scope).where_values.present?
+      end
+    rescue
+      # if there's an error evaluating the scope block or whatever, just
+      # err on the side of caution and assume there are conditions
+      true
     end
-  rescue
-    # if there's an error evaluating the scope block or whatever, just
-    # err on the side of caution and assume there are conditions
-    true
   end
 end

data/lib/immigrant/compat/4.2.rb

@@ -1,60 +1,18 @@
-require "active_record/connection_adapters/abstract/schema_definitions"
+require_relative 'active_record'
 
 module Immigrant
-  ForeignKeyDefinition = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
-
-  TEMPLATE = 'immigration.rb.erb'
-  FOREIGN_KEY = :foreign_key
-  ON_DELETE = :on_delete
-
-  def self.qualified_reflection?(reflection, klass)
-    scope = reflection.scope
-    if scope.nil?
-      false
-    elsif scope.respond_to?(:options)
-      scope.options[:where].present?
-    else
-      klass.instance_exec(*([nil]*scope.arity), &scope).where_values.present?
-    end
-  rescue
-    # if there's an error evaluating the scope block or whatever, just
-    # err on the side of caution and assume there are conditions
-    true
-  end
-
-  module ForeignKeyExtensions
-    # DRY alert: copied from ActiveRecord::SchemaDumper#foreign_keys
-    def dump_foreign_key(foreign_key)
-      parts = [
-        "add_foreign_key #{remove_prefix_and_suffix(foreign_key.from_table).inspect}",
-        remove_prefix_and_suffix(foreign_key.to_table).inspect,
-      ]
-
-      if foreign_key.column != foreign_key_column_for(foreign_key.to_table)
-        parts << "column: #{foreign_key.column.inspect}"
-      end
-
-      if foreign_key.custom_primary_key?
-        parts << "primary_key: #{foreign_key.primary_key.inspect}"
+  class KeyFinder
+    def qualified_reflection?(reflection, klass)
+      scope = reflection.scope
+      if scope.nil?
+        false
+      else
+        klass.instance_exec(*([nil]*scope.arity), &scope).where_values.present?
       end
-
-      if foreign_key.name !~ /^fk_rails_[0-9a-f]{10}$/
-        parts << "name: #{foreign_key.name.inspect}"
-      end
-
-      parts << "on_update: #{foreign_key.on_update.inspect}" if foreign_key.on_update
-      parts << "on_delete: #{foreign_key.on_delete.inspect}" if foreign_key.on_delete
-
-      "  #{parts.join(', ')}"
-    end
-
-
-    def remove_prefix_and_suffix(table)
-      table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
-    end
-
-    def foreign_key_column_for(table_name)
-      "#{table_name.to_s.singularize}_id"
+    rescue
+      # if there's an error evaluating the scope block or whatever, just
+      # err on the side of caution and assume there are conditions
+      true
     end
   end
 end

data/lib/immigrant/compat/5.0.rb

@@ -0,0 +1 @@
+require_relative 'active_record'

data/lib/immigrant/compat/active_record.rb

@@ -0,0 +1,44 @@
+require "active_record/connection_adapters/abstract/schema_definitions"
+
+module Immigrant
+  ForeignKeyDefinition = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
+
+  TEMPLATE = 'immigration.rb.erb'
+  FOREIGN_KEY = :foreign_key
+
+  module ForeignKeyExtensions
+    # DRY alert: copied from ActiveRecord::SchemaDumper#foreign_keys
+    def dump_foreign_key(foreign_key)
+      parts = [
+        "add_foreign_key #{remove_prefix_and_suffix(foreign_key.from_table).inspect}",
+        remove_prefix_and_suffix(foreign_key.to_table).inspect,
+      ]
+
+      if foreign_key.column != foreign_key_column_for(foreign_key.to_table)
+        parts << "column: #{foreign_key.column.inspect}"
+      end
+
+      if foreign_key.custom_primary_key?
+        parts << "primary_key: #{foreign_key.primary_key.inspect}"
+      end
+
+      if foreign_key.name !~ /^fk_rails_[0-9a-f]{10}$/
+        parts << "name: #{foreign_key.name.inspect}"
+      end
+
+      parts << "on_update: #{foreign_key.on_update.inspect}" if foreign_key.on_update
+      parts << "on_delete: #{foreign_key.on_delete.inspect}" if foreign_key.on_delete
+
+      parts.join(', ')
+    end
+
+
+    def remove_prefix_and_suffix(table)
+      table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
+    end
+
+    def foreign_key_column_for(table_name)
+      "#{table_name.to_s.singularize}_id"
+    end
+  end
+end

data/lib/immigrant/compat/foreigner.rb

@@ -0,0 +1,44 @@
+begin
+  require 'foreigner'
+rescue LoadError
+  $stderr.puts <<-ERR.strip_heredoc
+
+    ERROR: immigrant requires the foreigner gem (unless you are on rails 4.2+)
+
+    To fix this, add the following to your Gemfile:
+
+      gem "foreigner", "~> 1.2"
+
+    Or just upgrade rails ;) ... lol, "just"
+
+  ERR
+  exit 1
+end
+Foreigner.load
+
+module Immigrant
+  ForeignKeyDefinition = ::Foreigner::ConnectionAdapters::ForeignKeyDefinition
+
+  module ForeignKeyExtensions
+    include Foreigner::SchemaDumper::ClassMethods
+
+    def self.included(klass)
+      # ForeignKeyExtensions already overrides initialize; override it
+      # some more
+      klass.send(:include, Module.new{
+        def initialize(from_table, to_table, options)
+          options.delete(:on_update)
+          options[:dependent] = normalize_dependent(options.delete(:on_delete))
+          super
+        end
+      })
+    end
+
+    def normalize_dependent(value)
+      case value
+      when :cascade then :delete
+      else value
+      end
+    end
+  end
+end

data/lib/immigrant/compat.rb

@@ -1,57 +1,13 @@
 version = ActiveRecord::VERSION::STRING
 
-if version >= '4.2.'
+if version >= '5.0.'
+  require_relative 'compat/5.0'
+elsif version >= '4.2.'
   require_relative 'compat/4.2'
+elsif version >= '4.0'
+  require_relative 'compat/4.0'
+elsif version >= '3.1'
+  require_relative 'compat/3.1'
 else
-  begin
-    require 'foreigner'
-  rescue LoadError
-    $stderr.puts <<-ERR.strip_heredoc
-
-      ERROR: immigrant requires the foreigner gem (unless you are on rails 4.2+)
-
-      To fix this, add the following to your Gemfile:
-
-        gem "foreigner", "~> 1.2"
-
-      Or just upgrade rails ;) ... lol, "just"
-
-    ERR
-    exit 1
-  end
-  Foreigner.load
-
-  require_relative 'compat/foreigner_extensions'
-
-  if version >= '4.0'
-    require_relative 'compat/4.0'
-  elsif version >= '3.1'
-    require_relative 'compat/3.1'
-  else
-    require_relative 'compat/3.0'
-  end
-end
-
-# add some useful things for querying/comparing/dumping foreign keys
-module Immigrant
-  module ForeignKeyExtensions
-    def initialize(from_table, to_table, options, *args)
-      options ||= {}
-      options[:name] ||= "#{from_table}_#{options[:column]}_fk"
-      super(from_table, to_table, options, *args)
-    end
-
-    def hash_key
-      [from_table, options[:column]]
-    end
-
-    def to_ruby(action = :add)
-      if action == :add
-        dump_foreign_key(self)
-      else
-        "remove_foreign_key #{from_table.inspect}, " \
-        ":name => #{options[:name].inspect}"
-      end
-    end
-  end
+  require_relative 'compat/3.0'
 end

data/lib/immigrant/foreign_key_extensions.rb

@@ -0,0 +1,23 @@
+# add some useful things for querying/comparing/dumping foreign keys
+module Immigrant
+  module ForeignKeyExtensions
+    def initialize(from_table, to_table, options, *args)
+      options ||= {}
+      options[:name] ||= "#{from_table}_#{options[:column]}_fk"
+      super(from_table, to_table, options, *args)
+    end
+
+    def hash_key
+      [from_table, options[:column]]
+    end
+
+    def to_ruby(action = :add)
+      if action == :add
+        dump_foreign_key(self)
+      else
+        "remove_foreign_key #{from_table.inspect}, " \
+        ":name => #{options[:name].inspect}"
+      end
+    end
+  end
+end

data/lib/immigrant.rb

@@ -1,7 +1,7 @@
 require 'active_support/all'
 
 module Immigrant
-  class << self
+  class KeyFinder
     def infer_keys(db_keys = current_foreign_keys, classes = model_classes)
       database_keys = db_keys.inject({}) { |hash, foreign_key|
         hash[foreign_key.hash_key] = foreign_key
@@ -27,8 +27,12 @@ module Immigrant
 
     private
 
+      def tables
+        @tables ||= ActiveRecord::Base.connection.tables
+      end
+
       def current_foreign_keys
-        ActiveRecord::Base.connection.tables.map{ |table|
+        tables.map{ |table|
           ActiveRecord::Base.connection.foreign_keys(table)
         }.flatten
       end
@@ -81,16 +85,17 @@ module Immigrant
       end
 
       def foreign_keys_for(klass)
+        return [] if klass.abstract_class? || !tables.include?(klass.table_name)
         candidate_reflections_for(klass).inject([]) do |result, reflection|
           begin
-            result.concat foreign_key_for(klass, reflection)
+            result.concat foreign_keys_for_reflection(klass, reflection)
           rescue NameError # e.g. belongs_to :oops_this_is_not_a_table
             result
           end
         end
       end
 
-      def foreign_key_for(klass, reflection)
+      def foreign_keys_for_reflection(klass, reflection)
         case reflection.macro
         when :belongs_to
           infer_belongs_to_keys(klass, reflection)
@@ -98,59 +103,112 @@ module Immigrant
           infer_has_n_keys(klass, reflection)
         when :has_and_belongs_to_many
           infer_habtm_keys(klass, reflection)
-        else
-          []
-        end
+        end || []
       end
 
       def infer_belongs_to_keys(klass, reflection)
-        return [] if reflection.name == :left_side # redundant and unusable reflection automagically created by HABTM
+        return if reflection.name == :left_side # redundant and unusable reflection automagically created by HABTM
+
+        from_table = klass.table_name
+        to_table = reflection.klass.table_name
+        column = reflection.send(FOREIGN_KEY).to_s
+        primary_key = (reflection.options[:primary_key] || reflection.klass.primary_key).to_s
+
+        return unless column_exists?(from_table, column)
+
         [
           ForeignKeyDefinition.new(
-            klass.table_name,
-            reflection.klass.table_name,
-            :column => reflection.send(FOREIGN_KEY).to_s,
-            :primary_key => (reflection.options[:primary_key] || reflection.klass.primary_key).to_s,
+            from_table,
+            to_table,
+            :column => column,
+            :primary_key => primary_key
             # although belongs_to can specify :dependent, it doesn't make
-            # sense from a foreign key perspective
-            ON_DELETE => nil
+            # sense from a foreign key perspective, so no :on_delete
           )
         ]
       end
 
       def infer_has_n_keys(klass, reflection)
+        from_table = reflection.klass.table_name
+        to_table = klass.table_name
+        column = reflection.send(FOREIGN_KEY).to_s
+        primary_key = (reflection.options[:primary_key] || klass.primary_key).to_s
+
+        actions = {}
+        if [:delete, :delete_all].include?(reflection.options[:dependent]) && !qualified_reflection?(reflection, klass)
+          actions = {:on_delete => :cascade, :on_update => :cascade}
+        end
+
+        return unless column_exists?(from_table, column)
+
         [
           ForeignKeyDefinition.new(
-            reflection.klass.table_name,
-            klass.table_name,
-            :column => reflection.send(FOREIGN_KEY).to_s,
-            :primary_key => (reflection.options[:primary_key] || klass.primary_key).to_s,
-            ON_DELETE => [:delete, :delete_all].include?(reflection.options[:dependent]) && !qualified_reflection?(reflection, klass) ? :delete : nil
+            from_table,
+            to_table,
+            {
+              :column => column,
+              :primary_key => primary_key
+            }.merge(actions)
           )
         ]
       end
 
       def infer_habtm_keys(klass, reflection)
+        keys = []
+
         join_table = (reflection.respond_to?(:join_table) ? reflection.join_table : reflection.options[:join_table]).to_s
-        [
-          ForeignKeyDefinition.new(
+
+        left_to_table = klass.table_name
+        left_column = reflection.send(FOREIGN_KEY).to_s
+        left_primary_key = klass.primary_key.to_s
+        if column_exists?(join_table, left_column)
+          keys << ForeignKeyDefinition.new(
             join_table,
-            klass.table_name,
-            :column => reflection.send(FOREIGN_KEY).to_s,
-            :primary_key => klass.primary_key.to_s,
-            ON_DELETE => nil
-          ),
-          ForeignKeyDefinition.new(
+            left_to_table,
+            :column => left_column,
+            :primary_key => left_primary_key
+          )
+        end
+
+        right_to_table = reflection.klass.table_name
+        right_column = reflection.association_foreign_key.to_s
+        right_primary_key = reflection.klass.primary_key.to_s
+        if column_exists?(join_table, left_column)
+          keys << ForeignKeyDefinition.new(
             join_table,
-            reflection.klass.table_name,
-            :column => reflection.association_foreign_key.to_s,
-            :primary_key => reflection.klass.primary_key.to_s,
-            ON_DELETE => nil
+            right_to_table,
+            :column => right_column,
+            :primary_key => right_primary_key
           )
-        ]
+        end
+
+        keys
+      end
+
+      def column_exists?(table_name, column_name)
+        columns_for(table_name).any? { |column| column.name == column_name }
+      end
+
+      def columns_for(table_name)
+        @columns ||= {}
+        @columns[table_name] ||= ActiveRecord::Base.connection.columns(table_name)
+      end
+
+      def qualified_reflection?(reflection, klass)
+        scope = reflection.scope
+        if scope.nil?
+          false
+        else
+          klass.instance_exec(*([nil]*scope.arity), &scope).where_clause.any?
+        end
+      rescue
+        # if there's an error evaluating the scope block or whatever, just
+        # err on the side of caution and assume there are conditions
+        true
       end
   end
 end
 
 require 'immigrant/loader'
+require 'immigrant/foreign_key_extensions'
 require 'immigrant/railtie' if defined?(Rails)

data/test/helper.rb

@@ -3,6 +3,7 @@ require 'bundler/setup'
 Bundler.require(:default)
 
 require 'minitest/autorun'
+require 'minitest/stub_any_instance'
 
 require 'active_record'
 require_relative "compat"

data/test/immigrant_test.rb

@@ -3,22 +3,19 @@ require 'helper'
 class ImmigrantTest < ActiveSupport::TestCase
   include TestMethods
 
-  class MockModel < ActiveRecord::Base
-    self.abstract_class = true
-    class << self
-      def primary_key
-        connection.primary_key(table_name)
-      end
-      def connection
-        @connection ||= MockConnection.new
-      end
+  ActiveRecord::Base.instance_eval do
+    def primary_key
+      connection.primary_key(table_name)
+    end
+    def connection
+      @connection ||= MockConnection.new
     end
 
     if ActiveRecord::VERSION::STRING >= '4.'
       # support old 3.x syntax for the sake of concise tests
-      [:belongs_to, :has_one, :has_many, :has_and_belongs_to_many].each do |method|
-        instance_eval <<-CODE, __FILE__, __LINE__ + 1
-          def self.#{method}(assoc, scope = nil, options = {})
+      extend(Module.new{
+        [:belongs_to, :has_one, :has_many, :has_and_belongs_to_many].each do |method|
+          define_method method do |assoc, scope = nil, options = {}|
             if scope.is_a?(Hash)
               options = scope
               scope_opts = options.extract!(:conditions, :order)
@@ -28,8 +25,8 @@ class ImmigrantTest < ActiveSupport::TestCase
             end
             super assoc, scope, options
           end
-        CODE
-      end
+        end
+      })
     end
   end
 
@@ -40,18 +37,27 @@ class ImmigrantTest < ActiveSupport::TestCase
     def primary_key(table)
       table.to_s !~ /s_.*s\z/ ? 'id' : nil
     end
+    def tables
+      ActiveSupport::DescendantsTracker.direct_descendants(ActiveRecord::Base).map(&:table_name)
+    end
+    def columns(table_name)
+      AnyColumn.new
+    end
+  end
+
+  class AnyColumn
+    def any?
+      true
+    end
   end
 
   def teardown
-    subclasses = ActiveSupport::DescendantsTracker.direct_descendants(MockModel)
+    subclasses = ActiveSupport::DescendantsTracker.direct_descendants(ActiveRecord::Base)
     subclasses.each do |subclass|
-      Object.send(:remove_const, subclass.to_s)
+      subclass = subclass.to_s
+      Object.send(:remove_const, subclass) if subclass =~ /\A[A-Z]/ && Object.const_defined?(subclass)
     end
     subclasses.replace([])
-    # also need to clear out other things under AR::Base, because as of
-    # 4.1 there are automagical anonymous classes due to HABTM
-    subclasses = ActiveSupport::DescendantsTracker.direct_descendants(ActiveRecord::Base)
-    subclasses.replace([MockModel])
   end
 
   def given(code)
@@ -60,194 +66,183 @@ class ImmigrantTest < ActiveSupport::TestCase
     Object.class_eval code
   end
 
+  def infer_keys(db_keys = [])
+    keys = Immigrant::KeyFinder.new.infer_keys(db_keys).first
+    # ensure each key generates correctly
+    keys.each { |key| key.to_ruby(:add) }
+    keys.sort_by { |key| [key.from_table, key.to_table] }
+  end
+
   # basic scenarios
 
   test 'belongs_to should generate a foreign key' do
     given <<-CODE
-      class Author < MockModel; end
-      class Book < MockModel
+      class Author < ActiveRecord::Base; end
+      class Book < ActiveRecord::Base
         belongs_to :guy, :class_name => 'Author', :foreign_key => 'author_id'
       end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'books', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'author_id', :primary_key => 'id'
        )],
-      keys
+      infer_keys
     )
   end
 
   test 'has_one should generate a foreign key' do
     given <<-CODE
-      class Author < MockModel
+      class Author < ActiveRecord::Base
         has_one :piece_de_resistance, :class_name => 'Book', :order => "id DESC"
       end
-      class Book < MockModel; end
+      class Book < ActiveRecord::Base; end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'books', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'author_id', :primary_key => 'id'
        )],
-      keys
+      infer_keys
     )
   end
 
-  test 'has_one :dependent => :delete should generate a foreign key with :on_delete => :delete' do
+  test 'has_one :dependent => :delete should generate a foreign key with :on_delete => :cascade' do
     given <<-CODE
-      class Author < MockModel
+      class Author < ActiveRecord::Base
         has_one :book, :order => "id DESC", :dependent => :delete
       end
-      class Book < MockModel; end
+      class Book < ActiveRecord::Base; end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'books', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => :delete
+         :column => 'author_id', :primary_key => 'id', :on_delete => :cascade, :on_update => :cascade
        )],
-      keys
+      infer_keys
     )
   end
 
   test 'has_many should generate a foreign key' do
     given <<-CODE
-      class Author < MockModel
+      class Author < ActiveRecord::Base
         has_many :babies, :class_name => 'Book'
       end
-      class Book < MockModel; end
+      class Book < ActiveRecord::Base; end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'books', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'author_id', :primary_key => 'id'
        )],
-      keys
+      infer_keys
     )
   end
 
-  test 'has_many :dependent => :delete_all should generate a foreign key with :on_delete => :delete' do
+  test 'has_many :dependent => :delete_all should generate a foreign key with :on_delete => :cascade' do
     given <<-CODE
-      class Author < MockModel
+      class Author < ActiveRecord::Base
         has_many :books, :dependent => :delete_all
       end
-      class Book < MockModel; end
+      class Book < ActiveRecord::Base; end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'books', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => :delete
+         :column => 'author_id', :primary_key => 'id', :on_delete => :cascade, :on_update => :cascade
        )],
-      keys
+      infer_keys
     )
   end
 
   test 'has_and_belongs_to_many should generate two foreign keys' do
     given <<-CODE
-      class Author < MockModel
+      class Author < ActiveRecord::Base
         has_and_belongs_to_many :fans
       end
-      class Fan < MockModel; end
+      class Fan < ActiveRecord::Base; end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'authors_fans', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'author_id', :primary_key => 'id'
        ),
        foreign_key_definition(
          'authors_fans', 'fans',
-         :column => 'fan_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'fan_id', :primary_key => 'id'
        )],
-      keys
+      infer_keys
     )
   end
 
   test 'has_and_belongs_to_many should respect the join_table' do
     given <<-CODE
-      class Author < MockModel
+      class Author < ActiveRecord::Base
         has_and_belongs_to_many :fans, :join_table => :lols_wuts
       end
-      class Fan < MockModel; end
+      class Fan < ActiveRecord::Base; end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'lols_wuts', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'author_id', :primary_key => 'id'
        ),
        foreign_key_definition(
          'lols_wuts', 'fans',
-         :column => 'fan_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'fan_id', :primary_key => 'id'
        )],
-      keys
+      infer_keys
     )
   end
 
   test 'conditional has_one/has_many associations should ignore :dependent' do
     given <<-CODE
-      class Author < MockModel
+      class Author < ActiveRecord::Base
         has_many :articles, :conditions => "published", :dependent => :delete_all
         has_one :favorite_book, :class_name => 'Book',
                 :conditions => "most_awesome", :dependent => :delete
       end
-      class Book < MockModel; end
-      class Article < MockModel; end
+      class Book < ActiveRecord::Base; end
+      class Article < ActiveRecord::Base; end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'articles', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'author_id', :primary_key => 'id'
        ),
        foreign_key_definition(
          'books', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'author_id', :primary_key => 'id'
        )],
-      keys
+      infer_keys
     )
   end
 
   test 'primary_key should be respected' do
     given <<-CODE
-      class User < MockModel
+      class User < ActiveRecord::Base
         has_many :emails, :primary_key => :email, :foreign_key => :to,
                  :dependent => :destroy
       end
-      class Email < MockModel
+      class Email < ActiveRecord::Base
         belongs_to :user, :primary_key => :email, :foreign_key => :to
       end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
         'emails', 'users',
-        :column => 'to', :primary_key => 'email', Immigrant::ON_DELETE => nil
+        :column => 'to', :primary_key => 'email'
        )],
-      keys
+      infer_keys
     )
   end
 
@@ -255,64 +250,58 @@ class ImmigrantTest < ActiveSupport::TestCase
 
   test 'STI should not generate duplicate foreign keys' do
     given <<-CODE
-      class Company < MockModel; end
-      class Employee < MockModel
+      class Company < ActiveRecord::Base; end
+      class Employee < ActiveRecord::Base
         belongs_to :company
       end
       class Manager < Employee; end
     CODE
 
     assert(Manager.reflections.present?)
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'employees', 'companies',
-         :column => 'company_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'company_id', :primary_key => 'id'
        )],
-      keys
+      infer_keys
     )
   end
 
   test 'complementary associations should not generate duplicate foreign keys' do
     given <<-CODE
-      class Author < MockModel
+      class Author < ActiveRecord::Base
         has_many :books
       end
-      class Book < MockModel
+      class Book < ActiveRecord::Base
         belongs_to :author
       end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'books', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'author_id', :primary_key => 'id'
        )],
-      keys
+      infer_keys
     )
   end
 
   test 'redundant associations should not generate duplicate foreign keys' do
     given <<-CODE
-      class Author < MockModel
+      class Author < ActiveRecord::Base
         has_many :books
         has_many :favorite_books, :class_name => 'Book', :conditions => "awesome"
         has_many :bad_books, :class_name => 'Book', :conditions => "amateur_hour"
       end
-      class Book < MockModel; end
+      class Book < ActiveRecord::Base; end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'books', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'author_id', :primary_key => 'id'
        )],
-      keys
+      infer_keys
     )
   end
 
@@ -323,33 +312,32 @@ class ImmigrantTest < ActiveSupport::TestCase
     database_keys = [
       foreign_key_definition(
         'articles', 'authors',
-        :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil,
+        :column => 'author_id', :primary_key => 'id',
         :name => "doesn't_matter"
       ),
       foreign_key_definition(
         'books', 'authors', :column => 'author_id', :primary_key => 'id',
-        Immigrant::ON_DELETE => :delete
+        :on_delete => :restrict, :on_update => :nullify
       )
     ]
 
     given <<-CODE
-      class Author < MockModel
+      class Author < ActiveRecord::Base
         has_many :articles
         has_one :favorite_book, :class_name => 'Book',
                 :conditions => "most_awesome"
       end
-      class Book < MockModel; end
-      class Article < MockModel; end
+      class Book < ActiveRecord::Base; end
+      class Article < ActiveRecord::Base; end
     CODE
 
-    keys = Immigrant.infer_keys(database_keys).first
-    assert_equal([], keys)
+    assert_equal([], infer_keys(database_keys))
   end
 
   if ActiveRecord::VERSION::STRING < '4.'
     test 'finder_sql associations should not generate foreign keys' do
       given <<-CODE
-        class Author < MockModel
+        class Author < ActiveRecord::Base
           has_many :books, :finder_sql => <<-SQL
             SELECT *
             FROM books
@@ -357,79 +345,113 @@ class ImmigrantTest < ActiveSupport::TestCase
             ORDER BY RANDOM() LIMIT 5'
           SQL
         end
-        class Book < MockModel; end
+        class Book < ActiveRecord::Base; end
       CODE
 
-      keys = Immigrant.infer_keys([]).first
-      assert_equal([], keys)
+      assert_equal([], infer_keys)
     end
   end
 
   test 'polymorphic associations should not generate foreign keys' do
     given <<-CODE
-      class Property < MockModel
+      class Property < ActiveRecord::Base
         belongs_to :owner, :polymorphic => true
       end
-      class Person < MockModel
+      class Person < ActiveRecord::Base
         has_many :properties, :as => :owner
       end
-      class Corporation < MockModel
+      class Corporation < ActiveRecord::Base
         has_many :properties, :as => :owner
       end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_equal([], keys)
+    assert_equal([], infer_keys)
   end
 
   test 'has_many :through should not generate foreign keys' do
     given <<-CODE
-      class Author < MockModel
+      class Author < ActiveRecord::Base
         has_many :authors_fans
         has_many :fans, :through => :authors_fans
       end
-      class AuthorsFan < MockModel
+      class AuthorsFan < ActiveRecord::Base
         belongs_to :author
         belongs_to :fan
       end
-      class Fan < MockModel
+      class Fan < ActiveRecord::Base
         has_many :authors_fans
         has_many :authors, :through => :authors_fans
       end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'authors_fans', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'author_id', :primary_key => 'id'
        ),
        foreign_key_definition(
          'authors_fans', 'fans',
-         :column => 'fan_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'fan_id', :primary_key => 'id'
        )],
-      keys
+      infer_keys
     )
   end
 
   test 'broken associations should not cause errors' do
     given <<-CODE
-      class Author < MockModel; end
-      class Book < MockModel
+      class Author < ActiveRecord::Base; end
+      class Book < ActiveRecord::Base
         belongs_to :author
         belongs_to :invalid
       end
     CODE
 
-    keys = Immigrant.infer_keys([]).first
-    assert_nothing_raised { keys.map { |key| key.to_ruby(:add) } }
     assert_equal(
       [foreign_key_definition(
          'books', 'authors',
-         :column => 'author_id', :primary_key => 'id', Immigrant::ON_DELETE => nil
+         :column => 'author_id', :primary_key => 'id'
        )],
-      keys
+      infer_keys
     )
   end
+
+  test 'abstract classes should not generate a foreign key' do
+    given <<-CODE
+      class User < ActiveRecord::Base; end
+      class Widget < ActiveRecord::Base
+        self.abstract_class = true
+
+        belongs_to :user
+      end
+    CODE
+
+    assert_equal([], infer_keys)
+  end
+
+  test 'missing tables should not generate a foreign key' do
+    given <<-CODE
+      class User < ActiveRecord::Base; end
+      class Widget < ActiveRecord::Base
+        self.table_name = :wiiiidgets
+        belongs_to :user
+      end
+    CODE
+
+    MockConnection.stub_any_instance(:tables, ["users"]) do
+      assert_equal([], infer_keys)
+    end
+  end
+
+  test 'invalid columns should not generate a foreign key' do
+    given <<-CODE
+      class User < ActiveRecord::Base; end
+      class Widget < ActiveRecord::Base
+        belongs_to :user
+      end
+    CODE
+
+    MockConnection.stub_any_instance(:columns, []) do
+      assert_equal([], infer_keys)
+    end
+  end
 end

metadata

@@ -1,30 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: immigrant
 version: !ruby/object:Gem::Version
-  version: 0.2.0
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Jon Jensen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-11 00:00:00.000000000 Z
+date: 2015-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 description: Adds a generator for creating a foreign key migration based on your current
@@ -35,47 +32,48 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
-- Rakefile
 - README.md
+- Rakefile
 - lib/generators/USAGE
 - lib/generators/immigration_generator.rb
 - lib/generators/templates/immigration-pre-3.1.rb.erb
 - lib/generators/templates/immigration.rb.erb
+- lib/immigrant.rb
+- lib/immigrant/compat.rb
 - lib/immigrant/compat/3.0.rb
 - lib/immigrant/compat/3.1.rb
 - lib/immigrant/compat/4.0.rb
 - lib/immigrant/compat/4.2.rb
-- lib/immigrant/compat/foreigner_extensions.rb
-- lib/immigrant/compat.rb
+- lib/immigrant/compat/5.0.rb
+- lib/immigrant/compat/active_record.rb
+- lib/immigrant/compat/foreigner.rb
+- lib/immigrant/foreign_key_extensions.rb
 - lib/immigrant/loader.rb
 - lib/immigrant/railtie.rb
-- lib/immigrant.rb
 - test/compat.rb
 - test/helper.rb
 - test/immigrant_test.rb
 homepage: http://github.com/jenseng/immigrant
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.5
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23.2
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Foreign key migration generator for Rails
 test_files: []
-has_rdoc: 

data/lib/immigrant/compat/foreigner_extensions.rb

@@ -1,5 +0,0 @@
-module Immigrant
-  module ForeignKeyExtensions
-    include Foreigner::SchemaDumper::ClassMethods
-  end
-end