foreign_key_saver 2.0.0

data/.gitignore

@@ -0,0 +1 @@
+test/log/*

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007-2008 Will Bryant, Sekuda Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,36 @@
+ForeignKeySaver
+===============
+
+This plugin adds an add_foreign_key_constraint schema method, and extends the
+schema dump code to output these foreign key constraints.
+
+Only MySQL and PostgreSQL are currently supported.
+
+
+Examples
+========
+
+# adds a constraint on projects.customer_id with parent customers.id
+add_foreign_key :projects, :customer_id, :customers, :id
+
+# adds a constraint on projects(a, b) with parent(a, b) with the default RESTRICT update/delete actions
+add_foreign_key "child", ["a", "b"], "parent", ["a", "b"]
+
+# adds a constraint with the ON UPDATE action set to CASCADE and the ON DELETE action set to SET NULL
+add_foreign_key 'projects', 'customer_id', 'customers', 'id', :on_update => :cascade, :on_delete => :set_null
+
+The following actions are defined:
+  :restrict
+  :no_action
+  :cascade
+  :set_null (aka :nullify)
+  :set_default
+Note that MySQL does not support :set_default, and also treats :no_action as :restrict.
+
+
+Compatibility
+=============
+
+Supports mysql, mysql2, postgresql.
+
+Currently tested against Rails 3.2.13 on 2.0.0p0 and Rails 3.2.13, 3.1.8, 3.0.17, and 2.3.14 on Ruby 1.8.7.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'rake/testtask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the foreign_key_constraints plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/foreign_key_saver.gemspec

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/foreign_key_saver/version', __FILE__)
+
+spec = Gem::Specification.new do |gem|
+  gem.name         = 'foreign_key_saver'
+  gem.version      = ForeignKeySaver::VERSION
+  gem.summary      = "Adds support for foreign key constraints to ActiveRecord schema operations."
+  gem.description  = <<-EOF
+Adds a add_foreign_key_constraint schema method, and extends the schema dump code to output these
+foreign key constraints.
+
+Only MySQL and PostgreSQL are currently supported.
+
+
+Examples
+========
+
+# adds a constraint on projects.customer_id with parent customers.id
+add_foreign_key :projects, :customer_id, :customers, :id
+
+# adds a constraint on projects(a, b) with parent(a, b) with the default RESTRICT update/delete actions
+add_foreign_key "child", ["a", "b"], "parent", ["a", "b"]
+
+# adds a constraint with the ON UPDATE action set to CASCADE and the ON DELETE action set to SET NULL
+add_foreign_key 'projects', 'customer_id', 'customers', 'id', :on_update => :cascade, :on_delete => :set_null
+
+The following actions are defined:
+  :restrict
+  :no_action
+  :cascade
+  :set_null (aka :nullify)
+  :set_default
+Note that MySQL does not support :set_default, and also treats :no_action as :restrict.
+
+
+Compatibility
+=============
+
+Supports mysql, mysql2, postgresql.
+
+Currently tested against Rails 3.2.13 on 2.0.0p0 and Rails 3.2.13, 3.1.8, 3.0.17, and 2.3.14 on Ruby 1.8.7.
+EOF
+  gem.has_rdoc     = false
+  gem.author       = "Will Bryant"
+  gem.email        = "will.bryant@gmail.com"
+  gem.homepage     = "http://github.com/willbryant/foreign_key_saver"
+  
+  gem.executables  = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files        = `git ls-files`.split("\n")
+  gem.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_path = "lib"
+  
+  gem.add_dependency "activerecord"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "mysql"
+  gem.add_development_dependency "mysql2"
+  gem.add_development_dependency "pg"
+end

data/init.rb

@@ -0,0 +1 @@
+require 'foreign_key_saver/foreign_key_saver_patches'

data/lib/foreign_key_saver.rb

@@ -0,0 +1,3 @@
+Rails::Application.initializer :load_foreign_key_saver, :before => :load_config_initializers do
+  require 'foreign_key_saver/foreign_key_saver_patches'
+end

data/lib/foreign_key_saver/foreign_key_saver_patches.rb

@@ -0,0 +1,202 @@
+require 'active_record'
+
+module ActiveRecord
+  class ForeignKeyConstraint
+    ACTIONS = { :restrict => 'RESTRICT', :no_action   => 'NO ACTION', :cascade  => 'CASCADE',
+                :set_null => 'SET NULL', :set_default => 'SET DEFAULT' }.freeze
+                
+    attr_accessor :name, :referenced_table
+    attr_reader :key, :referenced_key, :update_action, :delete_action
+    
+    def initialize(name, key, referenced_table, referenced_key, update_action = nil, delete_action = nil)
+      self.name = name
+      self.key = key
+      self.referenced_table = referenced_table
+      self.referenced_key = referenced_key
+      self.update_action = update_action
+      self.delete_action = delete_action
+    end
+    
+    def key=(columns)
+      @key = columns.is_a?(Enumerable) && columns.length == 1 ? columns.first : columns
+    end
+    
+    def referenced_key=(columns)
+      @referenced_key = columns.is_a?(Enumerable) && columns.length == 1 ? columns.first : columns
+    end
+    
+    def update_action=(action)
+      @update_action = ACTIONS.invert[action] || action || :restrict
+    end
+    
+    def delete_action=(action)
+      @delete_action = ACTIONS.invert[action] || action || :restrict
+    end
+    
+    def ==(other)
+      name == other.name && key == other.key &&
+      referenced_table == other.referenced_table && referenced_key == other.referenced_key &&
+      update_action == other.update_action && delete_action == other.delete_action
+    end
+    
+    def quote_constraint_action(action)
+      ACTIONS[action.to_sym] || action.to_s
+    end
+    
+    def to_sql(connection)
+      (name.blank? ? "" : "CONSTRAINT #{connection.quote_column_name(name)} ") +
+      "FOREIGN KEY (#{connection.quote_column_names(key)}) " +
+      "REFERENCES #{connection.quote_table_name(referenced_table)} (#{connection.quote_column_names(referenced_key)}) " +
+      "ON UPDATE #{quote_constraint_action(update_action)} " +
+      "ON DELETE #{quote_constraint_action(delete_action)}"
+    end
+    
+    def to_dump
+      dump = "#{key.inspect}, #{referenced_table.inspect}, #{referenced_key.inspect}"
+      dump << ", :name => #{name.inspect}" unless name.blank?
+      dump << ", :on_update => #{update_action.inspect}" if update_action != :restrict
+      dump << ", :on_delete => #{delete_action.inspect}" if delete_action != :restrict
+      dump
+    end
+    
+    def to_s
+      name
+    end
+    
+    def self.constraint_action_from_sql(action)
+      ACTIONS.invert[action] || action
+    end
+  end
+  
+  module ConnectionAdapters
+    module SchemaStatements
+      VALID_FOREIGN_KEY_OPTIONS = [:name, :on_update, :on_delete]
+      
+      def add_foreign_key_constraint(table_name, key, referenced_table, referenced_key, options = {})
+        options.assert_valid_keys(VALID_FOREIGN_KEY_OPTIONS)
+        execute "ALTER TABLE #{quote_table_name(table_name)} ADD #{ForeignKeyConstraint.new(options[:name], key, referenced_table, referenced_key, options[:on_update], options[:on_delete]).to_sql(self)}"
+      end
+      
+      def remove_foreign_key_constraint(table_name, constraint)
+        execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(constraint)}"
+      end
+    end
+    
+    class AbstractAdapter
+      def quote_column_names(*column_names)
+        column_names.flatten.map {|column_name| quote_column_name(column_name)} * ', '
+      end
+      
+      def drop_table_with_foreign_keys(table_name, options = {})
+        remove_foreign_key_constraints_referencing(table_name) if tables.include?(table_name) # the if is an optimization for the sake of create_table with :force => true, which is crucial for db:test:prepare performance on mysql as mysql's INFORMATION_SCHEMA implementation is excrutiatingly slow; it's not needed for postgres, but does give a small boost to performance there too
+        drop_table_without_foreign_keys(table_name, options)
+      end
+      alias_method_chain :drop_table, :foreign_keys
+    end
+    
+    module MysqlAdapterForeignKeyMethods # common to mysql & mysql2
+      def remove_foreign_key_constraint(table_name, constraint)
+        execute "ALTER TABLE #{quote_table_name(table_name)} DROP FOREIGN KEY #{quote_column_name(constraint)}"
+      end
+    
+      def remove_foreign_key_constraints_referencing(table_name)
+        select_rows(
+                "SELECT DISTINCT TABLE_NAME, CONSTRAINT_NAME" +
+                "  FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE" +
+                " WHERE REFERENCED_TABLE_SCHEMA = SCHEMA()" +
+                "   AND REFERENCED_TABLE_NAME = #{quote(table_name)}").each do |table_name, constraint_name|
+          remove_foreign_key_constraint(table_name, constraint_name)
+        end
+      end
+    
+      def foreign_key_constraints_on(table_name)
+        self.class.constraints_from_sql(select_one("SHOW CREATE TABLE #{quote_table_name(table_name)}")["Create Table"])
+      end
+      
+      def self.constraints_from_sql(create_table_sql)
+        # the clauses look like this: CONSTRAINT `ab` FOREIGN KEY (`ac`, `bc`) REFERENCES `parent` (`a`, `b`) ON DELETE SET NULL ON UPDATE CASCADE
+        create_table_sql.scan(/CONSTRAINT `([^`]+)` FOREIGN KEY \((`(?:[^`]+)`(?:, `(?:[^`]+)`)*)\) REFERENCES `([^`]+)` \((`(?:[^`]+)`(?:, `(?:[^`]+)`)*)\)(?: ON DELETE (CASCADE|RESTRICT|NO ACTION|SET NULL|SET DEFAULT))?(?: ON UPDATE (CASCADE|RESTRICT|NO ACTION|SET NULL|SET DEFAULT))?/).collect do |capture|
+          ForeignKeyConstraint.new(capture[0], columns_from_sql(capture[1]), capture[2], columns_from_sql(capture[3]), capture[5], capture[4])
+        end
+      end
+  
+      def self.columns_from_sql(column_list_sql)
+        column_list_sql.scan(/`([^`]+)`/).collect(&:first)
+      end
+    end
+    
+    if const_defined?(:MysqlAdapter)
+      class MysqlAdapter
+        include MysqlAdapterForeignKeyMethods
+      
+        def self.constraints_from_sql(create_table_sql)
+          MysqlAdapterForeignKeyMethods.constraints_from_sql(create_table_sql)
+        end
+      
+        def self.columns_from_sql(column_list_sql)
+          MysqlAdapterForeignKeyMethods.columns_from_sql(column_list_sql)
+        end
+      end
+    end
+    
+    if const_defined?(:Mysql2Adapter)
+      class Mysql2Adapter
+        include MysqlAdapterForeignKeyMethods
+      
+        def self.constraints_from_sql(create_table_sql)
+          MysqlAdapterForeignKeyMethods.constraints_from_sql(create_table_sql)
+        end
+      
+        def self.columns_from_sql(column_list_sql)
+          MysqlAdapterForeignKeyMethods.columns_from_sql(column_list_sql)
+        end
+      end
+    end
+    
+    if const_defined?(:PostgreSQLAdapter)
+      class PostgreSQLAdapter
+        def remove_foreign_key_constraints_referencing(table_name)
+          select_rows(
+                  "SELECT referenced.relname, pg_constraint.conname" +
+                  "  FROM pg_constraint, pg_class, pg_class referenced" +
+                  " WHERE pg_constraint.confrelid = pg_class.oid" +
+                  "   AND pg_class.relname = #{quote(table_name)}" +
+                  "   AND referenced.oid = pg_constraint.conrelid").each do |table_name, constraint_name|
+            remove_foreign_key_constraint(table_name, constraint_name)
+          end
+        end
+      
+        def foreign_key_constraints_on(table_name)
+          select_rows(
+                  "SELECT pg_constraint.conname, pg_get_constraintdef(pg_constraint.oid)" +
+                  "  FROM pg_constraint, pg_class" +
+                  " WHERE pg_constraint.conrelid = pg_class.oid" +
+                  "   AND pg_class.relname = #{quote(table_name)}").collect do |name, constraintdef|
+            self.class.foreign_key_from_sql(name, constraintdef)
+          end.compact
+        end
+      
+        def self.foreign_key_from_sql(name, foreign_key_sql)
+          # the clauses look like this: FOREIGN KEY (ac, bc) REFERENCES parent(ap, bp) ON UPDATE CASCADE ON DELETE SET NULL
+          capture = foreign_key_sql.match(/FOREIGN KEY \(((?:\w+)(?:, \w+)*)\) REFERENCES (\w+)\(((?:\w+)(?:, \w+)*)\)(?: ON UPDATE (CASCADE|RESTRICT|NO ACTION|SET NULL|SET DEFAULT))?(?: ON DELETE (CASCADE|RESTRICT|NO ACTION|SET NULL|SET DEFAULT))?/)
+          ForeignKeyConstraint.new(name, capture[1].split(', '), capture[2], capture[3].split(', '), capture[4], capture[5]) if capture
+        end
+      end
+    end
+  end
+
+  class SchemaDumper
+    def foreign_key_constraints_on(table_name, stream)
+      constraints = @connection.foreign_key_constraints_on(table_name)
+      constraints.each {|constraint| stream.puts "  add_foreign_key_constraint #{table_name.inspect}, #{constraint.to_dump}"}
+      stream.puts unless constraints.empty?
+    end
+
+    def tables_with_foreign_key_constraints(stream)
+      tables_without_foreign_key_constraints(stream)
+      @connection.tables.sort.each {|table| foreign_key_constraints_on(table, stream)}
+    end
+    
+    alias_method_chain :tables, :foreign_key_constraints
+  end
+end

data/lib/foreign_key_saver/version.rb

@@ -0,0 +1,3 @@
+module ForeignKeySaver
+  VERSION = '2.0.0'
+end

data/test/database.yml

@@ -0,0 +1,11 @@
+mysql:
+    adapter: mysql
+    database: fkc_test
+    username: root
+mysql2:
+    adapter: mysql2
+    database: fkc_test
+    username: root
+postgresql:
+    adapter: postgresql
+    database: fkc_test

data/test/foreign_key_constraints_test.rb

@@ -0,0 +1,226 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class ForeignKeyConstraintsTest < Test::Unit::TestCase
+  def schema_dump
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    stream.rewind
+    stream.read
+  end
+  
+  def schema(&block)
+    ActiveRecord::Schema.define(:version => 1, &block)
+    schema_dump
+  end
+  
+  def test_constraints_to_dump
+    assert_equal '"ac", "parent", "ap", :name => "cn"',
+      ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap').to_dump
+      
+    assert_equal '["ac", "bc"], "parent", ["ap", "bp"], :name => "cn"',
+      ActiveRecord::ForeignKeyConstraint.new('cn', ['ac', 'bc'], 'parent', ['ap', 'bp']).to_dump
+      
+    assert_equal '"ac", "parent", "ap", :name => "cn", :on_update => :cascade',
+      ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', :cascade).to_dump
+  
+    assert_equal '"ac", "parent", "ap", :name => "cn", :on_delete => :set_default',
+      ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', nil, :set_default).to_dump
+  
+    assert_equal '"ac", "parent", "ap", :name => "cn", :on_update => :set_null, :on_delete => :no_action',
+      ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', :set_null, :no_action).to_dump
+  end
+  
+  if ActiveRecord::Base.connection.class.name == 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter'
+    def test_postgresql_constraints_to_sql
+      assert_equal 'CONSTRAINT "cn" FOREIGN KEY ("ac") REFERENCES "parent" ("ap") ON UPDATE RESTRICT ON DELETE RESTRICT',
+        ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap').to_sql(ActiveRecord::Base.connection)
+
+      assert_equal 'CONSTRAINT "cn" FOREIGN KEY ("ac", "bc") REFERENCES "parent" ("ap", "bp") ON UPDATE RESTRICT ON DELETE RESTRICT',
+        ActiveRecord::ForeignKeyConstraint.new('cn', ['ac', 'bc'], 'parent', ['ap', 'bp']).to_sql(ActiveRecord::Base.connection)
+
+      assert_equal 'CONSTRAINT "cn" FOREIGN KEY ("ac") REFERENCES "parent" ("ap") ON UPDATE CASCADE ON DELETE RESTRICT',
+        ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', :cascade).to_sql(ActiveRecord::Base.connection)
+
+      assert_equal 'CONSTRAINT "cn" FOREIGN KEY ("ac") REFERENCES "parent" ("ap") ON UPDATE RESTRICT ON DELETE SET DEFAULT',
+        ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', nil, :set_default).to_sql(ActiveRecord::Base.connection)
+
+      assert_equal 'CONSTRAINT "cn" FOREIGN KEY ("ac") REFERENCES "parent" ("ap") ON UPDATE SET NULL ON DELETE NO ACTION',
+        ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', :set_null, :no_action).to_sql(ActiveRecord::Base.connection)
+    end
+  else
+    def test_mysql_constraints_to_sql
+      assert_equal 'CONSTRAINT `cn` FOREIGN KEY (`ac`) REFERENCES `parent` (`ap`) ON UPDATE RESTRICT ON DELETE RESTRICT',
+        ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap').to_sql(ActiveRecord::Base.connection)
+      
+      assert_equal 'CONSTRAINT `cn` FOREIGN KEY (`ac`, `bc`) REFERENCES `parent` (`ap`, `bp`) ON UPDATE RESTRICT ON DELETE RESTRICT',
+        ActiveRecord::ForeignKeyConstraint.new('cn', ['ac', 'bc'], 'parent', ['ap', 'bp']).to_sql(ActiveRecord::Base.connection)
+      
+      assert_equal 'CONSTRAINT `cn` FOREIGN KEY (`ac`) REFERENCES `parent` (`ap`) ON UPDATE CASCADE ON DELETE RESTRICT',
+        ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', :cascade).to_sql(ActiveRecord::Base.connection)
+  
+      assert_equal 'CONSTRAINT `cn` FOREIGN KEY (`ac`) REFERENCES `parent` (`ap`) ON UPDATE RESTRICT ON DELETE SET DEFAULT',
+        ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', nil, :set_default).to_sql(ActiveRecord::Base.connection)
+  
+      assert_equal 'CONSTRAINT `cn` FOREIGN KEY (`ac`) REFERENCES `parent` (`ap`) ON UPDATE SET NULL ON DELETE NO ACTION',
+        ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', :set_null, :no_action).to_sql(ActiveRecord::Base.connection)
+    end
+  
+    def test_mysql_columns_from_sql
+      assert_equal ['abc'],               ActiveRecord::Base.connection.class.columns_from_sql('`abc`')
+      assert_equal ['abc', 'def'],        ActiveRecord::Base.connection.class.columns_from_sql('`abc`, `def`')
+      assert_equal ['abc', 'def', 'ghi'], ActiveRecord::Base.connection.class.columns_from_sql('`abc`, `def`, `ghi`')
+    end
+  
+    def test_mysql_constraints_from_sql
+      assert_equal [ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap')], ActiveRecord::Base.connection.class.
+        constraints_from_sql('CONSTRAINT `cn` FOREIGN KEY (`ac`) REFERENCES `parent` (`ap`)')
+      
+      assert_equal [ActiveRecord::ForeignKeyConstraint.new('cn', ['ac', 'bc'], 'parent', ['ap', 'bp'])], ActiveRecord::Base.connection.class.
+        constraints_from_sql('CONSTRAINT `cn` FOREIGN KEY (`ac`, `bc`) REFERENCES `parent` (`ap`, `bp`)')
+      
+      assert_equal [ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', :cascade)], ActiveRecord::Base.connection.class.
+        constraints_from_sql('CONSTRAINT `cn` FOREIGN KEY (`ac`) REFERENCES `parent` (`ap`) ON UPDATE CASCADE')
+  
+      assert_equal [ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', nil, :set_default)], ActiveRecord::Base.connection.class.
+        constraints_from_sql('CONSTRAINT `cn` FOREIGN KEY (`ac`) REFERENCES `parent` (`ap`) ON DELETE SET DEFAULT')
+  
+      assert_equal [ActiveRecord::ForeignKeyConstraint.new('cn', 'ac', 'parent', 'ap', :set_null, :no_action)], ActiveRecord::Base.connection.class.
+        constraints_from_sql('CONSTRAINT `cn` FOREIGN KEY (`ac`) REFERENCES `parent` (`ap`) ON DELETE NO ACTION ON UPDATE SET NULL') # mysql has update and delete kinda around the wrong way
+    end
+  end
+  
+  def test_fkc_define_roundtrip
+    dump = schema do
+      drop_table :child rescue nil
+      drop_table :parent rescue nil
+      create_table "parent" do end
+      create_table "child"  do |t| t.integer :parent_id end
+      add_foreign_key_constraint "child", "parent_id", "parent", "id"
+    end
+    assert_match /create_table "parent"/, dump
+    assert_match /add_foreign_key_constraint "child", "parent_id", "parent", "id"/, dump
+  end
+  
+  def test_remove_fkc
+    dump = schema do
+      drop_table :child rescue nil
+      drop_table :parent rescue nil
+      create_table "parent" do end
+      create_table "child"  do |t| t.integer :parent_id end
+      add_foreign_key_constraint "child", "parent_id", "parent", "id", :name => 'test_fk_name'
+      remove_foreign_key_constraint "child", "test_fk_name"
+    end
+    assert_no_match /add_foreign_key_constraint "child"/, dump
+  end
+  
+  def test_drop_parent_with_child_fkcs
+    dump = schema do
+      drop_table :child rescue nil
+      drop_table :parent rescue nil
+      create_table "parent" do end
+      create_table "child"  do |t| t.integer :parent_id end
+      add_foreign_key_constraint "child", "parent_id", "parent", "id"
+      drop_table :parent
+    end
+    assert_no_match /create_table "parent"/, dump
+    assert_no_match /add_foreign_key_constraint "child", "parent_id", "parent", "id"/, dump
+  end
+  
+  def test_force_table_create
+    dump = schema do
+      drop_table :child rescue nil
+      drop_table :parent rescue nil
+      create_table "parent" do end
+      create_table "child"  do |t| t.integer :parent_id end
+      add_foreign_key_constraint "child", "parent_id", "parent", "id"
+      create_table "parent", :force => true do end
+      create_table "child",  :force => true do |t| t.integer :parent_id end
+      add_foreign_key_constraint "child", "parent_id", "parent", "id"
+      create_table "child",  :force => true do |t| t.integer :parent_id end
+      create_table "parent", :force => true do end
+      add_foreign_key_constraint "child", "parent_id", "parent", "id"
+    end
+    assert_match /create_table "parent"/, dump
+    assert_match /add_foreign_key_constraint "child", "parent_id", "parent", "id"/, dump
+  end
+  
+  def test_fkc_composite_key
+    dump = schema do
+      create_table :parent, :force => true do |t| t.integer :afield end
+      add_index :parent, [:id, :afield], :unique => true
+      create_table :child,  :force => true do |t| t.integer :parent_id, :afield end
+      add_foreign_key_constraint :child, [:parent_id, :afield], :parent, [:id, :afield]
+    end
+    assert_match /add_foreign_key_constraint "child", \["parent_id", "afield"\], "parent", \["id", "afield"\]/, dump
+  end
+  
+  def test_define_actions
+    dump = schema do
+      create_table "parent", :force => true do end
+      create_table "child",  :force => true do |t| t.integer :parent_id end
+      add_foreign_key_constraint "child", "parent_id", "parent", "id", :on_update => :cascade, :on_delete => :set_null
+    end
+    assert_match /add_foreign_key_constraint "child", "parent_id", "parent", "id", :name => "\w+", :on_update => :cascade, :on_delete => :set_null/, dump
+  end
+  
+  def test_no_extraneous_actions_in_dump
+    dump = schema do
+      create_table "parent", :force => true do end
+      create_table "child",  :force => true do |t| t.integer :parent_id end
+      add_foreign_key_constraint "child", "parent_id", "parent", "id", :on_delete => :restrict
+    end
+    assert_no_match /add_foreign_key_constraint "child".*on_update/, dump
+    assert_no_match /add_foreign_key_constraint "child".*on_delete/, dump
+  end
+  
+  def test_explicit_names
+    dump = schema do
+      create_table "parent", :force => true do end
+      create_table "child",  :force => true do |t| t.integer :parent_id end
+      add_foreign_key_constraint "child", "parent_id", "parent", "id", :name => 'test_fk_name'
+    end
+    assert_match /add_foreign_key_constraint "child", "parent_id", "parent", "id", :name => "test_fk_name"/, dump
+  end
+  
+  def test_multiple_parents
+    dump = schema do
+      create_table "parent1", :force => true do end
+      create_table "parent2", :force => true do end
+      create_table "child",  :force => true do |t| t.integer :parent1_id, :parent2_id end
+      add_foreign_key_constraint "child", "parent1_id", "parent1", "id"
+      add_foreign_key_constraint "child", "parent2_id", "parent2", "id"
+    end
+    assert_match /add_foreign_key_constraint "child", "parent1_id", "parent1", "id"/, dump
+    assert_match /add_foreign_key_constraint "child", "parent2_id", "parent2", "id"/, dump
+  end
+  
+  def test_multiple_children
+    dump = schema do
+      create_table "parent", :force => true do end
+      create_table "child1",  :force => true do |t| t.integer :parent_id end
+      create_table "child2",  :force => true do |t| t.integer :parent_id end
+      add_foreign_key_constraint "child1", "parent_id", "parent", "id"
+      add_foreign_key_constraint "child2", "parent_id", "parent", "id"
+    end
+    assert_match /add_foreign_key_constraint "child1", "parent_id", "parent", "id"/, dump
+    assert_match /add_foreign_key_constraint "child2", "parent_id", "parent", "id"/, dump
+  end
+  
+  def test_remove_only_named
+    dump = schema do
+      create_table "parent1", :force => true do end
+      create_table "parent2", :force => true do end
+      create_table "child1",  :force => true do |t| t.integer :parent1_id, :parent2_id end
+      create_table "child2",  :force => true do |t| t.integer :parent1_id, :parent2_id end
+      add_foreign_key_constraint "child1", "parent1_id", "parent1", "id", :name => "test_a"
+      add_foreign_key_constraint "child1", "parent2_id", "parent2", "id", :name => "test_b"
+      add_foreign_key_constraint "child2", "parent1_id", "parent1", "id", :name => "test_c"
+      add_foreign_key_constraint "child2", "parent2_id", "parent2", "id", :name => "test_d"
+      remove_foreign_key_constraint :child1, :test_b
+    end
+    assert_match /add_foreign_key_constraint "child1", "parent1_id", "parent1", "id", :name => "test_a"/, dump
+    assert_no_match /add_foreign_key_constraint "child1", "parent2_id", "parent2", "id", :name => "test_b"/, dump
+    assert_match /add_foreign_key_constraint "child2", "parent1_id", "parent1", "id", :name => "test_c"/, dump
+    assert_match /add_foreign_key_constraint "child2", "parent2_id", "parent2", "id", :name => "test_d"/, dump
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+RAILS_ROOT = File.expand_path("../../..")
+if File.exist?("#{RAILS_ROOT}/config/boot.rb")
+  require "#{RAILS_ROOT}/config/boot.rb"
+else
+  require 'rubygems'
+end
+
+puts "Rails: #{ENV['RAILS_VERSION'] || 'default'}"
+gem 'activesupport', ENV['RAILS_VERSION']
+gem 'activerecord',  ENV['RAILS_VERSION']
+
+require 'test/unit'
+require 'active_support'
+require 'active_support/test_case'
+require 'active_record'
+
+begin
+  require 'ruby-debug'
+  Debugger.start
+rescue LoadError
+  # ruby-debug not installed, no debugging for you
+end
+
+ActiveRecord::Base.configurations = YAML::load(IO.read(File.join(File.dirname(__FILE__), "database.yml")))
+configuration = ActiveRecord::Base.configurations[ENV['RAILS_ENV']]
+raise "use RAILS_ENV=#{ActiveRecord::Base.configurations.keys.sort.join '/'} to test this plugin" unless configuration
+ActiveRecord::Base.establish_connection configuration
+
+require File.expand_path(File.join(File.dirname(__FILE__), '../init')) # load foreign_key_constraints

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification 
+name: foreign_key_saver
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: 
+  segments: 
+  - 2
+  - 0
+  - 0
+  version: 2.0.0
+platform: ruby
+authors: 
+- Will Bryant
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-04-21 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mysql
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mysql2
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: pg
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: |
+  Adds a add_foreign_key_constraint schema method, and extends the schema dump code to output these
+  foreign key constraints.
+  
+  Only MySQL and PostgreSQL are currently supported.
+  
+  
+  Examples
+  ========
+  
+  # adds a constraint on projects.customer_id with parent customers.id
+  add_foreign_key :projects, :customer_id, :customers, :id
+  
+  # adds a constraint on projects(a, b) with parent(a, b) with the default RESTRICT update/delete actions
+  add_foreign_key "child", ["a", "b"], "parent", ["a", "b"]
+  
+  # adds a constraint with the ON UPDATE action set to CASCADE and the ON DELETE action set to SET NULL
+  add_foreign_key 'projects', 'customer_id', 'customers', 'id', :on_update => :cascade, :on_delete => :set_null
+  
+  The following actions are defined:
+    :restrict
+    :no_action
+    :cascade
+    :set_null (aka :nullify)
+    :set_default
+  Note that MySQL does not support :set_default, and also treats :no_action as :restrict.
+  
+  
+  Compatibility
+  =============
+  
+  Supports mysql, mysql2, postgresql.
+  
+  Currently tested against Rails 3.2.13 on 2.0.0p0 and Rails 3.2.13, 3.1.8, 3.0.17, and 2.3.14 on Ruby 1.8.7.
+
+email: will.bryant@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- MIT-LICENSE
+- README
+- Rakefile
+- foreign_key_saver.gemspec
+- init.rb
+- lib/foreign_key_saver.rb
+- lib/foreign_key_saver/foreign_key_saver_patches.rb
+- lib/foreign_key_saver/version.rb
+- test/database.yml
+- test/foreign_key_constraints_test.rb
+- test/test_helper.rb
+homepage: http://github.com/willbryant/foreign_key_saver
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Adds support for foreign key constraints to ActiveRecord schema operations.
+test_files: 
+- test/database.yml
+- test/foreign_key_constraints_test.rb
+- test/test_helper.rb