schema_plus_foreign_keys 0.1.0

data/lib/schema_plus/foreign_keys/middleware/model.rb

@@ -0,0 +1,15 @@
+module SchemaPlus::ForeignKeys
+  module Middleware
+
+    module Model
+      module ResetColumnInformation
+
+        def after(env)
+          env.model.reset_foreign_key_information
+        end
+
+      end
+    end
+
+  end
+end

data/lib/schema_plus/foreign_keys/middleware/mysql.rb

@@ -0,0 +1,20 @@
+module SchemaPlus::ForeignKeys
+  module Middleware
+
+    module Mysql
+      module Migration
+        module DropTable
+
+          def around(env)
+            if (env.options[:force] == :cascade)
+              env.connection.reverse_foreign_keys(env.table_name).each do |foreign_key|
+                env.connection.remove_foreign_key(foreign_key.from_table, name: foreign_key.name)
+              end
+            end
+            yield env
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/foreign_keys/middleware/sql.rb

@@ -0,0 +1,27 @@
+module SchemaPlus::ForeignKeys
+  module Middleware
+    module Sql
+      module Table
+        def after(env)
+          foreign_keys = case ::ActiveRecord.version
+                         when Gem::Version.new("4.2.0") then env.table_definition.foreign_keys
+                         else env.table_definition.foreign_keys.values.tap { |v| v.flatten! }
+                         end
+
+          # create foreign key constraints inline in table definition
+          env.sql.body = ([env.sql.body] + foreign_keys.map(&:to_sql)).join(', ')
+ 
+          # prevents AR >= 4.2.1 from emitting add_foreign_key after the table
+          env.table_definition.foreign_keys.clear
+        end
+
+        module SQLite3
+
+          def before(env)
+            env.connection.execute('PRAGMA FOREIGN_KEYS = ON') if env.table_definition.foreign_keys.any?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/schema_plus/foreign_keys/version.rb

@@ -0,0 +1,5 @@
+module SchemaPlus
+  module ForeignKeys
+    VERSION = "0.1.0"
+  end
+end

data/lib/schema_plus_foreign_keys.rb

@@ -0,0 +1 @@
+require_relative 'schema_plus/foreign_keys'

data/schema_dev.yml

@@ -0,0 +1,9 @@
+ruby:
+    - 2.1.5
+activerecord:
+    - 4.2.0
+    - 4.2.1
+db:
+    - mysql2
+    - sqlite3
+    - postgresql

