declare_schema 0.2.0 → 0.4.0

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/generators/declare_schema/migration/migrator.rb

@@ -45,14 +45,14 @@ module Generators
           false # no single-column primary key
         end
 
-        def index_specs_with_primary_key
+        def index_definitions_with_primary_key
           [
-            ::DeclareSchema::Model::IndexSpec.new(self, foreign_keys, unique: true, name: "PRIMARY_KEY"),
-            ::DeclareSchema::Model::IndexSpec.new(self, foreign_keys.last) # not unique by itself; combines with primary key to be unique
+            ::DeclareSchema::Model::IndexDefinition.new(self, foreign_keys, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME),
+            ::DeclareSchema::Model::IndexDefinition.new(self, foreign_keys.last) # not unique by itself; combines with primary key to be unique
           ]
         end
 
-        alias_method :index_specs, :index_specs_with_primary_key
+        alias_method :index_definitions, :index_definitions_with_primary_key
 
         def ignore_indexes
           []
@@ -60,8 +60,8 @@ module Generators
 
         def constraint_specs
           [
-            ::DeclareSchema::Model::ForeignKeySpec.new(self, foreign_keys.first, parent_table: foreign_key_classes.first.table_name, constraint_name: "#{join_table}_FK1", dependent: :delete),
-            ::DeclareSchema::Model::ForeignKeySpec.new(self, foreign_keys.last,  parent_table: foreign_key_classes.last.table_name,  constraint_name: "#{join_table}_FK2", dependent: :delete)
+            ::DeclareSchema::Model::ForeignKeyDefinition.new(self, foreign_keys.first, parent_table: foreign_key_classes.first.table_name, constraint_name: "#{join_table}_FK1", dependent: :delete),
+            ::DeclareSchema::Model::ForeignKeyDefinition.new(self, foreign_keys.last, parent_table: foreign_key_classes.last.table_name, constraint_name: "#{join_table}_FK2", dependent: :delete)
           ]
         end
       end
@@ -69,12 +69,14 @@ module Generators
       class Migrator
         class Error < RuntimeError; end
 
-        @ignore_models = []
-        @ignore_tables = []
-        @active_record_class = ActiveRecord::Base
+        @ignore_models                    = []
+        @ignore_tables                    = []
+        @before_generating_migration_callback = nil
+        @active_record_class              = ActiveRecord::Base
 
         class << self
           attr_accessor :ignore_models, :ignore_tables, :disable_indexing, :disable_constraints, :active_record_class
+          attr_reader :before_generating_migration_callback
 
           def active_record_class
             @active_record_class.is_a?(Class) or @active_record_class = @active_record_class.to_s.constantize
@@ -110,6 +112,11 @@ module Generators
           def native_types
             @native_types ||= fix_native_types(connection.native_database_types)
           end
+
+          def before_generating_migration(&block)
+            block or raise ArgumentError, 'A block is required when setting the before_generating_migration callback'
+            @before_generating_migration_callback = block
+          end
         end
 
         def initialize(ambiguity_resolver = {})
@@ -120,14 +127,12 @@ module Generators
 
         attr_accessor :renames
 
-        # TODO: Add an application callback (maybe an initializer in a special group?) that
-        # the application can use to load other models that live in the database, to support DeclareSchema migrations
-        # for them.
         def load_rails_models
           ActiveRecord::Migration.verbose = false
 
           Rails.application.eager_load!
           Rails::Engine.subclasses.each(&:eager_load!)
+          self.class.before_generating_migration_callback&.call
         end
 
         # Returns an array of model classes that *directly* extend
@@ -336,7 +341,7 @@ module Generators
         end
 
         def create_indexes(model)
-          model.index_specs.map { |i| i.to_add_statement(model.table_name) }
+          model.index_definitions.map { |i| i.to_add_statement(model.table_name) }
         end
 
         def create_constraints(model)
@@ -408,7 +413,7 @@ module Generators
             col_name = old_names[c] || c
             col = db_columns[col_name]
             spec = model.field_specs[c]
-            if spec.different_to?(col) # TODO: DRY this up to a diff function that returns the differences. It's different if it has differences. -Colin
+            if spec.different_to?(col) # TODO: TECH-4814 DRY this up to a diff function that returns the differences. It's different if it has differences. -Colin
               change_spec = fk_field_options(model, c)
               change_spec[:limit]     ||= spec.limit   if (spec.sql_type != :text ||
                                                          ::DeclareSchema::Model::FieldSpec.mysql_text_limits?) &&
@@ -444,8 +449,8 @@ module Generators
           return [[], []] if Migrator.disable_constraints
 
           new_table_name = model.table_name
-          existing_indexes = ::DeclareSchema::Model::IndexSpec.for_model(model, old_table_name)
-          model_indexes_with_equivalents = model.index_specs_with_primary_key
+          existing_indexes = ::DeclareSchema::Model::IndexDefinition.for_model(model, old_table_name)
+          model_indexes_with_equivalents = model.index_definitions_with_primary_key
           model_indexes = model_indexes_with_equivalents.map do |i|
             if i.explicit_name.nil?
               if ex = existing_indexes.find { |e| i != e && e.equivalent?(i) }
@@ -453,20 +458,20 @@ module Generators
               end
             end || i
           end
-          existing_has_primary_key = existing_indexes.any? { |i| i.name == 'PRIMARY_KEY' }
-          model_has_primary_key    = model_indexes.any?    { |i| i.name == 'PRIMARY_KEY' }
+          existing_has_primary_key = existing_indexes.any? { |i| i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME }
+          model_has_primary_key    = model_indexes.any?    { |i| i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME }
 
           add_indexes_init = model_indexes - existing_indexes
           drop_indexes_init = existing_indexes - model_indexes
           undo_add_indexes = []
           undo_drop_indexes = []
           add_indexes = add_indexes_init.map do |i|
