schema_plus 1.8.9 → 2.0.0.pre1

data/lib/schema_views/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,31 @@
+module SchemaViews
+  module ActiveRecord
+    module ConnectionAdapters
+      module PostgresqlAdapter
+
+        def views(name = nil) #:nodoc:
+          sql = <<-SQL
+            SELECT viewname
+              FROM pg_views
+            WHERE schemaname = ANY (current_schemas(false))
+            AND viewname NOT LIKE 'pg\_%'
+          SQL
+          sql += " AND schemaname != 'postgis'" if adapter_name == 'PostGIS'
+          query(sql, name).map { |row| row[0] }
+        end
+
+        def view_definition(view_name, name = nil) #:nodoc:
+          result = query(<<-SQL, name)
+        SELECT pg_get_viewdef(oid)
+          FROM pg_class
+         WHERE relkind = 'v'
+           AND relname = '#{view_name}'
+          SQL
+          row = result.first
+          row.first.chomp(';') unless row.nil?
+        end
+
+      end
+    end
+  end
+end

data/lib/schema_views/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,18 @@
+module SchemaViews
+  module ActiveRecord
+    module ConnectionAdapters
+      module Sqlite3Adapter
+
+        def views(name = nil)
+          execute("SELECT name FROM sqlite_master WHERE type='view'", name).collect{|row| row["name"]}
+        end
+
+        def view_definition(view_name, name = nil)
+          sql = execute("SELECT sql FROM sqlite_master WHERE type='view' AND name=#{quote(view_name)}", name).collect{|row| row["sql"]}.first
+          sql.sub(/^CREATE VIEW \S* AS\s+/im, '') unless sql.nil?
+        end
+
+      end
+    end
+  end
+end

data/lib/schema_views/middleware.rb

@@ -0,0 +1,47 @@
+module SchemaViews
+  module Middleware
+    def self.insert
+        SchemaMonkey::Middleware::Dumper::Tables.prepend DumpViews
+    end
+    module Mysql
+      def self.insert
+        SchemaMonkey::Middleware::Query::Tables.append FilterOutViews
+      end
+    end
+    module Sqlite3
+      def self.insert
+        SchemaMonkey::Middleware::Query::Tables.append FilterOutViews
+      end
+    end
+  end
+
+  class FilterOutViews < SchemaMonkey::Middleware::Base
+    def call(env)
+      continue env
+      env.tables -= env.connection.views(env.query_name)
+    end
+  end
+
+  class DumpViews < SchemaMonkey::Middleware::Base
+
+    # quacks like a SchemaMonkey Dump::Table
+    class View < KeyStruct[:name, :definition]
+      def assemble(stream)
+        stream.puts("  create_view #{name.inspect}, #{definition.inspect}, :force => true\n")
+      end
+    end
+
+    def call(env)
+      continue env
+
+      re_view_referent = %r{(?:(?i)FROM|JOIN) \S*\b(\S+)\b}
+      env.connection.views.each do |view_name|
+        next if env.dumper.ignored?(view_name)
+        view = View.new(name: view_name, definition: env.connection.view_definition(view_name))
+        env.dump.tables[view.name] = view
+        env.dump.depends(view.name, view.definition.scan(re_view_referent).flatten)
+      end
+    end
+
+  end
+end

data/schema_dev.yml

@@ -1,39 +1,9 @@
 ruby:
-    - jruby
     - 1.9.3
-    - 2.1.3
+    - 2.1.5
 rails:
-    - 3.2
-    - 4.0
-    - 4.1
     - 4.2
 db:
-    - mysql
     - mysql2
     - sqlite3
     - postgresql
-exclude:
-  -
-    rails: 4.0
-    db: mysql
-  -
-    rails: 4.1
-    db: mysql
-  -
-    rails: 4.2
-    db: mysql
-  -
-    ruby: jruby
-    rails: 4.0
-  -
-    ruby: jruby
-    rails: 4.1
-  -
-    ruby: jruby
-    rails: 4.2
-  -
-    ruby: jruby
-    db: sqlite3
-  -
-    ruby: jruby
-    db: postgresql

data/schema_plus.gemspec

