schema_plus 2.0.0.pre15 → 2.0.0.pre16

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

@@ -1,15 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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
-      end
-    end
-  end
-end

data/lib/schema_plus/foreign_keys/version.rb

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

data/spec/schema_plus_foreign_keys/foreign_key_definition_spec.rb

@@ -1,34 +0,0 @@
-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/schema_plus_foreign_keys/named_schemas_spec.rb

@@ -1,136 +0,0 @@
-require 'spec_helper'
-
-describe "with multiple schemas" do
-  def connection
-    ActiveRecord::Base.connection
-  end
-
-  before(:all) do
-    newdb = case connection.adapter_name
-            when /^mysql/i then      "CREATE SCHEMA IF NOT EXISTS schema_plus_test2"
-            when /^postgresql/i then "CREATE SCHEMA schema_plus_test2"
-            when /^sqlite/i then     "ATTACH ':memory:' AS schema_plus_test2"
-            end
-    begin
-      ActiveRecord::Base.connection.execute newdb
-    rescue ActiveRecord::StatementInvalid => e
-      raise unless e.message =~ /already exists/
-    end
-
-    class User < ::ActiveRecord::Base ; end
-  end
-
-  before(:each) do
-    define_schema(:auto_create => false) do
-      create_table :users, :force => true do |t|
-        t.string :login
-      end
-    end
-
-    connection.execute 'DROP TABLE IF EXISTS schema_plus_test2.users'
-    connection.execute 'CREATE TABLE schema_plus_test2.users (id ' + case connection.adapter_name
-          when /^mysql/i then      "integer primary key auto_increment"
-          when /^postgresql/i then "serial primary key"
-          when /^sqlite/i then     "integer primary key autoincrement"
-          end + ", login varchar(255))"
-  end
-
-  context "with foreign key in each schema" do
-    before(:each) do
-      class Comment < ::ActiveRecord::Base ; end
-      connection.execute 'DROP TABLE IF EXISTS schema_plus_test2.comments'
-      connection.execute 'CREATE TABLE schema_plus_test2.comments (user_id integer,' + case connection.adapter_name
-            when /^mysql/i then      "foreign key (user_id) references schema_plus_test2.users (id))"
-            when /^postgresql/i then "foreign key (user_id) references schema_plus_test2.users (id))"
-            when /^sqlite/i then     "foreign key (user_id) references users (id))"
-            end
-    end
-
-    around(:each) do |example|
-      begin
-        example.run
-      ensure
-        connection.execute 'DROP TABLE IF EXISTS comments'
-        connection.execute 'DROP TABLE IF EXISTS schema_plus_test2.comments'
-      end
-    end
-
-    it "should not find foreign keys in other schema" do
-      connection.create_table :comments, :force => true do |t|
-        t.integer :user_id, :foreign_key => false
-      end
-      Comment.reset_column_information
-      expect(Comment.foreign_keys.length).to eq(0)
-      User.reset_column_information
-      expect(User.reverse_foreign_keys.length).to eq(0)
-    end
-
-    it "should find foreign keys in this schema" do
-      connection.create_table :comments, :force => true do |t|
-        t.integer :user_id, :foreign_key => true
-      end
-      Comment.reset_column_information
-      expect(Comment.foreign_keys.map(&:column).flatten).to eq(["user_id"])
-      User.reset_column_information
-      expect(User.reverse_foreign_keys.map(&:column).flatten).to eq(["user_id"])
-    end
-
-  end
-
-  context "foreign key migrations" do
-    before(:each) do
-      define_schema do
-        create_table "items", :force => true do |t|
-        end
-        create_table "schema_plus_test2.groups", :force => true do |t|
-        end
-        create_table "schema_plus_test2.members", :force => true do |t|
-          t.integer :item_id, :foreign_key => true unless SchemaDev::Rspec::Helpers.mysql?
-          t.integer :group_id, :foreign_key => { references: "schema_plus_test2.groups" }
-        end
-      end
-      class Group < ::ActiveRecord::Base
-        self.table_name = "schema_plus_test2.groups"
-      end
-      class Item < ::ActiveRecord::Base
-        self.table_name = "items"
-      end
-      class Member < ::ActiveRecord::Base
-        self.table_name = "schema_plus_test2.members"
-      end
-    end
-
-    around(:each) do |example|
-      begin
-        example.run
-      ensure
-        connection.execute 'DROP TABLE IF EXISTS schema_plus_test2.members'
-        connection.execute 'DROP TABLE IF EXISTS schema_plus_test2.groups'
-        connection.execute 'DROP TABLE IF EXISTS items'
-      end
-    end
-
-    it "should find foreign keys" do
-      expect(Member.foreign_keys).not_to be_empty
-    end
-
-    it "should find reverse foreign keys" do
-      expect(Group.reverse_foreign_keys).not_to be_empty
-    end
-
-    it "should reference table in same schema" do
-      expect(Member.foreign_keys.map(&:to_table)).to include "schema_plus_test2.groups"
-    end
-
-    it "should reference table in default schema", :mysql => :skip do
-      expect(Member.foreign_keys.map(&:to_table)).to include "items"
-    end
-
-    it "should include the schema in the constraint name" do
-      expected_names = ["fk_schema_plus_test2_members_group_id"]
-      expected_names << "fk_schema_plus_test2_members_item_id" unless SchemaDev::Rspec::Helpers.mysql?
-      expect(Member.foreign_keys.map(&:name).sort).to match_array(expected_names.sort)
-    end
-  end
-
-end