-            undo_add_indexes << drop_index(old_table_name, i.name) unless i.name == "PRIMARY_KEY"
+            undo_add_indexes << drop_index(old_table_name, i.name) unless i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME
             i.to_add_statement(new_table_name, existing_has_primary_key)
           end
           drop_indexes = drop_indexes_init.map do |i|
             undo_drop_indexes << i.to_add_statement(old_table_name, model_has_primary_key)
-            drop_index(new_table_name, i.name) unless i.name == "PRIMARY_KEY"
+            drop_index(new_table_name, i.name) unless i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME
           end.compact
 
           # the order is important here - adding a :unique, for instance needs to remove then add
@@ -484,7 +489,7 @@ module Generators
           return [[], []] if Migrator.disable_indexing
 
           new_table_name = model.table_name
-          existing_fks = ::DeclareSchema::Model::ForeignKeySpec.for_model(model, old_table_name)
+          existing_fks = ::DeclareSchema::Model::ForeignKeyDefinition.for_model(model, old_table_name)
           model_fks = model.constraint_specs
           add_fks = model_fks - existing_fks
           drop_fks = existing_fks - model_fks

data/lib/generators/declare_schema/migration/templates/migration.rb.erb

@@ -1,4 +1,4 @@
-class <%= @migration_class_name %> < ActiveRecord::Migration<%= ('[4.2]' if Rails::VERSION::MAJOR >= 5) %>
+class <%= @migration_class_name %> < (Rails::VERSION::MAJOR >= 5 ? ActiveRecord::Migration[4.2] : ActiveRecord::Migration)
   def self.up
     <%= @up %>
   end

data/spec/lib/declare_schema/api_spec.rb

@@ -10,14 +10,14 @@ RSpec.describe 'DeclareSchema API' do
 
   describe 'example models' do
     it 'generates a model' do
-      expect(system("bundle exec rails generate declare_schema:model advert title:string body:text")).to be_truthy
+      generate_model 'advert', 'title:string', 'body:text'
 
       # The above will generate the test, fixture and a model file like this:
       # model_declaration = Rails::Generators.invoke('declare_schema:model', ['advert2', 'title:string', 'body:text'])
       # expect(model_declaration.first).to eq([["Advert"], nil, "app/models/advert.rb", nil,
       #                                       [["AdvertTest"], "test/models/advert_test.rb", nil, "test/fixtures/adverts.yml"]])
 
-      expect(File.read("#{TESTAPP_PATH}/app/models/advert.rb")).to eq(<<~EOS)
+      expect_model_definition_to_eq('advert', <<~EOS)
         class Advert < #{active_record_base_class}
 
           fields do
@@ -27,7 +27,8 @@ RSpec.describe 'DeclareSchema API' do
 
         end
       EOS
-      system("rm -rf #{TESTAPP_PATH}/app/models/advert2.rb #{TESTAPP_PATH}/test/models/advert2.rb #{TESTAPP_PATH}/test/fixtures/advert2.rb")
+
+      clean_up_model('advert2')
 
       # The migration generator uses this information to create a migration.
       # The following creates and runs the migration:
@@ -36,13 +37,11 @@ RSpec.describe 'DeclareSchema API' do
 
       # We're now ready to start demonstrating the API
 
-      Rails.application.config.autoload_paths += ["#{TESTAPP_PATH}/app/models"]
-
-      $LOAD_PATH << "#{TESTAPP_PATH}/app/models"
+      load_models
 
       unless Rails::VERSION::MAJOR >= 6
         # TODO: get this to work on Travis for Rails 6
-        Rails::Generators.invoke('declare_schema:migration', %w[-n -m])
+        generate_migrations '-n', '-m'
       end
 
       require 'advert'

data/spec/lib/declare_schema/generator_spec.rb

@@ -6,22 +6,20 @@ RSpec.describe 'DeclareSchema Migration Generator' do
   end
 
   it "generates nested models" do
-    Rails::Generators.invoke('declare_schema:model', %w[alpha/beta one:string two:integer])
+    generate_model 'alpha/beta', 'one:string', 'two:integer'
 
-    expect(File.exist?('app/models/alpha/beta.rb')).to be_truthy
-
-    expect(File.read('app/models/alpha/beta.rb')).to eq(<<~EOS)
+    expect_model_definition_to_eq('alpha/beta', <<~EOS)
       class Alpha::Beta < #{active_record_base_class}
-  
+
         fields do
           one :string, limit: 255
           two :integer
         end
-  
+
       end
     EOS
 
-    expect(File.read('app/models/alpha.rb')).to eq(<<~EOS)
+    expect_model_definition_to_eq('alpha', <<~EOS)
       module Alpha
         def self.table_name_prefix
           'alpha_'
@@ -29,9 +27,9 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     EOS
 
-    expect(File.read('test/models/alpha/beta_test.rb')).to eq(<<~EOS)
+    expect_test_definition_to_eq('alpha/beta', <<~EOS)
       require 'test_helper'
-      
+
       class Alpha::BetaTest < ActiveSupport::TestCase
         # test "the truth" do
         #   assert true
@@ -39,7 +37,50 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     EOS
 
-    expect(File.exist?('test/fixtures/alpha/beta.yml')).to be_truthy
+    case Rails::VERSION::MAJOR
+    when 4
+      expect_test_fixture_to_eq('alpha/beta', <<~EOS)
+        # Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+
+        # This model initially had no columns defined.  If you add columns to the
+        # model remove the '{}' from the fixture names and add the columns immediately
+        # below each fixture, per the syntax in the comments below
+        #
+        one: {}
+        # column: value
+        #
+        two: {}
+        #  column: value
+      EOS
+    when 5
+      expect_test_fixture_to_eq('alpha/beta', <<~EOS)
+        # Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+
+        # This model initially had no columns defined. If you add columns to the
+        # model remove the '{}' from the fixture names and add the columns immediately
+        # below each fixture, per the syntax in the comments below
+        #
+        one: {}
+        # column: value
+        #
+        two: {}
+        # column: value
+      EOS
+    when 6
+      expect_test_fixture_to_eq('alpha/beta', <<~EOS)
+        # Read about fixtures at https://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+
+        # This model initially had no columns defined. If you add columns to the
+        # model remove the '{}' from the fixture names and add the columns immediately
+        # below each fixture, per the syntax in the comments below
+        #
+        one: {}
+        # column: value
+        #
+        two: {}
+        # column: value
+      EOS
+    end
 
     $LOAD_PATH << "#{TESTAPP_PATH}/app/models"
 