@@ -21,15 +21,17 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency("activerecord", ">= 3.2", "<= 4.2.0")
-  s.add_dependency("valuable")
+  s.add_dependency "activerecord", ">= 3.2", "< 4.3"
+  s.add_dependency "valuable"
+  s.add_dependency "schema_monkey", "~> 0.1"
+  s.add_dependency "schema_plus_indexes", "~> 0.1"
+  s.add_dependency "schema_plus_pg_indexes", "~> 0.1"
 
-  s.add_development_dependency("schema_dev", "~> 1.4")
-  s.add_development_dependency("rake")
-  s.add_development_dependency("rspec", "~> 3.0.0")
-  s.add_development_dependency("rdoc")
-  s.add_development_dependency("simplecov")
-  s.add_development_dependency("simplecov-gem-profile")
-  s.add_development_dependency("its-it")
+  s.add_development_dependency "schema_dev", "~> 2.0", ">= 2.0.3"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 3.0.0"
+  s.add_development_dependency "rdoc"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "simplecov-gem-profile"
 end
 

data/spec/foreign_key_definition_spec.rb

@@ -1,10 +1,10 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
 describe "Foreign Key definition" do
 
   let(:definition) {
-    options = {:name => "posts_user_fkey", :column_names => :user, :references_column_names => :id}
-    SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(:posts, :users, options)
+    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
@@ -12,14 +12,14 @@ describe "Foreign Key definition" do
   end
 
   it "dumps to sql with deferrable values" do
-    options = {:name => "posts_user_fkey", :column_names => :user, :references_column_names => :id, :deferrable => true}
-    deferred_definition = SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(:posts, :users, options)
+    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_names => :user, :references_column_names => :id, :deferrable => :initially_deferred}
-    initially_deferred_definition = SchemaPlus::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(:posts, :users, options)
+    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
 

data/spec/foreign_key_spec.rb

@@ -12,7 +12,7 @@ describe "Foreign Key" do
         end
         create_table :comments, :force => true do |t|
           t.integer :user_id
-          t.foreign_key :user_id, :users, :id
+          t.foreign_key :user_id, :users
         end
       end
       class User < ::ActiveRecord::Base ; end
@@ -20,42 +20,40 @@ describe "Foreign Key" do
     end
 
     it "should report foreign key constraints" do
-      expect(Comment.foreign_keys.collect(&:column_names).flatten).to eq([ "user_id" ])
+      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_names).flatten).to eq([ "user_id" ])
+      expect(User.reverse_foreign_keys.collect(&:column).flatten).to eq([ "user_id" ])
     end
 
   end
 
-  if ::ActiveRecord::VERSION::MAJOR.to_i >= 4
-    context "with modifications to SQL generated by upstream visit_TableDefinition" do
-      before(:each) do
-        allow_any_instance_of(ActiveRecord::Base.connection.class.const_get(:SchemaCreation))
-          .to receive(:visit_TableDefinition_without_schema_plus)
-          .and_return('this is unexpected')
-      end
+  context "with modifications to SQL generated by upstream visit_TableDefinition" do
+    before(:each) do
+      allow_any_instance_of(ActiveRecord::Base.connection.class.const_get(:SchemaCreation))
+      .to receive(:visit_TableDefinition_without_schema_plus)
+      .and_return('this is unexpected')
+    end
 