data/schema_plus_foreign_keys.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'schema_plus/foreign_keys/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "schema_plus_foreign_keys"
+  gem.version       = SchemaPlus::ForeignKeys::VERSION
+  gem.authors       = ["ronen barzel"]
+  gem.email         = ["ronen@barzel.org"]
+  gem.summary       = %q{Extended support for foreign key constraints in ActiveRecord}
+  gem.description   = %q{Extended support for foreign key constraints in ActiveRecord, including: definition as column attribute; deferrable; and SQLite3 support; cleaner dumps; and more!}
+  gem.homepage      = "https://github.com/SchemaPlus/schema_plus_foreign_keys"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files -z`.split("\x0")
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "activerecord", "~> 4.2"
+  gem.add_dependency "schema_plus_core", "~> 0.4"
+  gem.add_dependency "valuable"
+
+  gem.add_development_dependency "bundler", "~> 1.7"
+  gem.add_development_dependency "rake", "~> 10.0"
+  gem.add_development_dependency "rspec", "~> 3.0"
+  gem.add_development_dependency "schema_dev", "~> 3.5"
+  gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "simplecov-gem-profile"
+end

data/spec/deprecation_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+describe 'Deprecations' do
+
+  let(:migration) { ActiveRecord::Migration }
+
+  describe "on add_foreign_key", sqlite3: :skip do
+    before(:each) do
+      define_schema do
+        create_table :posts
+        create_table :comments do |t|
+          t.integer :post_id
+        end
+      end
+      class Comment < ::ActiveRecord::Base ; end
+    end
+
+    it "deprecates 4-argument form" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/4-argument/)
+      migration.add_foreign_key "comments", "post_id", "posts", "id"
+      expect(Comment).to reference(:posts, :id).on(:post_id)
+    end
+
+  end
+
+  describe "on remove_foreign_key", sqlite3: :skip do
+    before(:each) do
+      define_schema do
+        create_table :posts
+        create_table :comments do |t|
+          t.integer :post_id, foreign_key: true
+        end
+      end
+      class Comment < ::ActiveRecord::Base ; end
+    end
+
+    it "deprecates :column_names option" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/column_names/)
+      migration.remove_foreign_key "comments", "posts", column_names: "post_id"
+      Comment.reset_column_information
+      expect(Comment).to_not reference(:posts, :id).on(:post_id)
+    end
+
+    it "deprecates :references_column_names option" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/references_column_names.*primary_key/)
+      migration.remove_foreign_key "comments", "posts", references_column_names: "id"
+      Comment.reset_column_information
+      expect(Comment).to_not reference(:posts, :id).on(:post_id)
+    end
+
+    it "deprecates :references_table_name option" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/references_table_name.*to_table/)
+      migration.remove_foreign_key "comments", references_table_name: "posts"
+      Comment.reset_column_information
+      expect(Comment).to_not reference(:posts, :id).on(:post_id)
+    end
+
+    it "deprecates table-and-name form" do
+      Comment.reset_column_information
+      name = Comment.foreign_keys.first.name
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/name.*name: name/)
+      migration.remove_foreign_key "comments", name
+      Comment.reset_column_information
+      expect(Comment).to_not reference(:posts, :id).on(:post_id)
+    end
+
+    it "deprecates 3-argument form" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/3.*-argument/)
+      migration.remove_foreign_key "comments", "post_id", "posts"
+      Comment.reset_column_information
+      expect(Comment).to_not reference(:posts, :id).on(:post_id)
+    end
+
+    it "deprecates 4-argument form" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/4.*-argument/)
+      migration.remove_foreign_key "comments", "post_id", "posts", "id"
+      Comment.reset_column_information
+      expect(Comment).to_not reference(:posts, :id).on(:post_id)
+    end
+
+    it "raises error for 5 arguments" do
+      expect { migration.remove_foreign_key "zip", "a", "dee", "do", "da" }.to raise_error /Wrong number of arguments.*5/
+    end
+
+  end
+
+  describe "on foreign key definition" do
+    before(:each) do
+      define_schema do
+        create_table :posts
+        create_table :comments do |t|
+          t.integer :post_id, foreign_key: true
+        end
+      end
+      class Comment < ::ActiveRecord::Base ; end
+    end
+
+    let(:definition) {
+      Comment.reset_column_information
+      Comment.foreign_keys.first
+    }
+
+    it "deprecates column_names" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/column_names/)
+      expect(definition.column_names).to eq(["post_id"])
+    end
+
+    it "deprecates references_column_names" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/references_column_names.*primary_key/)
+      expect(definition.references_column_names).to eq(["id"])
+    end
+
+    it "deprecates references_table_name" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/references_table_name.*to_table/)
+      expect(definition.references_table_name).to eq("posts")
+    end
+
+    it "deprecates table_name" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/table_name.*from_table/)
+      expect(definition.table_name).to eq("comments")
+    end
+
+    it "deprecates :set_null" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/set_null.*nullify/)
+      define_schema do
+        create_table :posts
+        create_table :comments do |t|
+          t.integer :post_id, references: :posts, on_delete: :set_null
+        end
+      end
+      expect(definition.on_delete).to eq(:nullify)
+    end
+
+  end
+
+  describe "in table definition" do
+    it "deprecates 3-column form" do
+      expect(ActiveSupport::Deprecation).to receive(:warn).with(/positional arg.*primary_key/)
+      define_schema do
+        create_table :posts, primary_key: :funky
+        create_table :comments do |t|
+          t.integer :post_id
+          t.foreign_key :post_id, :posts, :funky
+        end
+      end
+      expect(migration.foreign_keys("comments").first.primary_key).to eq("funky")
+    end
+
+    it "raises error for 4 arguments" do
+      expect {
+        define_schema do
+          create_table :posts, primary_key: :funky
+          create_table :comments do |t|
+            t.integer :post_id
+            t.foreign_key :post_id, :posts, :funky, :town
+          end
+        end
+      }.to raise_error /wrong number of arguments/i
+    end
+  end
+end

data/spec/foreign_key_definition_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe "Foreign Key definition" do
+
+  let(:definition) {
+    options = {:name => "posts_user_fkey", :column => :user, :primary_key => :id}
+    ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(:posts, :users, options)
+  }
+
+  it "dumps to sql with quoted values" do
+    expect(definition.to_sql).to eq(%Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')})})
+  end
+
+  it "dumps to sql with deferrable values" do
+    options = {:name => "posts_user_fkey", :column => :user, :primary_key => :id, :deferrable => true}
+    deferred_definition = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(:posts, :users, options)
+    expect(deferred_definition.to_sql).to eq(%Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')}) DEFERRABLE})
+  end
+
+  it "dumps to sql with initially deferrable values" do
+    options = {:name => "posts_user_fkey", :column => :user, :primary_key => :id, :deferrable => :initially_deferred}
+    initially_deferred_definition = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(:posts, :users, options)
+    expect(initially_deferred_definition.to_sql).to eq(%Q{CONSTRAINT posts_user_fkey FOREIGN KEY (#{quote_column_name('user')}) REFERENCES #{quote_table_name('users')} (#{quote_column_name('id')}) DEFERRABLE INITIALLY DEFERRED})
+  end
+
+  def quote_table_name(table)
+    ActiveRecord::Base.connection.quote_table_name(table)
+  end
+
+  def quote_column_name(column)
+    ActiveRecord::Base.connection.quote_column_name(column)
+  end
+
+end

data/spec/foreign_key_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+describe "Foreign Key" do
+
+  let(:migration) { ::ActiveRecord::Migration }
+
+  context "created with table" do
+    before(:each) do
+      define_schema do
+        create_table :users, :force => true do |t|
+          t.string :login
+        end
+        create_table :comments, :force => true do |t|
+          t.integer :user_id
+          t.foreign_key :user_id, :users
+        end
+      end
+      class User < ::ActiveRecord::Base ; end
+      class Comment < ::ActiveRecord::Base ; end
+      Comment.reset_column_information
+    end
+
+    it "should report foreign key constraints" do
+      expect(Comment.foreign_keys.collect(&:column).flatten).to eq([ "user_id" ])
+    end
+
+    it "should report reverse foreign key constraints" do
+      expect(User.reverse_foreign_keys.collect(&:column).flatten).to eq([ "user_id" ])
+    end
+
+  end
+
+  context "modification" do
+
+    before(:each) do
+      define_schema do
+        create_table :users, :force => true do |t|
+          t.string :login
+          t.datetime :deleted_at
+        end
+
+        create_table :posts, :force => true do |t|
+          t.text :body
+          t.integer :user_id
+          t.integer :author_id
+        end
+
+        create_table :comments, :force => true do |t|
+          t.text :body
+          t.integer :post_id
+          t.foreign_key :post_id, :posts
+        end
+      end
+      class User < ::ActiveRecord::Base ; end
+      class Post < ::ActiveRecord::Base ; end
+      class Comment < ::ActiveRecord::Base ; end
+      Comment.reset_column_information
+    end
+
+
+    context "works", :sqlite3 => :skip do
+
+      context "when is added", "posts(author_id)" do
+
+        before(:each) do
+          add_foreign_key(:posts, :users, :column => :author_id, :on_update => :cascade, :on_delete => :restrict)
+        end
+
+        it "references users(id)" do
+          expect(Post).to reference(:users, :id).on(:author_id)
+        end
+
+        it "cascades on update" do
+          expect(Post).to reference(:users).on_update(:cascade)
+        end
+
+        it "restricts on delete" do
+          expect(Post).to reference(:users).on_delete(:restrict)
+        end
+
+        it "is available in Post.foreign_keys" do
+          expect(Post.foreign_keys.collect(&:column)).to include('author_id')
+        end
+
+        it "is available in User.reverse_foreign_keys" do
+          expect(User.reverse_foreign_keys.collect(&:column)).to include('author_id')
+        end
+
+      end
+
+      context "when is dropped", "comments(post_id)" do
+
+        let(:foreign_key_name) { fk = Comment.foreign_keys.detect(&its.column == 'post_id') and fk.name }
+
+        before(:each) do
+          remove_foreign_key(:comments, name: foreign_key_name)
+        end
+
+        it "doesn't reference posts(id)" do
+          expect(Comment).not_to reference(:posts).on(:post_id)
+        end
+
+        it "is no longer available in Post.foreign_keys" do
+          expect(Comment.foreign_keys.collect(&:column)).not_to include('post_id')
+        end
+
+        it "is no longer available in User.reverse_foreign_keys" do
+          expect(Post.reverse_foreign_keys.collect(&:column)).not_to include('post_id')
+        end
+
+      end
+
+      context "when drop using hash", "comments(post_id)" do
+
+        let(:foreign_key_name) { fk = Comment.foreign_keys.detect(&its.column == 'post_id') and fk.name }
+
+        it "finds by name" do
+          remove_foreign_key(:comments, name: foreign_key_name)
+          expect(Comment).not_to reference(:posts).on(:post_id)
+        end
+
+        it "finds by column_names" do
+          remove_foreign_key(:comments, column: "post_id", to_table: "posts")
+          expect(Comment).not_to reference(:posts).on(:post_id)
+        end
+      end
+
+      context "when attempt to drop nonexistent foreign key" do
+        it "raises error" do
+          expect{remove_foreign_key(:comments, "posts", column: "nonesuch")}.to raise_error(/no foreign key/i)
+        end
+
+        it "does not error with :if_exists" do
+          expect{remove_foreign_key(:comments, "posts", column: "nonesuch", :if_exists => true)}.to_not raise_error
+        end
+      end
+
+      context "when referencing column and column is removed" do
+
+        let(:foreign_key_name) { Comment.foreign_keys.detect { |definition| definition.column == 'post_id' }.name }
+
+        it "should remove foreign keys" do
+          remove_foreign_key(:comments, name: foreign_key_name)
+          expect(Post.reverse_foreign_keys.collect { |fk| fk.column == 'post_id' && fk.from_table == "comments" }).to be_empty
+        end
+
+      end
+
+      context "when table name is a reserved word" do
+        before(:each) do
+          migration.suppress_messages do
+            migration.create_table :references, :force => true do |t|
+              t.integer :post_id, :foreign_key => false
+            end
+          end
+        end
+
+        it "can add, detect, and remove a foreign key without error" do
+          migration.suppress_messages do
+            expect {
+              migration.add_foreign_key(:references, :posts)
+              foreign_key = migration.foreign_keys(:references).detect{|definition| definition.column == "post_id"}
+              migration.remove_foreign_key(:references, name: foreign_key.name)
+            }.to_not raise_error
+          end
+        end
+      end
+
+    end
+
+    context "raises an exception", :sqlite3 => :only do
+
+      it "when attempting to add" do
+        expect {
+          add_foreign_key(:posts, :users, :column => :author_id, :on_update => :cascade, :on_delete => :restrict)
+        }.to raise_error(NotImplementedError)
+      end
+
+      it "when attempting to remove" do
+        expect {
+          remove_foreign_key(:posts, name: "dummy")
+        }.to raise_error(NotImplementedError)
+      end
+
+    end
+  end
+
+  protected
+  def add_foreign_key(*args)
+    migration.suppress_messages do
+      migration.add_foreign_key(*args)
+    end
+    User.reset_column_information
+    Post.reset_column_information
+    Comment.reset_column_information
+  end
+
+  def remove_foreign_key(*args)
+    migration.suppress_messages do
+      migration.remove_foreign_key(*args)
+    end
+    User.reset_column_information
+    Post.reset_column_information
+    Comment.reset_column_information
+  end
+
+end