data/spec/lib/declare_schema/interactive_primary_key_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe 'DeclareSchema Migration Generator interactive primary key' do
       self.primary_key = "foo_id"
     end
 
-    Rails::Generators.invoke('declare_schema:migration', %w[-n -m])
+    generate_migrations '-n', '-m'
     expect(Foo.primary_key).to eq('foo_id')
 
     ### migrate from
@@ -24,28 +24,30 @@ RSpec.describe 'DeclareSchema Migration Generator interactive primary key' do
     end
 
     puts "\n\e[45m Please enter 'id' (no quotes) at the next prompt \e[0m"
-    Rails::Generators.invoke('declare_schema:migration', %w[-n -m])
+    generate_migrations '-n', '-m'
     expect(Foo.primary_key).to eq('id')
 
     nuke_model_class(Foo)
 
     ### migrate to
 
-    # rename to custom primary_key
-    class Foo < ActiveRecord::Base
-      fields do
+    if Rails::VERSION::MAJOR >= 5
+      # rename to custom primary_key
+      class Foo < ActiveRecord::Base
+        fields do
+        end
+        self.primary_key = "foo_id"
       end
-      self.primary_key = "foo_id"
-    end
 
-    puts "\n\e[45m Please enter 'drop id' (no quotes) at the next prompt \e[0m"
-    Rails::Generators.invoke('declare_schema:migration', %w[-n -m])
-    expect(Foo.primary_key).to eq('foo_id')
+      puts "\n\e[45m Please enter 'drop id' (no quotes) at the next prompt \e[0m"
+      generate_migrations '-n', '-m'
+      expect(Foo.primary_key).to eq('foo_id')
 
-    ### ensure it doesn't cause further migrations
+      ### ensure it doesn't cause further migrations
 
-    # check no further migrations
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq("")
+      # check no further migrations
+      up = Generators::DeclareSchema::Migration::Migrator.run.first
+      expect(up).to eq("")
+    end
   end
 end

data/spec/lib/declare_schema/migration_generator_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'rails'
+
 RSpec.describe 'DeclareSchema Migration Generator' do
   before do
     load File.expand_path('prepare_testapp.rb', __dir__)
@@ -9,14 +11,12 @@ RSpec.describe 'DeclareSchema Migration Generator' do
   it 'generates migrations' do
     ## The migration generator -- introduction
 
-    up_down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up_down).to eq(["", ""])
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to migrate_up("").and migrate_down("")
 
     class Advert < ActiveRecord::Base
     end
 
-    up_down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up_down).to eq(["", ""])
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to migrate_up("").and migrate_down("")
 
     Generators::DeclareSchema::Migration::Migrator.ignore_tables = ["green_fishes"]
 
@@ -28,13 +28,17 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         name :string, limit: 255, null: true
       end
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq(<<~EOS.strip)
-      create_table :adverts, id: :bigint do |t|
-        t.string :name, limit: 255
-      end
-    EOS
-    expect(down).to eq("drop_table :adverts")
+
+    up, _ = Generators::DeclareSchema::Migration::Migrator.run.tap do |migrations|
+      expect(migrations).to(
+        migrate_up(<<~EOS.strip)
+          create_table :adverts, id: :bigint do |t|
+            t.string :name, limit: 255
+          end
+        EOS
+        .and migrate_down("drop_table :adverts")
+      )
+    end
 
     ActiveRecord::Migration.class_eval(up)
     expect(Advert.columns.map(&:name)).to eq(["id", "name"])
@@ -46,19 +50,20 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         published_at :datetime, null: true
       end
     end
-    up, down = migrate
-    expect(up).to eq(<<~EOS.strip)
-      add_column :adverts, :body, :text
-      add_column :adverts, :published_at, :datetime
 
-      add_index :adverts, [:id], unique: true, name: 'PRIMARY_KEY'
-    EOS
-    # TODO: ^ add_index should not be there?
+    Advert.connection.schema_cache.clear!
+    Advert.reset_column_information
 
-    expect(down).to eq(<<~EOS.strip)
-      remove_column :adverts, :body
-      remove_column :adverts, :published_at
-    EOS
+    expect(migrate).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :body, :text
+        add_column :adverts, :published_at, :datetime
+      EOS
+      .and migrate_down(<<~EOS.strip)
+        remove_column :adverts, :body
+        remove_column :adverts, :published_at
+      EOS
+    )
 
     Advert.field_specs.clear # not normally needed
     class Advert < ActiveRecord::Base
@@ -68,9 +73,11 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up, down = migrate
-    expect(up).to eq("remove_column :adverts, :published_at")
-    expect(down).to eq("add_column :adverts, :published_at, :datetime")
+    expect(migrate).to(
+      migrate_up("remove_column :adverts, :published_at").and(
+        migrate_down("add_column :adverts, :published_at, :datetime")
+      )
+    )
 
     nuke_model_class(Advert)
     class Advert < ActiveRecord::Base