-      it "raises an exception when attempting to create a table" do
-        expect {
-          define_schema(:auto_create => true) 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, :id
-            end
+    it "raises an exception when attempting to create a table" do
+      expect {
+        define_schema(:auto_create => true) do
+          create_table :users, :force => true do |t|
+            t.string :login
           end
-        }.to raise_error(RuntimeError, /Internal Error: Can't find.*Rails internals have changed/)
-      end
+          create_table :comments, :force => true do |t|
+            t.integer :user_id
+            t.foreign_key :user_id, :users
+          end
+        end
+      }.to raise_error(RuntimeError, /Internal Error: Can't find.*Rails internals have changed/)
     end
   end
 
   context "modification" do
 
-    before(:all) do
+    before(:each) do
       define_schema(:auto_create => false) do
         create_table :users, :force => true do |t|
           t.string :login
@@ -71,12 +69,13 @@ describe "Foreign Key" do
         create_table :comments, :force => true do |t|
           t.text :body
           t.integer :post_id
-          t.foreign_key :post_id, :posts, :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
 
 
@@ -85,12 +84,7 @@ describe "Foreign Key" do
       context "when is added", "posts(author_id)" do
 
         before(:each) do
-          add_foreign_key(:posts, :author_id, :users, :id, :on_update => :cascade, :on_delete => :restrict)
-        end
-
-        after(:each) do
-          fk = Post.foreign_keys.detect(&its.column_names == %w[author_id])
-          remove_foreign_key(:posts, fk.name)
+          add_foreign_key(:posts, :users, :column => :author_id, :on_update => :cascade, :on_delete => :restrict)
         end
 
         it "references users(id)" do
@@ -106,25 +100,21 @@ describe "Foreign Key" do
         end
 
         it "is available in Post.foreign_keys" do
-          expect(Post.foreign_keys.collect(&:column_names)).to include(%w[author_id])
+          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_names)).to include(%w[author_id])
+          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_names == %w[post_id]) and fk.name }
+        let(:foreign_key_name) { fk = Comment.foreign_keys.detect(&its.column == 'post_id') and fk.name }
 
         before(:each) do
-          remove_foreign_key(:comments, foreign_key_name)
-        end
-
-        after(:each) do
-          add_foreign_key(:comments, :post_id, :posts, :id)
+          remove_foreign_key(:comments, name: foreign_key_name)
         end
 
         it "doesn't reference posts(id)" do
@@ -132,22 +122,47 @@ describe "Foreign Key" do
         end
 
         it "is no longer available in Post.foreign_keys" do
-          expect(Comment.foreign_keys.collect(&:column_names)).not_to include(%w[post_id])
+          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_names)).not_to include(%w[post_id])
+          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_names == %w[post_id] }.name }
+        let(:foreign_key_name) { Comment.foreign_keys.detect { |definition| definition.column == 'post_id' }.name }
 
         it "should remove foreign keys" do
-          remove_foreign_key(:comments, foreign_key_name)
-          expect(Post.reverse_foreign_keys.collect { |fk| fk.column_names == %w[post_id] && fk.table_name == "comments" }).to be_empty
+          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
@@ -164,9 +179,9 @@ describe "Foreign Key" do
         it "can add, detect, and remove a foreign key without error" do
           migration.suppress_messages do
             expect {
-              migration.add_foreign_key(:references, :post_id, :posts, :id)
-              foreign_key = migration.foreign_keys(:references).detect{|definition| definition.column_names == ["post_id"]}
-              migration.remove_foreign_key(:references, foreign_key.name)
+              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
@@ -178,13 +193,13 @@ describe "Foreign Key" do
 
       it "when attempting to add" do
         expect {
-          add_foreign_key(:posts, :author_id, :users, :id, :on_update => :cascade, :on_delete => :restrict)
+          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, "dummy")
+          remove_foreign_key(:posts, name: "dummy")
         }.to raise_error(NotImplementedError)
       end
 

data/spec/migration_spec.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'spec_helper'
 
 describe ActiveRecord::Migration do
 
@@ -18,7 +18,7 @@ describe ActiveRecord::Migration do
         t.string :content
         t.integer :user
         t.integer :user_id
-        t.foreign_key :user_id, :users, :id
+        t.foreign_key :user_id, :users, :primary_key => :id
       end
 
       create_table :posts, :force => true do |t|
@@ -172,27 +172,6 @@ describe ActiveRecord::Migration do
       expect(@model).to reference(@model.table_name, :id).on(:parent_id)
     end
 
-    it "should create an index if specified on column" do
-      recreate_table(@model) do |t|
-        t.integer :state, :index => true
-      end
-      expect(@model).to have_index.on(:state)
-    end
-
-    it "should create a unique index if specified on column" do
-      recreate_table(@model) do |t|
-        t.integer :state, :index => { :unique => true }
-      end
-      expect(@model).to have_unique_index.on(:state)
-    end
-
-    it "should create a unique index if specified on column using shorthand" do
-      recreate_table(@model) do |t|
-        t.integer :state, :index => :unique
-      end
-      expect(@model).to have_unique_index.on(:state)
-    end
-
     [:references, :belongs_to].each do |reftype|
 
       context "when define #{reftype}" do
@@ -229,7 +208,7 @@ describe ActiveRecord::Migration do
         it "should create a two-column index if polymophic and index requested" do
           create_reference(reftype, :post, :polymorphic => true, :index => true)
           expect(@model).to have_index.on([:post_id, :post_type])
-        end unless ::ActiveRecord::VERSION::MAJOR.to_i < 4
+        end
 
         protected
 
@@ -242,49 +221,6 @@ describe ActiveRecord::Migration do
       end
     end
 
-    it "should pass index length option properly", :mysql => :only do
-      recreate_table(@model) do |t|
-        t.string :foo
-        t.string :bar, :index => { :with => :foo, :length => { :foo => 8, :bar => 12 }}
-      end
-      index = @model.indexes.first
-      expect(Hash[index.columns.zip(index.lengths.map(&:to_i))]).to eq({ "foo" => 8, "bar" => 12})
-    end
-
-    it "should create an index if specified explicitly" do
-      recreate_table(@model) do |t|
-        t.integer :state
-        t.index :state
-      end
-      expect(@model).to have_index.on(:state)
-    end
-
-    it "should create a unique index if specified explicitly" do
-      recreate_table(@model) do |t|
-        t.integer :state
-        t.index :state, :unique => true
-      end
-      expect(@model).to have_unique_index.on(:state)
-    end
-
-    it "should create a multiple-column index if specified" do
-      recreate_table(@model) do |t|
-        t.integer :city
-        t.integer :state,       :index => { :with => :city }
-      end
-      expect(@model).to have_index.on([:state, :city])
-    end
-
-    it "should create the index without modifying the input hash" do
-      hash = { :with => :foo, :length => { :foo => 8, :bar => 12 }}
-      hash_original = hash.dup
-      recreate_table(@model) do |t|
-        t.string :foo
-        t.string :bar, :index => hash
-      end
-      expect(hash).to eq(hash_original)
-    end
-
     it "should auto-index foreign keys only" do
       recreate_table(@model) do |t|
         t.integer :user_id
@@ -323,7 +259,7 @@ describe ActiveRecord::Migration do
       end
     end
 
-    actions = [:cascade, :restrict, :set_null, :set_default, :no_action]
+    actions = [:cascade, :restrict, :nullify, :set_default, :no_action]
 
     actions.each do |action|
       if action == :set_default
@@ -419,18 +355,18 @@ describe ActiveRecord::Migration do
     it "should override on_update action per column" do
       with_fk_config(:on_update => :cascade) do
         recreate_table @model, :foreign_keys => {:on_update => :restrict} do |t|
-          t.integer :user_id, :foreign_key => { :on_update => :set_null }
+          t.integer :user_id, :foreign_key => { :on_update => :nullify }
         end
-        expect(@model).to reference.on(:user_id).on_update(:set_null)
+        expect(@model).to reference.on(:user_id).on_update(:nullify)
       end
     end
 
     it "should override on_delete action per column" do
       with_fk_config(:on_delete => :cascade) do
         recreate_table @model, :foreign_keys => {:on_delete => :restrict} do |t|
-          t.integer :user_id, :foreign_key => { :on_delete => :set_null }
+          t.integer :user_id, :foreign_key => { :on_delete => :nullify }
         end
-        expect(@model).to reference.on(:user_id).on_delete(:set_null)
+        expect(@model).to reference.on(:user_id).on_delete(:nullify)
       end
     end
 
@@ -477,13 +413,6 @@ describe ActiveRecord::Migration do
     [false, true].each do |bulk|
       suffix = bulk ? ' with :bulk option' : ""
 
-      it "should create an index if specified on column"+suffix do
-        change_table(@model, :bulk => bulk) do |t|
-          t.integer :state, :index => true
-        end
-        expect(@model).to have_index.on(:state)
-      end
-
       it "should create a foreign key constraint"+suffix, :sqlite3 => :skip do
         change_table(@model, :bulk => bulk) do |t|
           t.integer :user_id
@@ -508,7 +437,7 @@ describe ActiveRecord::Migration do
           Comment.reset_column_information
           expect(Comment).not_to reference(:users, :id).on(:user_id)
         end
-      end if ActiveRecord::VERSION::MAJOR >= 4
+      end
 
       it "should create a foreign key constraint using :references"+suffix, :sqlite3 => :skip do
         change_table(@model, :bulk => bulk) do |t|