@@ -80,20 +87,22 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq(<<~EOS.strip)
-      add_column :adverts, :title, :string, limit: 255
-      remove_column :adverts, :name
-    EOS
-
-    expect(down).to eq(<<~EOS.strip)
-      remove_column :adverts, :title
-      add_column :adverts, :name, :string, limit: 255
-    EOS
-
-    up, down = Generators::DeclareSchema::Migration::Migrator.run(adverts: { name: :title })
-    expect(up).to eq("rename_column :adverts, :name, :title")
-    expect(down).to eq("rename_column :adverts, :title, :name")
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :title, :string, limit: 255
+        remove_column :adverts, :name
+      EOS
+      .and migrate_down(<<~EOS.strip)
+        remove_column :adverts, :title
+        add_column :adverts, :name, :string, limit: 255
+      EOS
+    )
+
+    expect(Generators::DeclareSchema::Migration::Migrator.run(adverts: { name: :title })).to(
+      migrate_up("rename_column :adverts, :name, :title").and(
+        migrate_down("rename_column :adverts, :title, :name")
+      )
+    )
 
     migrate
 
@@ -104,9 +113,11 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up_down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up_down).to eq(["change_column :adverts, :title, :text",
-                           "change_column :adverts, :title, :string, limit: 255"])
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up("change_column :adverts, :title, :text").and(
+        migrate_down("change_column :adverts, :title, :string, limit: 255")
+      )
+    )
 
     class Advert < ActiveRecord::Base
       fields do
@@ -115,11 +126,14 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up, down = migrate
-    expect(up.split(',').slice(0,3).join(',')).to eq('change_column :adverts, :title, :string')
-    expect(up.split(',').slice(3,2).sort.join(',')).to eq(" default: \"Untitled\", limit: 255")
-    expect(down).to eq("change_column :adverts, :title, :string, limit: 255")
-
+    expect(migrate).to(
+      migrate_up(<<~EOS.strip)
+        change_column :adverts, :title, :string, limit: 255, default: "Untitled"
+      EOS
+      .and migrate_down(<<~EOS.strip)
+        change_column :adverts, :title, :string, limit: 255
+      EOS
+    )
 
     ### Limits
 
@@ -129,8 +143,9 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq("add_column :adverts, :price, :integer, limit: 2")
+    up, _ = Generators::DeclareSchema::Migration::Migrator.run.tap do |migrations|
+      expect(migrations).to migrate_up("add_column :adverts, :price, :integer, limit: 2")
+    end
 
     # Now run the migration, then change the limit:
 
@@ -141,9 +156,14 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq("change_column :adverts, :price, :integer, limit: 3")
-    expect(down).to eq("change_column :adverts, :price, :integer, limit: 2")
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        change_column :adverts, :price, :integer, limit: 3
+      EOS
+      .and migrate_down(<<~EOS.strip)
+        change_column :adverts, :price, :integer, limit: 2
+      EOS
+    )
 
     # Note that limit on a decimal column is ignored (use :scale and :precision)
 
@@ -154,8 +174,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq("add_column :adverts, :price, :decimal")
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to migrate_up("add_column :adverts, :price, :decimal")
 
     # Limits are generally not needed for `text` fields, because by default, `text` fields will use the maximum size
     # allowed for that database type (0xffffffff for LONGTEXT in MySQL unlimited in Postgres, 1 billion in Sqlite).
@@ -170,12 +189,13 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq(<<~EOS.strip)
-      add_column :adverts, :price, :decimal
-      add_column :adverts, :notes, :text, null: false
-      add_column :adverts, :description, :text, null: false
-    EOS
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :price, :decimal
+        add_column :adverts, :notes, :text, null: false
+        add_column :adverts, :description, :text, null: false
+      EOS
+    )
 
     # (There is no limit on `add_column ... :description` above since these tests are run against SQLite.)
 
@@ -194,11 +214,12 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq(<<~EOS.strip)
-      add_column :adverts, :notes, :text, null: false, limit: 4294967295
-      add_column :adverts, :description, :text, null: false, limit: 255
-    EOS
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :notes, :text, null: false, limit: 4294967295
+        add_column :adverts, :description, :text, null: false, limit: 255
+      EOS
+    )
 
     Advert.field_specs.delete :notes
 
@@ -237,9 +258,14 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq("change_column :adverts, :description, :text, limit: 4294967295, null: false")
-    expect(down).to eq("change_column :adverts, :description, :text")
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        change_column :adverts, :description, :text, limit: 4294967295, null: false
+      EOS
+      .and migrate_down(<<~EOS.strip)
+        change_column :adverts, :description, :text
+      EOS
+    )
 
     # TODO TECH-4814: The above test should have this output:
     # TODO => "change_column :adverts, :description, :text, limit: 255
@@ -252,9 +278,14 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq("change_column :adverts, :description, :text, limit: 4294967295, null: false")
-    expect(down).to eq("change_column :adverts, :description, :text")
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        change_column :adverts, :description, :text, limit: 4294967295, null: false
+      EOS
+      .and migrate_down(<<~EOS.strip)
+        change_column :adverts, :description, :text
+      EOS
+    )
     ::DeclareSchema::Model::FieldSpec::instance_variable_set(:@mysql_text_limits, false)
 
     Advert.field_specs.clear
@@ -266,7 +297,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
+    up = Generators::DeclareSchema::Migration::Migrator.run.first
     ActiveRecord::Migration.class_eval up
     Advert.connection.schema_cache.clear!
     Advert.reset_column_information
@@ -278,63 +309,82 @@ RSpec.describe 'DeclareSchema Migration Generator' do
 
     class Category < ActiveRecord::Base; end
     class Advert < ActiveRecord::Base
+      fields do
+        name :string, limit: 255, null: true
+      end
       belongs_to :category
     end
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      add_column :adverts, :category_id, :integer, limit: 8, null: false
-      add_index :adverts, [:category_id], name: 'on_category_id'
-    EOS
-    expect(down.sub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      remove_column :adverts, :category_id
-      remove_index :adverts, name: :on_category_id rescue ActiveRecord::StatementInvalid
-    EOS
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :category_id, :integer, limit: 8, null: false
+
+        add_index :adverts, [:category_id], name: 'on_category_id'
+      EOS
+      .and migrate_down(<<~EOS.strip)
+        remove_column :adverts, :category_id
+
+        remove_index :adverts, name: :on_category_id rescue ActiveRecord::StatementInvalid
+      EOS
+    )
 
     Advert.field_specs.delete(:category_id)
-    Advert.index_specs.delete_if {|spec| spec.fields==["category_id"]}
+    Advert.index_definitions.delete_if { |spec| spec.fields==["category_id"] }
 
     # If you specify a custom foreign key, the migration generator observes that:
 
     class Category < ActiveRecord::Base; end
     class Advert < ActiveRecord::Base
+      fields { }
       belongs_to :category, foreign_key: "c_id", class_name: 'Category'
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      add_column :adverts, :c_id, :integer, limit: 8, null: false
-      add_index :adverts, [:c_id], name: 'on_c_id'
-    EOS
+
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :c_id, :integer, limit: 8, null: false
+
+        add_index :adverts, [:c_id], name: 'on_c_id'
+      EOS
+    )
 
     Advert.field_specs.delete(:c_id)
-    Advert.index_specs.delete_if { |spec| spec.fields == ["c_id"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["c_id"] }
 
     # You can avoid generating the index by specifying `index: false`
 
     class Category < ActiveRecord::Base; end
     class Advert < ActiveRecord::Base
+      fields { }
       belongs_to :category, index: false
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq("add_column :adverts, :category_id, :integer, limit: 8, null: false")
+
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :category_id, :integer, limit: 8, null: false
+      EOS
+    )
 
     Advert.field_specs.delete(:category_id)
-    Advert.index_specs.delete_if { |spec| spec.fields == ["category_id"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
 
     # You can specify the index name with :index
 
     class Category < ActiveRecord::Base; end
     class Advert < ActiveRecord::Base
+      fields { }
       belongs_to :category, index: 'my_index'
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      add_column :adverts, :category_id, :integer, limit: 8, null: false
-      add_index :adverts, [:category_id], name: 'my_index'
-    EOS
+
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :category_id, :integer, limit: 8, null: false
+
+        add_index :adverts, [:category_id], name: 'my_index'
+      EOS
+    )
 
     Advert.field_specs.delete(:category_id)
-    Advert.index_specs.delete_if { |spec| spec.fields == ["category_id"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
 
     ### Timestamps and Optimimistic Locking
 
@@ -347,17 +397,19 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         optimistic_lock
       end
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      add_column :adverts, :created_at, :datetime
-      add_column :adverts, :updated_at, :datetime
-      add_column :adverts, :lock_version, :integer, null: false, default: 1
-    EOS
-    expect(down.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      remove_column :adverts, :created_at
-      remove_column :adverts, :updated_at
-      remove_column :adverts, :lock_version
-    EOS
+
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :created_at, :datetime
+        add_column :adverts, :updated_at, :datetime
+        add_column :adverts, :lock_version, :integer, null: false, default: 1
+      EOS
+      .and migrate_down(<<~EOS.strip)
+        remove_column :adverts, :created_at
+        remove_column :adverts, :updated_at
+        remove_column :adverts, :lock_version
+      EOS
+    )
 
     Advert.field_specs.delete(:updated_at)
     Advert.field_specs.delete(:created_at)
@@ -372,13 +424,16 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         title :string, index: true, limit: 255, null: true
       end
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      add_column :adverts, :title, :string, limit: 255
-      add_index :adverts, [:title], name: 'on_title'
-    EOS
 
-    Advert.index_specs.delete_if { |spec| spec.fields==["title"] }
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :title, :string, limit: 255
+
+        add_index :adverts, [:title], name: 'on_title'
+      EOS
+    )
+
+    Advert.index_definitions.delete_if { |spec| spec.fields==["title"] }
 
     # You can ask for a unique index
 
@@ -387,13 +442,16 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         title :string, index: true, unique: true, null: true, limit: 255
       end
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      add_column :adverts, :title, :string, limit: 255
-      add_index :adverts, [:title], unique: true, name: 'on_title'
-    EOS
 
-    Advert.index_specs.delete_if { |spec| spec.fields == ["title"] }
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :title, :string, limit: 255
+
+        add_index :adverts, [:title], unique: true, name: 'on_title'
+      EOS
+    )
+
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
 
     # You can specify the name for the index
 
@@ -402,52 +460,64 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         title :string, index: 'my_index', limit: 255, null: true
       end
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      add_column :adverts, :title, :string, limit: 255
-      add_index :adverts, [:title], name: 'my_index'
-    EOS
 
-    Advert.index_specs.delete_if {|spec| spec.fields==["title"]}
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :title, :string, limit: 255
+
+        add_index :adverts, [:title], name: 'my_index'
+      EOS
+    )
+
+    Advert.index_definitions.delete_if { |spec| spec.fields==["title"] }
 
     # You can ask for an index outside of the fields block
 
     class Advert < ActiveRecord::Base
       index :title
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      add_column :adverts, :title, :string, limit: 255
-      add_index :adverts, [:title], name: 'on_title'
-    EOS
 
-    Advert.index_specs.delete_if { |spec| spec.fields == ["title"] }
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :title, :string, limit: 255
+
+        add_index :adverts, [:title], name: 'on_title'
+      EOS
+    )
+
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
 
     # The available options for the index function are `:unique` and `:name`
 
     class Advert < ActiveRecord::Base
       index :title, unique: true, name: 'my_index'
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      add_column :adverts, :title, :string, limit: 255
-      add_index :adverts, [:title], unique: true, name: 'my_index'
-    EOS
 
-    Advert.index_specs.delete_if { |spec| spec.fields == ["title"] }
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :title, :string, limit: 255
+
+        add_index :adverts, [:title], unique: true, name: 'my_index'
+      EOS
+    )
+
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
 
     # You can create an index on more than one field
 
     class Advert < ActiveRecord::Base
       index [:title, :category_id]
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      add_column :adverts, :title, :string, limit: 255
-      add_index :adverts, [:title, :category_id], name: 'on_title_and_category_id'
-    EOS
 