@@ -542,12 +471,6 @@ describe ActiveRecord::Migration do
       @model = Comment
     end
 
-    it "should create an index" do
-      add_column(:slug, :string, :index => true) do
-        expect(@model).to have_index.on(:slug)
-      end
-    end
-
     it "should create foreign key" do
       add_column(:post_id, :integer) do
         expect(@model).to reference(:posts, :id).on(:post_id)
@@ -596,31 +519,6 @@ describe ActiveRecord::Migration do
       end
     end
 
-    it "should create an index if specified" do
-      add_column(:post_id, :integer, :index => true) do
-        expect(@model).to have_index.on(:post_id)
-      end
-    end
-
-    it "should create a unique index if specified" do
-      add_column(:post_id, :integer, :index => { :unique => true }) do
-        expect(@model).to have_unique_index.on(:post_id)
-      end
-    end
-
-    it "should create a unique index if specified by shorthand" do
-      add_column(:post_id, :integer, :index => :unique) do
-        expect(@model).to have_unique_index.on(:post_id)
-      end
-    end
-
-    it "should allow custom name for index" do
-      index_name = 'comments_post_id_unique_index'
-      add_column(:post_id, :integer, :index => { :unique => true, :name => index_name }) do
-        expect(@model).to have_unique_index(:name => index_name).on(:post_id)
-      end
-    end
-
     it "should auto-index if specified in global options" do
       SchemaPlus.config.foreign_keys.auto_index = true
       add_column(:post_id, :integer) do
@@ -665,8 +563,8 @@ describe ActiveRecord::Migration do
     it "should allow to overwrite default actions" do
       SchemaPlus.config.foreign_keys.on_delete = :cascade
       SchemaPlus.config.foreign_keys.on_update = :restrict
-      add_column(:post_id, :integer, :foreign_key => { :on_update => :set_null, :on_delete => :set_null}) do
-        expect(@model).to reference.on(:post_id).on_delete(:set_null).on_update(:set_null)
+      add_column(:post_id, :integer, :foreign_key => { :on_update => :nullify, :on_delete => :nullify}) do
+        expect(@model).to reference.on(:post_id).on_delete(:nullify).on_update(:nullify)
       end
       SchemaPlus.config.foreign_keys.on_delete = nil
     end
@@ -685,96 +583,78 @@ describe ActiveRecord::Migration do
   end
 
 
-  context "when changing a column" do
+  context "when column is changed", :sqlite3 => :skip do
 
     before(:each) do
       @model = Comment
     end
 
-    context "with foreign keys", :sqlite3 => :skip do
-
-      it "should create foreign key" do
-        change_column :user, :string, :foreign_key => { :references => [:users, :login] }
-        expect(@model).to reference(:users, :login).on(:user)
-      end
+    it "should create foreign key" do
+      change_column :user, :string, :foreign_key => { :references => [:users, :login] }
+      expect(@model).to reference(:users, :login).on(:user)
+    end
 
-      context "and initially references to users table" do
+    context "and initially references to users table" do
 
-        before(:each) do
-          recreate_table @model do |t|
-            t.integer :user_id
-          end
+      before(:each) do
+        recreate_table @model do |t|
+          t.integer :user_id
         end
+      end
 
-        it "should have foreign key" do
-          expect(@model).to reference(:users)
-        end
+      it "should have foreign key" do
+        expect(@model).to reference(:users)
+      end
 
-        it "should drop foreign key if it is no longer valid" do
-          change_column :user_id, :integer, :foreign_key => { :references => :members }
-          expect(@model).not_to reference(:users)
-        end
+      it "should drop foreign key if it is no longer valid" do
+        change_column :user_id, :integer, :foreign_key => { :references => :members }
+        expect(@model).not_to reference(:users)
+      end
 
-        it "should drop foreign key if requested to do so" do
-          change_column :user_id, :integer, :foreign_key => { :references => nil }
-          expect(@model).not_to reference(:users)
-        end
+      it "should drop foreign key if requested to do so" do
+        change_column :user_id, :integer, :foreign_key => { :references => nil }
+        expect(@model).not_to reference(:users)
+      end
 
-        it "should remove auto-created index if foreign key is removed" do
-          expect(@model).to have_index.on(:user_id)  # sanity check that index was auto-created
-          change_column :user_id, :integer, :foreign_key => { :references => nil }
-          expect(@model).not_to have_index.on(:user_id)
-        end
+      it "should remove auto-created index if foreign key is removed" do
+        expect(@model).to have_index.on(:user_id)  # sanity check that index was auto-created
+        change_column :user_id, :integer, :foreign_key => { :references => nil }
+        expect(@model).not_to have_index.on(:user_id)
+      end
 
-        it "should reference pointed table afterwards if new one is created" do
-          change_column :user_id, :integer, :foreign_key => { :references => :members }
-          expect(@model).to reference(:members)
-        end
+      it "should reference pointed table afterwards if new one is created" do
+        change_column :user_id, :integer, :foreign_key => { :references => :members }
+        expect(@model).to reference(:members)
+      end
 
-        it "should maintain foreign key if it's unaffected by change" do
+      it "should maintain foreign key if it's unaffected by change" do
+        change_column :user_id, :integer, :default => 0
+        expect(@model).to reference(:users)
+      end
+
+      it "should maintain foreign key if it's unaffected by change, even if auto_index is off" do
+        with_fk_config(:auto_create => false) do
           change_column :user_id, :integer, :default => 0
           expect(@model).to reference(:users)
         end
-
-        it "should maintain foreign key if it's unaffected by change, even if auto_index is off" do
-          with_fk_config(:auto_create => false) do
-            change_column :user_id, :integer, :default => 0
-            expect(@model).to reference(:users)
-          end
-        end
-
       end
 
-      context "if column defined without foreign key but with index" do
-        before(:each) do
-          recreate_table @model do |t|
-            t.integer :user_id, :foreign_key => false, :index => true
-          end
-        end
-
-        it "should create the index" do
-          expect(@model).to have_index.on(:user_id)
-        end
-
-        it "adding foreign key should not fail due to attempt to auto-create existing index" do
-          expect { change_column :user_id, :integer, :foreign_key => true }.to_not raise_error
-        end
-      end
     end
 
-    context "without foreign keys" do
-
-      it "doesn't auto-add foreign keys" do
+    context "if column defined without foreign key but with index" do
+      before(:each) do
         recreate_table @model do |t|
-          t.integer :user_id, :foreign_key => false
-          t.string :other_column
-        end
-        with_fk_auto_create do
-          change_column :other_column, :text
+          t.integer :user_id, :foreign_key => false, :index => true
         end
-        expect(@model).to_not reference(:users)
       end
 
+      it "should create the index" do
+        expect(@model).to have_index.on(:user_id)
+      end
+
+      it "adding foreign key should not fail due to attempt to auto-create existing index" do
+        expect { change_column :user_id, :integer, :foreign_key => true }.to_not raise_error
+      end
     end
 
     protected
@@ -788,7 +668,6 @@ describe ActiveRecord::Migration do
 
   end
 
-
   context "when column is removed", :sqlite3 => :skip do
     before(:each) do
       @model = Comment
@@ -833,21 +712,6 @@ describe ActiveRecord::Migration do
       end
     end
 
-    around(:each) do |example|
-      begin
-        example.run
-      ensure
-        ActiveRecord::Migration.suppress_messages do
-          ActiveRecord::Migration.rename_table :newname, :comments
-        end
-      end
-    end
-
-    it "should rename rails-named indexes" do
-      index = ActiveRecord::Base.connection.indexes(:newname).find(&its.columns == ['xyz'])
-      expect(index.name).to match(/^index_newname_on/)
-    end
-
     it "should rename fk indexes" do
       index = ActiveRecord::Base.connection.indexes(:newname).find(&its.columns == ['user_id'])
       expect(index.name).to match(/^fk__newname_/)
@@ -873,15 +737,6 @@ describe ActiveRecord::Migration do
       end
     end
 
-    around(:each) do |example|
-      begin
-        example.run
-      ensure
-        ActiveRecord::Migration.suppress_messages do
-          ActiveRecord::Migration.rename_table :newname, :comments
-        end
-      end
-    end
     it "should rename foreign key constraints" do
       names = ActiveRecord::Base.connection.foreign_keys(:newname).map(&:name)
       expect(names.grep(/newname/)).to eq(names)