-    Advert.index_specs.delete_if { |spec| spec.fields==["title", "category_id"] }
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        add_column :adverts, :title, :string, limit: 255
+
+        add_index :adverts, [:title, :category_id], name: 'on_title_and_category_id'
+      EOS
+    )
+
+    Advert.index_definitions.delete_if { |spec| spec.fields==["title", "category_id"] }
 
     # Finally, you can specify that the migration generator should completely ignore an
     # index by passing its name to ignore_index in the model.
@@ -468,19 +538,24 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     Advert.connection.schema_cache.clear!
     Advert.reset_column_information
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run("adverts" => "ads")
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      rename_table :adverts, :ads
-      add_column :ads, :title, :string, limit: 255
-      add_column :ads, :body, :text
-      add_index :ads, [:id], unique: true, name: 'PRIMARY_KEY'
-    EOS
-    expect(down.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      remove_column :ads, :title
-      remove_column :ads, :body
-      rename_table :ads, :adverts
-      add_index :adverts, [:id], unique: true, name: 'PRIMARY_KEY'
-    EOS
+    expect(Generators::DeclareSchema::Migration::Migrator.run("adverts" => "ads")).to(
+      migrate_up(<<~EOS.strip)
+        rename_table :adverts, :ads
+
+        add_column :ads, :title, :string, limit: 255
+        add_column :ads, :body, :text
+
+        add_index :ads, [:id], unique: true, name: 'PRIMARY'
+      EOS
+      .and migrate_down(<<~EOS.strip)
+        remove_column :ads, :title
+        remove_column :ads, :body
+
+        rename_table :ads, :adverts
+
+        add_index :adverts, [:id], unique: true, name: 'PRIMARY'
+      EOS
+    )
 
     # Set the table name back to what it should be and confirm we're in sync:
 
@@ -504,21 +579,27 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         body :text, null: true
       end
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run("adverts" => "advertisements")
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      rename_table :adverts, :advertisements
-      add_column :advertisements, :title, :string, limit: 255
-      add_column :advertisements, :body, :text
-      remove_column :advertisements, :name
-      add_index :advertisements, [:id], unique: true, name: 'PRIMARY_KEY'
-    EOS
-    expect(down.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      remove_column :advertisements, :title
-      remove_column :advertisements, :body
-      add_column :adverts, :name, :string, limit: 255
-      rename_table :advertisements, :adverts
-      add_index :adverts, [:id], unique: true, name: 'PRIMARY_KEY'
-    EOS
+
+    expect(Generators::DeclareSchema::Migration::Migrator.run("adverts" => "advertisements")).to(
+      migrate_up(<<~EOS.strip)
+        rename_table :adverts, :advertisements
+
+        add_column :advertisements, :title, :string, limit: 255
+        add_column :advertisements, :body, :text
+        remove_column :advertisements, :name
+
+        add_index :advertisements, [:id], unique: true, name: 'PRIMARY'
+      EOS
+      .and migrate_down(<<~EOS.strip)
+        remove_column :advertisements, :title
+        remove_column :advertisements, :body
+        add_column :adverts, :name, :string, limit: 255
+
+        rename_table :advertisements, :adverts
+
+        add_index :adverts, [:id], unique: true, name: 'PRIMARY'
+      EOS
+    )
 
     ### Drop a table
 
@@ -528,9 +609,25 @@ RSpec.describe 'DeclareSchema Migration Generator' do
 
     # Dropping tables is where the automatic down-migration really comes in handy:
 
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq("drop_table :adverts")
-    expect(down.gsub(/,.*/m, '')).to eq("create_table \"adverts\"")
+    rails4_table_create = <<~EOS.strip
+      create_table "adverts", id: false, force: :cascade do |t|
+        t.integer "id",   limit: 8
+        t.string  "name", limit: 255
+      end
+    EOS
+
+    rails5_table_create = <<~EOS.strip
+      create_table "adverts", id: :integer, force: :cascade do |t|
+        t.string "name", limit: 255
+      end
+    EOS
+
+    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+      migrate_up(<<~EOS.strip)
+        drop_table :adverts
+      EOS
+      .and migrate_down(Rails::VERSION::MAJOR >= 5 ? rails5_table_create : rails4_table_create)
+    )
 
     ## STI
 
@@ -544,27 +641,33 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         title :string, default: "Untitled", limit: 255, null: true
       end
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
+    up = Generators::DeclareSchema::Migration::Migrator.run.first
     ActiveRecord::Migration.class_eval(up)
 
     class FancyAdvert < Advert
     end
     class SuperFancyAdvert < FancyAdvert
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      add_column :adverts, :type, :string, limit: 255
-      add_index :adverts, [:type], name: 'on_type'
-    EOS
-    expect(down.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      remove_column :adverts, :type
-      remove_index :adverts, name: :on_type rescue ActiveRecord::StatementInvalid
-    EOS
+
+    up, _ = Generators::DeclareSchema::Migration::Migrator.run do |migrations|
+      expect(migrations).to(
+        migrate_up(<<~EOS.strip)
+          add_column :adverts, :type, :string, limit: 255
+
+          add_index :adverts, [:type], name: 'on_type'
+        EOS
+        .and migrate_down(<<~EOS.strip)
+          remove_column :adverts, :type
+
+          remove_index :adverts, name: :on_type rescue ActiveRecord::StatementInvalid
+        EOS
+      )
+    end
 
     Advert.field_specs.delete(:type)
     nuke_model_class(SuperFancyAdvert)
     nuke_model_class(FancyAdvert)
-    Advert.index_specs.delete_if { |spec| spec.fields==["type"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields==["type"] }
 
     ## Coping with multiple changes
 
@@ -592,16 +695,17 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         body :text, null: true
       end
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run(adverts: { title: :name })
-    expect(up).to eq(<<~EOS.strip)
-      rename_column :adverts, :title, :name
-      change_column :adverts, :name, :string, limit: 255, default: \"No Name\"
-    EOS
 
-    expect(down).to eq(<<~EOS.strip)
-      rename_column :adverts, :name, :title
-      change_column :adverts, :title, :string, limit: 255, default: \"Untitled\"
-    EOS
+    expect(Generators::DeclareSchema::Migration::Migrator.run(adverts: { title: :name })).to(
+      migrate_up(<<~EOS.strip)
+        rename_column :adverts, :title, :name
+        change_column :adverts, :name, :string, limit: 255, default: "No Name"
+      EOS
+      .and migrate_down(<<~EOS.strip)
+        rename_column :adverts, :name, :title
+        change_column :adverts, :title, :string, limit: 255, default: "Untitled"
+      EOS
+    )
 
     ### Rename a table and add a column
 
@@ -613,13 +717,17 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         created_at :datetime
       end
     end
-    up, down = Generators::DeclareSchema::Migration::Migrator.run(adverts: :ads)
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      rename_table :adverts, :ads
-      add_column :ads, :created_at, :datetime, null: false
-      change_column :ads, :title, :string, limit: 255, null: false, default: \"Untitled\"
-      add_index :ads, [:id], unique: true, name: 'PRIMARY_KEY'
-    EOS
+
+    expect(Generators::DeclareSchema::Migration::Migrator.run(adverts: :ads)).to(
+      migrate_up(<<~EOS.strip)
+        rename_table :adverts, :ads
+
+        add_column :ads, :created_at, :datetime, null: false
+        change_column :ads, :title, :string, limit: 255, null: false, default: \"Untitled\"
+
+        add_index :ads, [:id], unique: true, name: 'PRIMARY'
+      EOS
+    )
 
     class Advert < ActiveRecord::Base
       fields do
@@ -640,11 +748,14 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
       self.primary_key = "advert_id"
     end
-    up, _down = Generators::DeclareSchema::Migration::Migrator.run(adverts: { id: :advert_id })
-    expect(up.gsub(/\n+/, "\n")).to eq(<<~EOS.strip)
-      rename_column :adverts, :id, :advert_id
-      add_index :adverts, [:advert_id], unique: true, name: 'PRIMARY_KEY'
-    EOS
+
+    expect(Generators::DeclareSchema::Migration::Migrator.run(adverts: { id: :advert_id })).to(
+      migrate_up(<<~EOS.strip)
+        rename_column :adverts, :id, :advert_id
+
+        add_index :adverts, [:advert_id], unique: true, name: 'PRIMARY'
+      EOS
+    )
 
     nuke_model_class(Advert)
     ActiveRecord::Base.connection.execute("drop table `adverts`;")
@@ -682,5 +793,299 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     ActiveRecord::Migration.class_eval(up)
     expect(Ad.field_specs['company'].options[:validates].inspect).to eq("{:presence=>true, :uniqueness=>{:case_sensitive=>false}}")
   end
-end
 
+  describe 'serialize' do
+    before do
+      class Ad < ActiveRecord::Base
+        @serialize_args = []
+
+        class << self
+          attr_reader :serialize_args
+
+          def serialize(*args)
+            @serialize_args << args
+          end
+        end
+      end
+    end
+
+    describe 'untyped' do
+      it 'allows serialize: true' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :text, limit: 0xFFFF, serialize: true
+          end
+        end
+
+        expect(Ad.serialize_args).to eq([[:allow_list]])
+      end
+
+      it 'converts defaults with .to_yaml' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: true, null: true, default: []
+            allow_hash :string, limit: 255, serialize: true, null: true, default: {}
+            allow_string :string, limit: 255, serialize: true, null: true, default: ['abc']
+            allow_null :string, limit: 255, serialize: true, null: true, default: nil
+          end
+        end
+
+        expect(Ad.field_specs['allow_list'].default).to eq("--- []\n")
+        expect(Ad.field_specs['allow_hash'].default).to eq("--- {}\n")
+        expect(Ad.field_specs['allow_string'].default).to eq("---\n- abc\n")
+        expect(Ad.field_specs['allow_null'].default).to eq(nil)
+      end
+    end
+
+    describe 'Array' do
+      it 'allows serialize: Array' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: Array, null: true
+          end
+        end
+
+        expect(Ad.serialize_args).to eq([[:allow_list, Array]])
+      end
+
+      it 'allows Array defaults' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: Array, null: true, default: [2]
+            allow_string :string, limit: 255, serialize: Array, null: true, default: ['abc']
+            allow_empty :string, limit: 255, serialize: Array, null: true, default: []
+            allow_null :string, limit: 255, serialize: Array, null: true, default: nil
+          end
+        end
+
+        expect(Ad.field_specs['allow_list'].default).to eq("---\n- 2\n")
+        expect(Ad.field_specs['allow_string'].default).to eq("---\n- abc\n")
+        expect(Ad.field_specs['allow_empty'].default).to eq(nil)
+        expect(Ad.field_specs['allow_null'].default).to eq(nil)
+      end
+    end
+
+    describe 'Hash' do
+      it 'allows serialize: Hash' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: Hash, null: true
+          end
+        end
+
+        expect(Ad.serialize_args).to eq([[:allow_list, Hash]])
+      end
+
+      it 'allows Hash defaults' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_loc :string, limit: 255, serialize: Hash, null: true, default: { 'state' => 'CA' }
+            allow_hash :string, limit: 255, serialize: Hash, null: true, default: {}
+            allow_null :string, limit: 255, serialize: Hash, null: true, default: nil
+          end
+        end
+
+        expect(Ad.field_specs['allow_loc'].default).to eq("---\nstate: CA\n")
+        expect(Ad.field_specs['allow_hash'].default).to eq(nil)
+        expect(Ad.field_specs['allow_null'].default).to eq(nil)
+      end
+    end
+
+    describe 'JSON' do
+      it 'allows serialize: JSON' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: JSON
+          end
+        end
+
+        expect(Ad.serialize_args).to eq([[:allow_list, JSON]])
+      end
+
+      it 'allows JSON defaults' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_hash :string, limit: 255, serialize: JSON, null: true, default: { 'state' => 'CA' }
+            allow_empty_array :string, limit: 255, serialize: JSON, null: true, default: []
+            allow_empty_hash :string, limit: 255, serialize: JSON, null: true, default: {}
+            allow_null :string, limit: 255, serialize: JSON, null: true, default: nil
+          end
+        end
+
+        expect(Ad.field_specs['allow_hash'].default).to eq("{\"state\":\"CA\"}")
+        expect(Ad.field_specs['allow_empty_array'].default).to eq("[]")
+        expect(Ad.field_specs['allow_empty_hash'].default).to eq("{}")
+        expect(Ad.field_specs['allow_null'].default).to eq(nil)
+      end
+    end
+
+    class ValueClass
+      delegate :present?, :inspect, to: :@value
+
+      def initialize(value)
+        @value = value
+      end
+
+      class << self
+        def dump(object)
+          if object&.present?
+            object.inspect
+          end
+        end
+
+        def load(serialized)
+          if serialized
+            raise 'not used ???'
+          end
+        end
+      end
+    end
+
+    describe 'custom coder' do
+      it 'allows serialize: ValueClass' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: ValueClass
+          end
+        end
+
+        expect(Ad.serialize_args).to eq([[:allow_list, ValueClass]])
+      end
+
+      it 'allows ValueClass defaults' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_hash :string, limit: 255, serialize: ValueClass, null: true, default: ValueClass.new([2])
+            allow_empty_array :string, limit: 255, serialize: ValueClass, null: true, default: ValueClass.new([])
+            allow_null :string, limit: 255, serialize: ValueClass, null: true, default: nil
+          end
+        end
+
+        expect(Ad.field_specs['allow_hash'].default).to eq("[2]")
+        expect(Ad.field_specs['allow_empty_array'].default).to eq(nil)
+        expect(Ad.field_specs['allow_null'].default).to eq(nil)
+      end
+    end
+
+    it 'disallows serialize: with a non-string column type' do
+      expect do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :integer, limit: 8, serialize: true
+          end
+        end
+      end.to raise_exception(ArgumentError, /must be :string or :text/)
+    end
+  end
+
+  context "for Rails #{Rails::VERSION::MAJOR}" do
+    if Rails::VERSION::MAJOR >= 5
+      let(:optional_true) { { optional: true } }
+      let(:optional_false) { { optional: false } }
+    else
+      let(:optional_true) { {} }
+      let(:optional_false) { {} }
+    end
+    let(:optional_flag) { { false => optional_false, true => optional_true } }
+
+    describe 'belongs_to' do
+      before do
+        unless defined?(AdCategory)
+          class AdCategory < ActiveRecord::Base
+            fields { }
+          end
+        end
+
+        class Advert < ActiveRecord::Base
+          fields do
+            name :string, limit: 255, null: true
+            category_id :integer, limit: 8
+            nullable_category_id :integer, limit: 8, null: true
+          end
+        end
+        up = Generators::DeclareSchema::Migration::Migrator.run.first
+        ActiveRecord::Migration.class_eval(up)
+      end
+
+      it 'passes through optional: when given' do
+        class AdvertBelongsTo < ActiveRecord::Base
+          self.table_name = 'adverts'
+          fields { }
+          reset_column_information
+          belongs_to :ad_category, optional: true
+        end
+        expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_true)
+      end
+
+      describe 'contradictory settings' do # contradictory settings are ok--for example, during migration
+        it 'passes through optional: true, null: false' do
+          class AdvertBelongsTo < ActiveRecord::Base
+            self.table_name = 'adverts'
+            fields { }
+            reset_column_information
+            belongs_to :ad_category, optional: true, null: false
+          end
+          expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_true)
+          expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(false)
+        end
+
+        it 'passes through optional: false, null: true' do
+          class AdvertBelongsTo < ActiveRecord::Base
+            self.table_name = 'adverts'
+            fields { }
+            reset_column_information
+            belongs_to :ad_category, optional: false, null: true
+          end
+          expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_false)
+          expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(true)
+        end
+      end
+
+      [false, true].each do |nullable|
+        context "nullable=#{nullable}" do
+          it 'infers optional: from null:' do
+            eval <<~EOS
+              class AdvertBelongsTo < ActiveRecord::Base
+                fields { }
+                belongs_to :ad_category, null: #{nullable}
+              end
+            EOS
+            expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_flag[nullable])
+            expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(nullable)
+          end
+
+          it 'infers null: from optional:' do
+            eval <<~EOS
+              class AdvertBelongsTo < ActiveRecord::Base
+                fields { }
+                belongs_to :ad_category, optional: #{nullable}
+              end
+            EOS
+            expect(AdvertBelongsTo.reflections['ad_category'].options).to eq(optional_flag[nullable])
+            expect(AdvertBelongsTo.field_specs['ad_category_id'].options&.[](:null)).to eq(nullable)
+          end
+        end
+      end
+    end
+  end
+
+  describe 'migration base class' do
+    it 'adapts to Rails 4' do
+      class Advert < active_record_base_class.constantize
+        fields do
+          title :string, limit: 100
+        end
+      end
+
+      generate_migrations '-n', '-m'
+
+      migrations = Dir.glob('db/migrate/*declare_schema_migration*.rb')
+      expect(migrations.size).to eq(1), migrations.inspect
+
+      migration_content = File.read(migrations.first)
+      first_line = migration_content.split("\n").first
+      base_class = first_line.split(' < ').last
+      expect(base_class).to eq("(Rails::VERSION::MAJOR >= 5 ? ActiveRecord::Migration[4.2] : ActiveRecord::Migration)")
+    end
+  end
+end