declare_schema 0.8.0.pre.5 → 0.10.0

data/spec/lib/declare_schema/generator_spec.rb

@@ -11,9 +11,9 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     expect_model_definition_to_eq('alpha/beta', <<~EOS)
       class Alpha::Beta < #{active_record_base_class}
 
-        fields do
-          one :string, limit: 255
-          two :integer
+        declare_schema do
+          string  :one, limit: 255
+          integer :two
         end
 
       end

data/spec/lib/declare_schema/interactive_primary_key_spec.rb

@@ -11,49 +11,101 @@ RSpec.describe 'DeclareSchema Migration Generator interactive primary key' do
     load File.expand_path('prepare_testapp.rb', __dir__)
   end
 
-  it "allows alternate primary keys" do
-    class Foo < ActiveRecord::Base
-      fields do
+  context 'Using fields' do
+    it "allows alternate primary keys" do
+      class Foo < ActiveRecord::Base
+        fields do
+        end
+        self.primary_key = "foo_id"
       end
-      self.primary_key = "foo_id"
-    end
 
-    generate_migrations '-n', '-m'
-    expect(Foo.primary_key).to eq('foo_id')
+      generate_migrations '-n', '-m'
+      expect(Foo._defined_primary_key).to eq('foo_id')
 
-    ### migrate from
-    # rename from custom primary_key
-    class Foo < ActiveRecord::Base
-      fields do
+      ### migrate from
+      # rename from custom primary_key
+      class Foo < ActiveRecord::Base
+        fields do
+        end
+        self.primary_key = "id"
       end
-      self.primary_key = "id"
-    end
 
-    puts "\n\e[45m Please enter 'id' (no quotes) at the next prompt \e[0m"
-    generate_migrations '-n', '-m'
-    expect(Foo.primary_key).to eq('id')
+      allow_any_instance_of(DeclareSchema::Support::ThorShell).to receive(:ask).with(/one of the rename choices or press enter to keep/) { 'id' }
+      generate_migrations '-n', '-m'
+      expect(Foo._defined_primary_key).to eq('id')
+
+      nuke_model_class(Foo)
+
+      ### migrate to
+
+      if Rails::VERSION::MAJOR >= 5 && !defined?(Mysql2) # TODO TECH-4814 Put this test back for Mysql2
+        # replace custom primary_key
+        class Foo < ActiveRecord::Base
+          fields do
+          end
+          self.primary_key = "foo_id"
+        end
+
+        allow_any_instance_of(DeclareSchema::Support::ThorShell).to receive(:ask).with(/one of the rename choices or press enter to keep/) { 'drop id' }
+        generate_migrations '-n', '-m'
+        expect(Foo._defined_primary_key).to eq('foo_id')
 
-    nuke_model_class(Foo)
+        ### ensure it doesn't cause further migrations
 
-    ### migrate to
+        # check no further migrations
+        up = Generators::DeclareSchema::Migration::Migrator.run.first
+        expect(up).to eq("")
+      end
+    end
+  end
 
-    if Rails::VERSION::MAJOR >= 5 && !defined?(Mysql2) # TODO TECH-4814 Put this test back for Mysql2
-      # replace custom primary_key
+  context 'Using declare_schema' do
+    it "allows alternate primary keys" do
       class Foo < ActiveRecord::Base
-        fields do
+        declare_schema do
         end
         self.primary_key = "foo_id"
       end
 
-      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
+      ### migrate from
+      # rename from custom primary_key
+      class Foo < ActiveRecord::Base
+        declare_schema do
+        end
+        self.primary_key = "id"
+      end
+
+      puts "\n\e[45m Please enter 'id' (no quotes) at the next prompt \e[0m"
+      allow_any_instance_of(DeclareSchema::Support::ThorShell).to receive(:ask).with(/one of the rename choices or press enter to keep/) { 'id' }
+      generate_migrations '-n', '-m'
+      expect(Foo.primary_key).to eq('id')
+
+      nuke_model_class(Foo)
+
+      ### migrate to
+
+      if Rails::VERSION::MAJOR >= 5 && !defined?(Mysql2) # TODO TECH-4814 Put this test back for Mysql2
+        # replace custom primary_key
+        class Foo < ActiveRecord::Base
+          declare_schema do
+          end
+          self.primary_key = "foo_id"
+        end
+
+        puts "\n\e[45m Please enter 'drop id' (no quotes) at the next prompt \e[0m"
+        allow_any_instance_of(DeclareSchema::Support::ThorShell).to receive(:ask).with(/one of the rename choices or press enter to keep/) { 'drop id' }
+        generate_migrations '-n', '-m'
+        expect(Foo.primary_key).to eq('foo_id')
 
-      # check no further migrations
-      up = Generators::DeclareSchema::Migration::Migrator.run.first
-      expect(up).to eq("")
+        ### ensure it doesn't cause further migrations
+
+        # check no further migrations
+        up = Generators::DeclareSchema::Migration::Migrator.run.first
+        expect(up).to eq("")
+      end
     end
   end
 end

data/spec/lib/declare_schema/migration_generator_spec.rb

@@ -55,1172 +55,2346 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     end
   end
 
-  # DeclareSchema - Migration Generator
-  it 'generates migrations' do
-    ## The migration generator -- introduction
+  context 'Using fields' do
+    # DeclareSchema - Migration Generator
+    it 'generates migrations' do
+      ## The migration generator -- introduction
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to migrate_up("").and migrate_down("")
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to migrate_up("").and migrate_down("")
 
-    class Advert < ActiveRecord::Base
-    end
+      class Advert < ActiveRecord::Base
+      end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to migrate_up("").and migrate_down("")
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to migrate_up("").and migrate_down("")
 
-    Generators::DeclareSchema::Migration::Migrator.ignore_tables = ["green_fishes"]
+      Generators::DeclareSchema::Migration::Migrator.ignore_tables = ["green_fishes"]
 
-    Advert.connection.schema_cache.clear!
-    Advert.reset_column_information
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
 
-    class Advert < ActiveRecord::Base
-      fields do
-        name :string, limit: 250, null: true
+      class Advert < ActiveRecord::Base
+        fields do
+          name :string, limit: 250, null: true
+        end
       end
-    end
 
-    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: 250, null: true#{charset_and_collation}
-          end#{charset_alter_table}
-        EOS
-        .and migrate_down("drop_table :adverts")
-      )
-    end
+      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: 250, null: true#{charset_and_collation}
+            end#{charset_alter_table}
+          EOS
+          .and migrate_down("drop_table :adverts")
+        )
+      end
 
-    ActiveRecord::Migration.class_eval(up)
-    expect(Advert.columns.map(&:name)).to eq(["id", "name"])
+      ActiveRecord::Migration.class_eval(up)
+      expect(Advert.columns.map(&:name)).to eq(["id", "name"])
 
-    if Rails::VERSION::MAJOR < 5
-      # Rails 4 drivers don't always create PK properly. Fix that by dropping and recreating.
-      ActiveRecord::Base.connection.execute("drop table adverts")
-      if defined?(Mysql2)
-        ActiveRecord::Base.connection.execute("CREATE TABLE adverts (id integer PRIMARY KEY AUTO_INCREMENT NOT NULL, name varchar(250)) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin")
-      else
-        ActiveRecord::Base.connection.execute("CREATE TABLE adverts (id integer PRIMARY KEY AUTOINCREMENT  NOT NULL, name varchar(250))")
+      if Rails::VERSION::MAJOR < 5
+        # Rails 4 drivers don't always create PK properly. Fix that by dropping and recreating.
+        ActiveRecord::Base.connection.execute("drop table adverts")
+        if defined?(Mysql2)
+          ActiveRecord::Base.connection.execute("CREATE TABLE adverts (id integer PRIMARY KEY AUTO_INCREMENT NOT NULL, name varchar(250)) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin")
+        else
+          ActiveRecord::Base.connection.execute("CREATE TABLE adverts (id integer PRIMARY KEY AUTOINCREMENT  NOT NULL, name varchar(250))")
+        end
       end
-    end
 
-    class Advert < ActiveRecord::Base
-      fields do
-        name :string, limit: 250, null: true
-        body :text, null: true
-        published_at :datetime, null: true
+      class Advert < ActiveRecord::Base
+        fields do
+          name :string, limit: 250, null: true
+          body :text, null: true
+          published_at :datetime, null: true
+        end
       end
-    end
 
-    Advert.connection.schema_cache.clear!
-    Advert.reset_column_information
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
 
-    expect(migrate).to(
-      migrate_up(<<~EOS.strip)
-        add_column :adverts, :body, :text#{text_limit}, null: true#{charset_and_collation}
-        add_column :adverts, :published_at, :datetime, null: true
-      EOS
-      .and migrate_down(<<~EOS.strip)
-        remove_column :adverts, :body
-        remove_column :adverts, :published_at
-      EOS
-    )
+      expect(migrate).to(
+        migrate_up(<<~EOS.strip)
+          add_column :adverts, :body, :text#{text_limit}, null: true#{charset_and_collation}
+          add_column :adverts, :published_at, :datetime, null: true
+        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
-      fields do
-        name :string, limit: 250, null: true
-        body :text, null: true
+      Advert.field_specs.clear # not normally needed
+      class Advert < ActiveRecord::Base
+        fields do
+          name :string, limit: 250, null: true
+          body :text, null: true
+        end
       end
-    end
 
-    expect(migrate).to(
-      migrate_up("remove_column :adverts, :published_at").and(
-        migrate_down("add_column :adverts, :published_at, :datetime#{datetime_precision}, null: true")
+      expect(migrate).to(
+        migrate_up("remove_column :adverts, :published_at").and(
+          migrate_down("add_column :adverts, :published_at, :datetime#{datetime_precision}, null: true")
+        )
       )
-    )
 
-    nuke_model_class(Advert)
-    class Advert < ActiveRecord::Base
-      fields do
-        title :string, limit: 250, null: true
-        body :text, null: true
+      nuke_model_class(Advert)
+      class Advert < ActiveRecord::Base
+        fields do
+          title :string, limit: 250, null: true
+          body :text, null: true
+        end
       end
-    end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
-        remove_column :adverts, :name
-      EOS
-      .and migrate_down(<<~EOS.strip)
-        remove_column :adverts, :title
-        add_column :adverts, :name, :string, limit: 250, null: true#{charset_and_collation}
-      EOS
-    )
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+          remove_column :adverts, :name
+        EOS
+        .and migrate_down(<<~EOS.strip)
+          remove_column :adverts, :title
+          add_column :adverts, :name, :string, limit: 250, null: true#{charset_and_collation}
+        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")
+      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
+      migrate
 
-    class Advert < ActiveRecord::Base
-      fields do
-        title :text, null: true
-        body :text, null: true
+      class Advert < ActiveRecord::Base
+        fields do
+          title :text, null: true
+          body :text, null: true
+        end
       end
-    end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up("change_column :adverts, :title, :text#{text_limit}, null: true#{charset_and_collation}").and(
-        migrate_down("change_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}")
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up("change_column :adverts, :title, :text#{text_limit}, null: true#{charset_and_collation}").and(
+          migrate_down("change_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}")
+        )
       )
-    )
 
-    class Advert < ActiveRecord::Base
-      fields do
-        title :string, default: "Untitled", limit: 250, null: true
-        body :text, null: true
+      class Advert < ActiveRecord::Base
+        fields do
+          title :string, default: "Untitled", limit: 250, null: true
+          body :text, null: true
+        end
       end
-    end
 
-    expect(migrate).to(
-      migrate_up(<<~EOS.strip)
-        change_column :adverts, :title, :string, limit: 250, null: true, default: "Untitled"#{charset_and_collation}
-      EOS
-      .and migrate_down(<<~EOS.strip)
-        change_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
-      EOS
-    )
+      expect(migrate).to(
+        migrate_up(<<~EOS.strip)
+          change_column :adverts, :title, :string, limit: 250, null: true, default: "Untitled"#{charset_and_collation}
+        EOS
+        .and migrate_down(<<~EOS.strip)
+          change_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+        EOS
+      )
 
-    ### Limits
+      ### Limits
 
-    class Advert < ActiveRecord::Base
-      fields do
-        price :integer, null: true, limit: 2
+      class Advert < ActiveRecord::Base
+        fields do
+          price :integer, null: true, limit: 2
+        end
       end
-    end
 
-    up, _ = Generators::DeclareSchema::Migration::Migrator.run.tap do |migrations|
-      expect(migrations).to migrate_up("add_column :adverts, :price, :integer, limit: 2, null: true")
-    end
-
-    # Now run the migration, then change the limit:
-
-    ActiveRecord::Migration.class_eval(up)
-    class Advert < ActiveRecord::Base
-      fields do
-        price :integer, null: true, limit: 3
+      up, _ = Generators::DeclareSchema::Migration::Migrator.run.tap do |migrations|
+        expect(migrations).to migrate_up("add_column :adverts, :price, :integer, limit: 2, null: true")
       end
-    end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        change_column :adverts, :price, :integer, limit: 3, null: true
-      EOS
-      .and migrate_down(<<~EOS.strip)
-        change_column :adverts, :price, :integer, limit: 2, null: true
-      EOS
-    )
+      # Now run the migration, then change the limit:
 
-    ActiveRecord::Migration.class_eval("remove_column :adverts, :price")
-    class Advert < ActiveRecord::Base
-      fields do
-        price :decimal, precision: 4, scale: 1, null: true
+      ActiveRecord::Migration.class_eval(up)
+      class Advert < ActiveRecord::Base
+        fields do
+          price :integer, null: true, limit: 3
+        end
       end
-    end
 
-    # 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).
-    # If a `limit` is given, it will only be used in MySQL, to choose the smallest TEXT field that will accommodate
-    # that limit (0xff for TINYTEXT, 0xffff for TEXT, 0xffffff for MEDIUMTEXT, 0xffffffff for LONGTEXT).
-
-    if defined?(SQLite3)
-      expect(::DeclareSchema::Model::FieldSpec.mysql_text_limits?).to be_falsey
-    end
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up(<<~EOS.strip)
+          change_column :adverts, :price, :integer, limit: 3, null: true
+        EOS
+        .and migrate_down(<<~EOS.strip)
+          change_column :adverts, :price, :integer, limit: 2, null: true
+        EOS
+      )
 
-    class Advert < ActiveRecord::Base
-      fields do
-        notes :text
-        description :text, limit: 30000
+      ActiveRecord::Migration.class_eval("remove_column :adverts, :price")
+      class Advert < ActiveRecord::Base
+        fields do
+          price :decimal, precision: 4, scale: 1, null: true
+        end
       end
-    end
-
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        add_column :adverts, :price, :decimal, precision: 4, scale: 1, null: true
-        add_column :adverts, :notes, :text#{text_limit}, null: false#{charset_and_collation}
-        add_column :adverts, :description, :text#{', limit: 65535' if defined?(Mysql2)}, null: false#{charset_and_collation}
-      EOS
-    )
 
-    Advert.field_specs.delete :price
-    Advert.field_specs.delete :notes
-    Advert.field_specs.delete :description
+      # 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).
+      # If a `limit` is given, it will only be used in MySQL, to choose the smallest TEXT field that will accommodate
+      # that limit (0xff for TINYTEXT, 0xffff for TEXT, 0xffffff for MEDIUMTEXT, 0xffffffff for LONGTEXT).
 
-    # In MySQL, limits are applied, rounded up:
-
-    if defined?(Mysql2)
-      expect(::DeclareSchema::Model::FieldSpec.mysql_text_limits?).to be_truthy
+      if defined?(SQLite3)
+        expect(::DeclareSchema::Model::FieldSpec.mysql_text_limits?).to be_falsey
+      end
 
       class Advert < ActiveRecord::Base
         fields do
           notes :text
-          description :text, limit: 250
+          description :text, limit: 30000
         end
       end
 
       expect(Generators::DeclareSchema::Migration::Migrator.run).to(
         migrate_up(<<~EOS.strip)
-          add_column :adverts, :notes, :text, limit: 4294967295, null: false#{charset_and_collation}
-          add_column :adverts, :description, :text, limit: 255, null: false#{charset_and_collation}
+          add_column :adverts, :price, :decimal, precision: 4, scale: 1, null: true
+          add_column :adverts, :notes, :text#{text_limit}, null: false#{charset_and_collation}
+          add_column :adverts, :description, :text#{', limit: 65535' if defined?(Mysql2)}, null: false#{charset_and_collation}
         EOS
       )
 
+      Advert.field_specs.delete :price
       Advert.field_specs.delete :notes
+      Advert.field_specs.delete :description
+
+      # In MySQL, limits are applied, rounded up:
 
-      # Limits that are too high for MySQL will raise an exception.
+      if defined?(Mysql2)
+        expect(::DeclareSchema::Model::FieldSpec.mysql_text_limits?).to be_truthy
 
-      expect do
         class Advert < ActiveRecord::Base
           fields do
             notes :text
-            description :text, limit: 0x1_0000_0000
+            description :text, limit: 250
           end
         end
-      end.to raise_exception(ArgumentError, "limit of 4294967296 is too large for MySQL")
 
-      Advert.field_specs.delete :notes
+        expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+            add_column :adverts, :notes, :text, limit: 4294967295, null: false#{charset_and_collation}
+            add_column :adverts, :description, :text, limit: 255, null: false#{charset_and_collation}
+          EOS
+        )
+
+        Advert.field_specs.delete :notes
+
+        # Limits that are too high for MySQL will raise an exception.
+
+        expect do
+          class Advert < ActiveRecord::Base
+            fields do
+              notes :text
+              description :text, limit: 0x1_0000_0000
+            end
+          end
+        end.to raise_exception(ArgumentError, "limit of 4294967296 is too large for MySQL")
+
+        Advert.field_specs.delete :notes
+
+        # And in MySQL, unstated text limits are treated as the maximum (LONGTEXT) limit.
+
+        # To start, we'll set the database schema for `description` to match the above limit of 250.
+
+        Advert.connection.execute "ALTER TABLE adverts ADD COLUMN description TINYTEXT"
+        Advert.connection.schema_cache.clear!
+        Advert.reset_column_information
+        expect(Advert.connection.tables - Generators::DeclareSchema::Migration::Migrator.always_ignore_tables).
+          to eq(["adverts"])
+        expect(Advert.columns.map(&:name)).to eq(["id", "body", "title", "description"])
+
+        # Now migrate to an unstated text limit:
+
+        class Advert < ActiveRecord::Base
+          fields do
+            description :text
+          end
+        end
 
-      # And in MySQL, unstated text limits are treated as the maximum (LONGTEXT) limit.
+        expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+            change_column :adverts, :description, :text, limit: 4294967295, null: false#{charset_and_collation}
+          EOS
+          .and migrate_down(<<~EOS.strip)
+            change_column :adverts, :description, :text#{', limit: 255' if defined?(Mysql2)}, null: true#{charset_and_collation}
+          EOS
+        )
 
-      # To start, we'll set the database schema for `description` to match the above limit of 250.
+        # And migrate to a stated text limit that is the same as the unstated one:
 
-      Advert.connection.execute "ALTER TABLE adverts ADD COLUMN description TINYTEXT"
+        class Advert < ActiveRecord::Base
+          fields do
+            description :text, limit: 0xffffffff
+          end
+        end
+
+        expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+            change_column :adverts, :description, :text, limit: 4294967295, null: false#{charset_and_collation}
+          EOS
+          .and migrate_down(<<~EOS.strip)
+            change_column :adverts, :description, :text#{', limit: 255' if defined?(Mysql2)}, null: true#{charset_and_collation}
+          EOS
+        )
+      end
+
+      Advert.field_specs.clear
       Advert.connection.schema_cache.clear!
       Advert.reset_column_information
-      expect(Advert.connection.tables - Generators::DeclareSchema::Migration::Migrator.always_ignore_tables).
-        to eq(["adverts"])
-      expect(Advert.columns.map(&:name)).to eq(["id", "body", "title", "description"])
+      class Advert < ActiveRecord::Base
+        fields do
+          name :string, limit: 250, null: true
+        end
+      end
+
+      up = Generators::DeclareSchema::Migration::Migrator.run.first
+      ActiveRecord::Migration.class_eval up
+
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
+
+      ### Foreign Keys
+
+      # DeclareSchema extends the `belongs_to` macro so that it also declares the
+      # foreign-key field.  It also generates an index on the field.
+
+      class Category < ActiveRecord::Base; end
+      class Advert < ActiveRecord::Base
+        fields do
+          name :string, limit: 250, null: true
+        end
+        belongs_to :category
+      end
+
+      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'
+
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" if defined?(Mysql2)}
+        EOS
+        .and migrate_down(<<~EOS.strip)
+          remove_column :adverts, :category_id
+
+          remove_index :adverts, name: :on_category_id rescue ActiveRecord::StatementInvalid
+
+          #{"remove_foreign_key(\"adverts\", name: \"on_category_id\")\n" if defined?(Mysql2)}
+        EOS
+      )
+
+      Advert.field_specs.delete(: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
+
+      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'
+
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+            "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
+        EOS
+      )
+
+      Advert.field_specs.delete(:c_id)
+      Advert.index_definitions.delete_if { |spec| spec.fields == ["c_id"] }
 
-      # Now migrate to an unstated text limit:
+      # 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
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up(<<~EOS.strip)
+          add_column :adverts, :category_id, :integer, limit: 8, null: false
+
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+            "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
+        EOS
+      )
+
+      Advert.field_specs.delete(: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
+
+      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'
+
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+            "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
+        EOS
+      )
+
+      Advert.field_specs.delete(:category_id)
+      Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
+
+      ### Timestamps and Optimimistic Locking
+
+      # `updated_at` and `created_at` can be declared with the shorthand `timestamps`.
+      # Similarly, `lock_version` can be declared with the "shorthand" `optimimistic_lock`.
 
       class Advert < ActiveRecord::Base
         fields do
-          description :text
+          timestamps
+          optimistic_lock
         end
       end
 
       expect(Generators::DeclareSchema::Migration::Migrator.run).to(
         migrate_up(<<~EOS.strip)
-          change_column :adverts, :description, :text, limit: 4294967295, null: false#{charset_and_collation}
+          add_column :adverts, :created_at, :datetime, null: true
+          add_column :adverts, :updated_at, :datetime, null: true
+          add_column :adverts, :lock_version, :integer#{lock_version_limit}, null: false, default: 1
+  
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+            "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
         EOS
         .and migrate_down(<<~EOS.strip)
-          change_column :adverts, :description, :text#{', limit: 255' if defined?(Mysql2)}, null: true#{charset_and_collation}
+          remove_column :adverts, :created_at
+          remove_column :adverts, :updated_at
+          remove_column :adverts, :lock_version
+
+          #{"remove_foreign_key(\"adverts\", name: \"on_category_id\")\n" +
+            "remove_foreign_key(\"adverts\", name: \"on_c_id\")" if defined?(Mysql2)}
+        EOS
+      )
+
+      Advert.field_specs.delete(:updated_at)
+      Advert.field_specs.delete(:created_at)
+      Advert.field_specs.delete(:lock_version)
+
+      ### Indices
+
+      # You can add an index to a field definition
+
+      class Advert < ActiveRecord::Base
+        fields do
+          title :string, index: true, limit: 250, null: true
+        end
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+
+          add_index :adverts, [:title], name: 'on_title'
+
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+            "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
+        EOS
+      )
+
+      Advert.index_definitions.delete_if { |spec| spec.fields==["title"] }
+
+      # You can ask for a unique index
+
+      class Advert < ActiveRecord::Base
+        fields do
+          title :string, index: true, unique: true, null: true, limit: 250
+        end
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+
+          add_index :adverts, [:title], unique: true, name: 'on_title'
+
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+            "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
+        EOS
+      )
+
+      Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
+
+      # You can specify the name for the index
+
+      class Advert < ActiveRecord::Base
+        fields do
+          title :string, index: 'my_index', limit: 250, null: true
+        end
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+
+          add_index :adverts, [:title], name: 'my_index'
+
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+            "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
+        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
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+
+          add_index :adverts, [:title], name: 'on_title'
+
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+            "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
         EOS
       )
 
-      # And migrate to a stated text limit that is the same as the unstated one:
+      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
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+
+          add_index :adverts, [:title], unique: true, name: 'my_index'
+
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+            "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
+        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
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+
+          add_index :adverts, [:title, :category_id], name: 'on_title_and_category_id'
+
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+            "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
+        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.
+      # This is helpful for preserving indices that can't be automatically generated, such as prefix indices in MySQL.
+
+      ### Rename a table
+
+      # The migration generator respects the `set_table_name` declaration, although as before, we need to explicitly tell the generator that we want a rename rather than a create and a drop.
+
+      class Advert < ActiveRecord::Base
+        self.table_name = "ads"
+        fields do
+          title :string, limit: 250, null: true
+          body :text, null: true
+        end
+      end
+
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run("adverts" => "ads")).to(
+        migrate_up(<<~EOS.strip)
+          rename_table :adverts, :ads
+
+          add_column :ads, :title, :string, limit: 250, null: true#{charset_and_collation}
+          add_column :ads, :body, :text#{', limit: 4294967295' if defined?(Mysql2)}, null: true#{charset_and_collation}
+
+          #{if defined?(SQLite3)
+              "add_index :ads, [:id], unique: true, name: 'PRIMARY'\n"
+            elsif defined?(Mysql2)
+              "execute \"ALTER TABLE ads DROP PRIMARY KEY, ADD PRIMARY KEY (id)\"\n\n" +
+              "add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+              "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")"
+            end}
+        EOS
+        .and migrate_down(<<~EOS.strip)
+          remove_column :ads, :title
+          remove_column :ads, :body
+
+          rename_table :ads, :adverts
+
+          #{if defined?(SQLite3)
+              "add_index :adverts, [:id], unique: true, name: 'PRIMARY'\n"
+            elsif defined?(Mysql2)
+              "execute \"ALTER TABLE adverts DROP PRIMARY KEY, ADD PRIMARY KEY (id)\"\n\n" +
+              "remove_foreign_key(\"adverts\", name: \"on_category_id\")\n" +
+              "remove_foreign_key(\"adverts\", name: \"on_c_id\")"
+            end}
+        EOS
+      )
+
+      # Set the table name back to what it should be and confirm we're in sync:
+
+      nuke_model_class(Advert)
+
+      class Advert < ActiveRecord::Base
+        self.table_name = "adverts"
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to eq(["", ""])
+
+      ### Rename a table
+
+      # As with renaming columns, we have to tell the migration generator about the rename. Here we create a new class 'Advertisement', and tell ActiveRecord to forget about the Advert class. This requires code that shouldn't be shown to impressionable children.
+
+      nuke_model_class(Advert)
+
+      class Advertisement < ActiveRecord::Base
+        fields do
+          title :string, limit: 250, null: true
+          body :text, null: true
+        end
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run("adverts" => "advertisements")).to(
+        migrate_up(<<~EOS.strip)
+          rename_table :adverts, :advertisements
+
+          add_column :advertisements, :title, :string, limit: 250, null: true#{charset_and_collation}
+          add_column :advertisements, :body, :text#{', limit: 4294967295' if defined?(Mysql2)}, null: true#{charset_and_collation}
+          remove_column :advertisements, :name
+
+          #{if defined?(SQLite3)
+              "add_index :advertisements, [:id], unique: true, name: 'PRIMARY'"
+            elsif defined?(Mysql2)
+              "execute \"ALTER TABLE advertisements DROP PRIMARY KEY, ADD PRIMARY KEY (id)\""
+            end}
+        EOS
+        .and migrate_down(<<~EOS.strip)
+          remove_column :advertisements, :title
+          remove_column :advertisements, :body
+          add_column :adverts, :name, :string, limit: 250, null: true#{charset_and_collation}
+
+          rename_table :advertisements, :adverts
+
+          #{if defined?(SQLite3)
+              "add_index :adverts, [:id], unique: true, name: 'PRIMARY'"
+            elsif defined?(Mysql2)
+              "execute \"ALTER TABLE adverts DROP PRIMARY KEY, ADD PRIMARY KEY (id)\""
+            end}
+        EOS
+      )
+
+      ### Drop a table
+
+      nuke_model_class(Advertisement)
+
+      # If you delete a model, the migration generator will create a `drop_table` migration.
+
+      # Dropping tables is where the automatic down-migration really comes in handy:
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+        migrate_up(<<~EOS.strip)
+          drop_table :adverts
+        EOS
+        .and migrate_down(<<~EOS.strip)
+          create_table "adverts"#{table_options}, force: :cascade do |t|
+            t.string "name", limit: 250#{charset_and_collation}
+          end
+        EOS
+      )
+
+      ## STI
+
+      ### Adding an STI subclass
+
+      # Adding a subclass or two should introduce the 'type' column and no other changes
+
+      class Advert < ActiveRecord::Base
+        fields do
+          body :text, null: true
+          title :string, default: "Untitled", limit: 250, null: true
+        end
+      end
+      up = Generators::DeclareSchema::Migration::Migrator.run.first
+      ActiveRecord::Migration.class_eval(up)
+
+      class FancyAdvert < Advert
+      end
+      class SuperFancyAdvert < FancyAdvert
+      end
+
+      up, _ = Generators::DeclareSchema::Migration::Migrator.run do |migrations|
+        expect(migrations).to(
+          migrate_up(<<~EOS.strip)
+            add_column :adverts, :type, :string, limit: 250, null: true#{charset_and_collation}
+
+            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_definitions.delete_if { |spec| spec.fields==["type"] }
+
+      ## Coping with multiple changes
+
+      # The migration generator is designed to create complete migrations even if many changes to the models have taken place.
+
+      # First let's confirm we're in a known state. One model, 'Advert', with a string 'title' and text 'body':
+
+      ActiveRecord::Migration.class_eval up.gsub(/.*type.*/, '')
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
+
+      expect(Advert.connection.tables - Generators::DeclareSchema::Migration::Migrator.always_ignore_tables).
+        to eq(["adverts"])
+      expect(Advert.columns.map(&:name).sort).to eq(["body", "id", "title"])
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to eq(["", ""])
+
+
+      ### Rename a column and change the default
+
+      Advert.field_specs.clear
+
+      class Advert < ActiveRecord::Base
+        fields do
+          name :string, default: "No Name", limit: 250, null: true
+          body :text, null: true
+        end
+      end
+
+      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: 250, null: true, default: "No Name"#{charset_and_collation}
+        EOS
+        .and migrate_down(<<~EOS.strip)
+          rename_column :adverts, :name, :title
+          change_column :adverts, :title, :string, limit: 250, null: true, default: "Untitled"#{charset_and_collation}
+        EOS
+      )
+
+      ### Rename a table and add a column
+
+      nuke_model_class(Advert)
+      class Ad < ActiveRecord::Base
+        fields do
+          title      :string, default: "Untitled", limit: 250
+          body       :text, null: true
+          created_at :datetime
+        end
+      end
+
+      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: 250, null: false, default: \"Untitled\"#{charset_and_collation}
+
+          #{if defined?(SQLite3)
+              "add_index :ads, [:id], unique: true, name: 'PRIMARY'"
+            elsif defined?(Mysql2)
+              'execute "ALTER TABLE ads DROP PRIMARY KEY, ADD PRIMARY KEY (id)"'
+            end}
+        EOS
+      )
+
+      class Advert < ActiveRecord::Base
+        fields do
+          body :text, null: true
+          title :string, default: "Untitled", limit: 250, null: true
+        end
+      end
+
+      ## Legacy Keys
+
+      # DeclareSchema has some support for legacy keys.
+
+      nuke_model_class(Ad)
+
+      class Advert < ActiveRecord::Base
+        fields do
+          body :text, null: true
+        end
+        self.primary_key = "advert_id"
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run(adverts: { id: :advert_id })).to(
+        migrate_up(<<~EOS.strip)
+          rename_column :adverts, :id, :advert_id
+
+          #{if defined?(SQLite3)
+              "add_index :adverts, [:advert_id], unique: true, name: 'PRIMARY'"
+            elsif defined?(Mysql2)
+            'execute "ALTER TABLE adverts DROP PRIMARY KEY, ADD PRIMARY KEY (advert_id)"'
+            end}
+        EOS
+      )
+
+      nuke_model_class(Advert)
+      ActiveRecord::Base.connection.execute("drop table `adverts`;")
+
+      ## DSL
+
+      # The DSL allows lambdas and constants
+
+      class User < ActiveRecord::Base
+        fields do
+          company :string, limit: 250, ruby_default: -> { "BigCorp" }
+        end
+      end
+      expect(User.field_specs.keys).to eq(['company'])
+      expect(User.field_specs['company'].options[:ruby_default]&.call).to eq("BigCorp")
+
+      ## validates
+
+      # DeclareSchema can accept a validates hash in the field options.
+
+      class Ad < ActiveRecord::Base
+        class << self
+          def validates(field_name, options)
+          end
+        end
+      end
+      expect(Ad).to receive(:validates).with(:company, presence: true, uniqueness: { case_sensitive: false })
+      class Ad < ActiveRecord::Base
+        fields do
+          company :string, limit: 250, index: true, unique: true, validates: { presence: true, uniqueness: { case_sensitive: false } }
+        end
+        self.primary_key = "advert_id"
+      end
+      up, _down = Generators::DeclareSchema::Migration::Migrator.run
+      ActiveRecord::Migration.class_eval(up)
+      expect(Ad.field_specs['company'].options[:validates].inspect).to eq("{:presence=>true, :uniqueness=>{:case_sensitive=>false}}")
+    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: 250, serialize: true, null: true, default: []
+              allow_hash :string, limit: 250, serialize: true, null: true, default: {}
+              allow_string :string, limit: 250, serialize: true, null: true, default: ['abc']
+              allow_null :string, limit: 250, 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: 250, 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: 250, serialize: Array, null: true, default: [2]
+              allow_string :string, limit: 250, serialize: Array, null: true, default: ['abc']
+              allow_empty :string, limit: 250, serialize: Array, null: true, default: []
+              allow_null :string, limit: 250, 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: 250, 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: 250, serialize: Hash, null: true, default: { 'state' => 'CA' }
+              allow_hash :string, limit: 250, serialize: Hash, null: true, default: {}
+              allow_null :string, limit: 250, 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: 250, 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: 250, serialize: JSON, null: true, default: { 'state' => 'CA' }
+              allow_empty_array :string, limit: 250, serialize: JSON, null: true, default: []
+              allow_empty_hash :string, limit: 250, serialize: JSON, null: true, default: {}
+              allow_null :string, limit: 250, 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: 250, 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: 250, serialize: ValueClass, null: true, default: ValueClass.new([2])
+              allow_empty_array :string, limit: 250, serialize: ValueClass, null: true, default: ValueClass.new([])
+              allow_null :string, limit: 250, 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: 250, 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
+
+    context 'Does not generate migrations' do
+      it 'for aliased fields bigint -> integer limit 8' do
+        if Rails::VERSION::MAJOR >= 5 || !ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
+          class Advert < active_record_base_class.constantize
+            fields do
+              price :bigint
+            end
+          end
+
+          generate_migrations '-n', '-m'
+
+          migrations = Dir.glob('db/migrate/*declare_schema_migration*.rb')
+          expect(migrations.size).to eq(1), migrations.inspect
+
+          if defined?(Mysql2) && Rails::VERSION::MAJOR < 5
+            ActiveRecord::Base.connection.execute("ALTER TABLE adverts ADD PRIMARY KEY (id)")
+          end
+
+          class Advert < active_record_base_class.constantize
+            fields do
+              price :integer, limit: 8
+            end
+          end
+
+          expect { generate_migrations '-n', '-g' }.to output("Database and models match -- nothing to change\n").to_stdout
+        end
+      end
+    end
+  end
+
+  context 'Using declare_schema' do
+    # DeclareSchema - Migration Generator
+    it 'generates migrations' do
+      ## The migration generator -- introduction
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to migrate_up("").and migrate_down("")
+
+      class Advert < ActiveRecord::Base
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to migrate_up("").and migrate_down("")
+
+      Generators::DeclareSchema::Migration::Migrator.ignore_tables = ["green_fishes"]
+
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
+
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          string :name, limit: 250, null: true
+        end
+      end
+
+      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: 250, null: true#{charset_and_collation}
+            end#{charset_alter_table}
+            EOS
+                .and migrate_down("drop_table :adverts")
+        )
+      end
+
+      ActiveRecord::Migration.class_eval(up)
+      expect(Advert.columns.map(&:name)).to eq(["id", "name"])
+
+      if Rails::VERSION::MAJOR < 5
+        # Rails 4 drivers don't always create PK properly. Fix that by dropping and recreating.
+        ActiveRecord::Base.connection.execute("drop table adverts")
+        if defined?(Mysql2)
+          ActiveRecord::Base.connection.execute("CREATE TABLE adverts (id integer PRIMARY KEY AUTO_INCREMENT NOT NULL, name varchar(250)) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin")
+        else
+          ActiveRecord::Base.connection.execute("CREATE TABLE adverts (id integer PRIMARY KEY AUTOINCREMENT  NOT NULL, name varchar(250))")
+        end
+      end
+
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          string :name, limit: 250, null: true
+          text :body, null: true
+          datetime :published_at, null: true
+        end
+      end
+
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
+
+      expect(migrate).to(
+          migrate_up(<<~EOS.strip)
+          add_column :adverts, :body, :text#{text_limit}, null: true#{charset_and_collation}
+          add_column :adverts, :published_at, :datetime, null: true
+          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
+        declare_schema do
+          string :name, limit: 250, null: true
+          text :body, null: true
+        end
+      end
+
+      expect(migrate).to(
+          migrate_up("remove_column :adverts, :published_at").and(
+              migrate_down("add_column :adverts, :published_at, :datetime#{datetime_precision}, null: true")
+          )
+      )
+
+      nuke_model_class(Advert)
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          string :title, limit: 250, null: true
+          text :body, null: true
+        end
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+          remove_column :adverts, :name
+          EOS
+              .and migrate_down(<<~EOS.strip)
+          remove_column :adverts, :title
+          add_column :adverts, :name, :string, limit: 250, null: true#{charset_and_collation}
+      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
+
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          text :title, null: true
+          text :body, null: true
+        end
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up("change_column :adverts, :title, :text#{text_limit}, null: true#{charset_and_collation}").and(
+              migrate_down("change_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}")
+          )
+      )
+
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          string :title, default: "Untitled", limit: 250, null: true
+          text :body, null: true
+        end
+      end
+
+      expect(migrate).to(
+          migrate_up(<<~EOS.strip)
+          change_column :adverts, :title, :string, limit: 250, null: true, default: "Untitled"#{charset_and_collation}
+          EOS
+              .and migrate_down(<<~EOS.strip)
+          change_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+      EOS
+      )
+
+      ### Limits
+
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          integer :price, null: true, limit: 2
+        end
+      end
+
+      up, _ = Generators::DeclareSchema::Migration::Migrator.run.tap do |migrations|
+        expect(migrations).to migrate_up("add_column :adverts, :price, :integer, limit: 2, null: true")
+      end
+
+      # Now run the migration, then change the limit:
+
+      ActiveRecord::Migration.class_eval(up)
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          integer :price, null: true, limit: 3
+        end
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+          change_column :adverts, :price, :integer, limit: 3, null: true
+          EOS
+              .and migrate_down(<<~EOS.strip)
+          change_column :adverts, :price, :integer, limit: 2, null: true
+      EOS
+      )
+
+      ActiveRecord::Migration.class_eval("remove_column :adverts, :price")
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          decimal :price, precision: 4, scale: 1, null: true
+        end
+      end
+
+      # 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).
+      # If a `limit` is given, it will only be used in MySQL, to choose the smallest TEXT field that will accommodate
+      # that limit (0xff for TINYTEXT, 0xffff for TEXT, 0xffffff for MEDIUMTEXT, 0xffffffff for LONGTEXT).
+
+      if defined?(SQLite3)
+        expect(::DeclareSchema::Model::FieldSpec.mysql_text_limits?).to be_falsey
+      end
+
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          text :notes
+          text :description, limit: 30000
+        end
+      end
+
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+          add_column :adverts, :price, :decimal, precision: 4, scale: 1, null: true
+          add_column :adverts, :notes, :text#{text_limit}, null: false#{charset_and_collation}
+          add_column :adverts, :description, :text#{', limit: 65535' if defined?(Mysql2)}, null: false#{charset_and_collation}
+      EOS
+      )
+
+      Advert.field_specs.delete :price
+      Advert.field_specs.delete :notes
+      Advert.field_specs.delete :description
+
+      # In MySQL, limits are applied, rounded up:
+
+      if defined?(Mysql2)
+        expect(::DeclareSchema::Model::FieldSpec.mysql_text_limits?).to be_truthy
+
+        class Advert < ActiveRecord::Base
+          declare_schema do
+            text :notes
+            text :description, limit: 250
+          end
+        end
+
+        expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+            migrate_up(<<~EOS.strip)
+            add_column :adverts, :notes, :text, limit: 4294967295, null: false#{charset_and_collation}
+            add_column :adverts, :description, :text, limit: 255, null: false#{charset_and_collation}
+        EOS
+        )
+
+        Advert.field_specs.delete :notes
+
+        # Limits that are too high for MySQL will raise an exception.
+
+        expect do
+          class Advert < ActiveRecord::Base
+            declare_schema do
+              text :notes
+              text :description, limit: 0x1_0000_0000
+            end
+          end
+        end.to raise_exception(ArgumentError, "limit of 4294967296 is too large for MySQL")
+
+        Advert.field_specs.delete :notes
+
+        # And in MySQL, unstated text limits are treated as the maximum (LONGTEXT) limit.
+
+        # To start, we'll set the database schema for `description` to match the above limit of 250.
+
+        Advert.connection.execute "ALTER TABLE adverts ADD COLUMN description TINYTEXT"
+        Advert.connection.schema_cache.clear!
+        Advert.reset_column_information
+        expect(Advert.connection.tables - Generators::DeclareSchema::Migration::Migrator.always_ignore_tables).
+            to eq(["adverts"])
+        expect(Advert.columns.map(&:name)).to eq(["id", "body", "title", "description"])
+
+        # Now migrate to an unstated text limit:
+
+        class Advert < ActiveRecord::Base
+          declare_schema do
+            text :description
+          end
+        end
+
+        expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+            migrate_up(<<~EOS.strip)
+            change_column :adverts, :description, :text, limit: 4294967295, null: false#{charset_and_collation}
+            EOS
+                .and migrate_down(<<~EOS.strip)
+            change_column :adverts, :description, :text#{', limit: 255' if defined?(Mysql2)}, null: true#{charset_and_collation}
+        EOS
+        )
+
+        # And migrate to a stated text limit that is the same as the unstated one:
 
-      class Advert < ActiveRecord::Base
-        fields do
-          description :text, limit: 0xffffffff
+        class Advert < ActiveRecord::Base
+          declare_schema do
+            text :description, limit: 0xffffffff
+          end
         end
-      end
 
-      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-        migrate_up(<<~EOS.strip)
-          change_column :adverts, :description, :text, limit: 4294967295, null: false#{charset_and_collation}
-        EOS
-        .and migrate_down(<<~EOS.strip)
-          change_column :adverts, :description, :text#{', limit: 255' if defined?(Mysql2)}, null: true#{charset_and_collation}
+        expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+            migrate_up(<<~EOS.strip)
+            change_column :adverts, :description, :text, limit: 4294967295, null: false#{charset_and_collation}
+            EOS
+                .and migrate_down(<<~EOS.strip)
+            change_column :adverts, :description, :text#{', limit: 255' if defined?(Mysql2)}, null: true#{charset_and_collation}
         EOS
-      )
-    end
+        )
+      end
 
-    Advert.field_specs.clear
-    Advert.connection.schema_cache.clear!
-    Advert.reset_column_information
-    class Advert < ActiveRecord::Base
-      fields do
-        name :string, limit: 250, null: true
+      Advert.field_specs.clear
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          string :name, limit: 250, null: true
+        end
       end
-    end
 
-    up = Generators::DeclareSchema::Migration::Migrator.run.first
-    ActiveRecord::Migration.class_eval up
+      up = Generators::DeclareSchema::Migration::Migrator.run.first
+      ActiveRecord::Migration.class_eval up
 
-    Advert.connection.schema_cache.clear!
-    Advert.reset_column_information
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
 
-    ### Foreign Keys
+      ### Foreign Keys
 
-    # DeclareSchema extends the `belongs_to` macro so that it also declares the
-    # foreign-key field.  It also generates an index on the field.
+      # DeclareSchema extends the `belongs_to` macro so that it also declares the
+      # foreign-key field.  It also generates an index on the field.
 
-    class Category < ActiveRecord::Base; end
-    class Advert < ActiveRecord::Base
-      fields do
-        name :string, limit: 250, null: true
+      class Category < ActiveRecord::Base; end
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          string :name, limit: 250, null: true
+        end
+        belongs_to :category
       end
-      belongs_to :category
-    end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        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
 
-        add_index :adverts, [:category_id], name: 'on_category_id'
+          add_index :adverts, [:category_id], name: 'on_category_id'
 
-        #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" if defined?(Mysql2)}
-      EOS
-      .and migrate_down(<<~EOS.strip)
-        remove_column :adverts, :category_id
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" if defined?(Mysql2)}
+          EOS
+              .and migrate_down(<<~EOS.strip)
+          remove_column :adverts, :category_id
 
-        remove_index :adverts, name: :on_category_id rescue ActiveRecord::StatementInvalid
+          remove_index :adverts, name: :on_category_id rescue ActiveRecord::StatementInvalid
 
-        #{"remove_foreign_key(\"adverts\", name: \"on_category_id\")\n" if defined?(Mysql2)}
+          #{"remove_foreign_key(\"adverts\", name: \"on_category_id\")\n" if defined?(Mysql2)}
       EOS
-    )
+      )
 
-    Advert.field_specs.delete(:category_id)
-    Advert.index_definitions.delete_if { |spec| spec.fields==["category_id"] }
+      Advert.field_specs.delete(:category_id)
+      Advert.index_definitions.delete_if { |spec| spec.fields==["category_id"] }
 
-    # If you specify a custom foreign key, the migration generator observes that:
+      # 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
+      class Category < ActiveRecord::Base; end
+      class Advert < ActiveRecord::Base
+        declare_schema { }
+        belongs_to :category, foreign_key: "c_id", class_name: 'Category'
+      end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        add_column :adverts, :c_id, :integer, limit: 8, null: false
+      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'
+          add_index :adverts, [:c_id], name: 'on_c_id'
 
-        #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
           "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
       EOS
-    )
+      )
 
-    Advert.field_specs.delete(:c_id)
-    Advert.index_definitions.delete_if { |spec| spec.fields == ["c_id"] }
+      Advert.field_specs.delete(:c_id)
+      Advert.index_definitions.delete_if { |spec| spec.fields == ["c_id"] }
 
-    # You can avoid generating the index by specifying `index: false`
+      # 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
+      class Category < ActiveRecord::Base; end
+      class Advert < ActiveRecord::Base
+        declare_schema { }
+        belongs_to :category, index: false
+      end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        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
 
-        #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
           "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
       EOS
-    )
+      )
 
-    Advert.field_specs.delete(:category_id)
-    Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
+      Advert.field_specs.delete(:category_id)
+      Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
 
-    # You can specify the index name with :index
+      # 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
+      class Category < ActiveRecord::Base; end
+      class Advert < ActiveRecord::Base
+        declare_schema { }
+        belongs_to :category, index: 'my_index'
+      end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        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
 
-        add_index :adverts, [:category_id], name: 'my_index'
+          add_index :adverts, [:category_id], name: 'my_index'
 
-        #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
           "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
       EOS
-    )
+      )
 
-    Advert.field_specs.delete(:category_id)
-    Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
+      Advert.field_specs.delete(:category_id)
+      Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
 
-    ### Timestamps and Optimimistic Locking
+      ### Timestamps and Optimimistic Locking
 
-    # `updated_at` and `created_at` can be declared with the shorthand `timestamps`.
-    # Similarly, `lock_version` can be declared with the "shorthand" `optimimistic_lock`.
+      # `updated_at` and `created_at` can be declared with the shorthand `timestamps`.
+      # Similarly, `lock_version` can be declared with the "shorthand" `optimimistic_lock`.
 
-    class Advert < ActiveRecord::Base
-      fields do
-        timestamps
-        optimistic_lock
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          timestamps
+          optimistic_lock
+        end
       end
-    end
-
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        add_column :adverts, :created_at, :datetime, null: true
-        add_column :adverts, :updated_at, :datetime, null: true
-        add_column :adverts, :lock_version, :integer#{lock_version_limit}, null: false, default: 1
-
-        #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
-          "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
-      EOS
-      .and migrate_down(<<~EOS.strip)
-        remove_column :adverts, :created_at
-        remove_column :adverts, :updated_at
-        remove_column :adverts, :lock_version
 
-        #{"remove_foreign_key(\"adverts\", name: \"on_category_id\")\n" +
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+          add_column :adverts, :created_at, :datetime, null: true
+          add_column :adverts, :updated_at, :datetime, null: true
+          add_column :adverts, :lock_version, :integer#{lock_version_limit}, null: false, default: 1
+  
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+              "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
+          EOS
+              .and migrate_down(<<~EOS.strip)
+          remove_column :adverts, :created_at
+          remove_column :adverts, :updated_at
+          remove_column :adverts, :lock_version
+
+          #{"remove_foreign_key(\"adverts\", name: \"on_category_id\")\n" +
           "remove_foreign_key(\"adverts\", name: \"on_c_id\")" if defined?(Mysql2)}
       EOS
-    )
+      )
 
-    Advert.field_specs.delete(:updated_at)
-    Advert.field_specs.delete(:created_at)
-    Advert.field_specs.delete(:lock_version)
+      Advert.field_specs.delete(:updated_at)
+      Advert.field_specs.delete(:created_at)
+      Advert.field_specs.delete(:lock_version)
 
-    ### Indices
+      ### Indices
 
-    # You can add an index to a field definition
+      # You can add an index to a field definition
 
-    class Advert < ActiveRecord::Base
-      fields do
-        title :string, index: true, limit: 250, null: true
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          string :title, index: true, limit: 250, null: true
+        end
       end
-    end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
 
-        add_index :adverts, [:title], name: 'on_title'
+          add_index :adverts, [:title], name: 'on_title'
 
-        #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
           "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
       EOS
-    )
+      )
 
-    Advert.index_definitions.delete_if { |spec| spec.fields==["title"] }
+      Advert.index_definitions.delete_if { |spec| spec.fields==["title"] }
 
-    # You can ask for a unique index
+      # You can ask for a unique index
 
-    class Advert < ActiveRecord::Base
-      fields do
-        title :string, index: true, unique: true, null: true, limit: 250
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          string :title, index: true, unique: true, null: true, limit: 250
+        end
       end
-    end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
 
-        add_index :adverts, [:title], unique: true, name: 'on_title'
+          add_index :adverts, [:title], unique: true, name: 'on_title'
 
-        #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
           "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
       EOS
-    )
+      )
 
-    Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
+      Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
 
-    # You can specify the name for the index
+      # You can specify the name for the index
 
-    class Advert < ActiveRecord::Base
-      fields do
-        title :string, index: 'my_index', limit: 250, null: true
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          string :title, index: 'my_index', limit: 250, null: true
+        end
       end
-    end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
 
-        add_index :adverts, [:title], name: 'my_index'
+          add_index :adverts, [:title], name: 'my_index'
 
-        #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
           "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
       EOS
-    )
+      )
 
-    Advert.index_definitions.delete_if { |spec| spec.fields==["title"] }
+      Advert.index_definitions.delete_if { |spec| spec.fields==["title"] }
 
-    # You can ask for an index outside of the fields block
+      # You can ask for an index outside of the fields block
 
-    class Advert < ActiveRecord::Base
-      index :title
-    end
+      class Advert < ActiveRecord::Base
+        index :title
+      end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
 
-        add_index :adverts, [:title], name: 'on_title'
+          add_index :adverts, [:title], name: 'on_title'
 
-        #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
           "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
       EOS
-    )
+      )
 
-    Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
+      Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
 
-    # The available options for the index function are `:unique` and `:name`
+      # The available options for the index function are `:unique` and `:name`
 
-    class Advert < ActiveRecord::Base
-      index :title, unique: true, name: 'my_index'
-    end
+      class Advert < ActiveRecord::Base
+        index :title, unique: true, name: 'my_index'
+      end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
 
-        add_index :adverts, [:title], unique: true, name: 'my_index'
+          add_index :adverts, [:title], unique: true, name: 'my_index'
 
-        #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
           "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
       EOS
-    )
+      )
 
-    Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
+      Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
 
-    # You can create an index on more than one field
+      # You can create an index on more than one field
 
-    class Advert < ActiveRecord::Base
-      index [:title, :category_id]
-    end
+      class Advert < ActiveRecord::Base
+        index [:title, :category_id]
+      end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+          add_column :adverts, :title, :string, limit: 250, null: true#{charset_and_collation}
 
-        add_index :adverts, [:title, :category_id], name: 'on_title_and_category_id'
+          add_index :adverts, [:title, :category_id], name: 'on_title_and_category_id'
 
-        #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+          #{"add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
           "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")" if defined?(Mysql2)}
       EOS
-    )
+      )
 
-    Advert.index_definitions.delete_if { |spec| spec.fields==["title", "category_id"] }
+      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.
-    # This is helpful for preserving indices that can't be automatically generated, such as prefix indices in MySQL.
+      # Finally, you can specify that the migration generator should completely ignore an
+      # index by passing its name to ignore_index in the model.
+      # This is helpful for preserving indices that can't be automatically generated, such as prefix indices in MySQL.
 
-    ### Rename a table
+      ### Rename a table
 
-    # The migration generator respects the `set_table_name` declaration, although as before, we need to explicitly tell the generator that we want a rename rather than a create and a drop.
+      # The migration generator respects the `set_table_name` declaration, although as before, we need to explicitly tell the generator that we want a rename rather than a create and a drop.
 
-    class Advert < ActiveRecord::Base
-      self.table_name = "ads"
-      fields do
-        title :string, limit: 250, null: true
-        body :text, null: true
+      class Advert < ActiveRecord::Base
+        self.table_name = "ads"
+        declare_schema do
+          string :title, limit: 250, null: true
+          text :body, null: true
+        end
       end
-    end
-
-    Advert.connection.schema_cache.clear!
-    Advert.reset_column_information
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run("adverts" => "ads")).to(
-      migrate_up(<<~EOS.strip)
-        rename_table :adverts, :ads
-
-        add_column :ads, :title, :string, limit: 250, null: true#{charset_and_collation}
-        add_column :ads, :body, :text#{', limit: 4294967295' if defined?(Mysql2)}, null: true#{charset_and_collation}
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
 
-        #{if defined?(SQLite3)
-            "add_index :ads, [:id], unique: true, name: 'PRIMARY'\n"
-          elsif defined?(Mysql2)
-            "execute \"ALTER TABLE ads DROP PRIMARY KEY, ADD PRIMARY KEY (id)\"\n\n" +
-            "add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
-            "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")"
-          end}
-      EOS
-      .and migrate_down(<<~EOS.strip)
-        remove_column :ads, :title
-        remove_column :ads, :body
-
-        rename_table :ads, :adverts
-
-        #{if defined?(SQLite3)
-            "add_index :adverts, [:id], unique: true, name: 'PRIMARY'\n"
-          elsif defined?(Mysql2)
-            "execute \"ALTER TABLE adverts DROP PRIMARY KEY, ADD PRIMARY KEY (id)\"\n\n" +
-            "remove_foreign_key(\"adverts\", name: \"on_category_id\")\n" +
-            "remove_foreign_key(\"adverts\", name: \"on_c_id\")"
-          end}
+      expect(Generators::DeclareSchema::Migration::Migrator.run("adverts" => "ads")).to(
+          migrate_up(<<~EOS.strip)
+          rename_table :adverts, :ads
+
+          add_column :ads, :title, :string, limit: 250, null: true#{charset_and_collation}
+          add_column :ads, :body, :text#{', limit: 4294967295' if defined?(Mysql2)}, null: true#{charset_and_collation}
+
+          #{if defined?(SQLite3)
+                                                                                                                                                                                                                               "add_index :ads, [:id], unique: true, name: 'PRIMARY'\n"
+            elsif defined?(Mysql2)
+              "execute \"ALTER TABLE ads DROP PRIMARY KEY, ADD PRIMARY KEY (id)\"\n\n" +
+                  "add_foreign_key(\"adverts\", \"categories\", column: \"category_id\", name: \"on_category_id\")\n" +
+                  "add_foreign_key(\"adverts\", \"categories\", column: \"c_id\", name: \"on_c_id\")"
+            end}
+          EOS
+              .and migrate_down(<<~EOS.strip)
+          remove_column :ads, :title
+          remove_column :ads, :body
+
+          rename_table :ads, :adverts
+
+          #{if defined?(SQLite3)
+              "add_index :adverts, [:id], unique: true, name: 'PRIMARY'\n"
+            elsif defined?(Mysql2)
+              "execute \"ALTER TABLE adverts DROP PRIMARY KEY, ADD PRIMARY KEY (id)\"\n\n" +
+                  "remove_foreign_key(\"adverts\", name: \"on_category_id\")\n" +
+                  "remove_foreign_key(\"adverts\", name: \"on_c_id\")"
+            end}
       EOS
-    )
+      )
 
-    # Set the table name back to what it should be and confirm we're in sync:
+      # Set the table name back to what it should be and confirm we're in sync:
 
-    nuke_model_class(Advert)
+      nuke_model_class(Advert)
 
-    class Advert < ActiveRecord::Base
-      self.table_name = "adverts"
-    end
+      class Advert < ActiveRecord::Base
+        self.table_name = "adverts"
+      end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to eq(["", ""])
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to eq(["", ""])
 
-    ### Rename a table
+      ### Rename a table
 
-    # As with renaming columns, we have to tell the migration generator about the rename. Here we create a new class 'Advertisement', and tell ActiveRecord to forget about the Advert class. This requires code that shouldn't be shown to impressionable children.
+      # As with renaming columns, we have to tell the migration generator about the rename. Here we create a new class 'Advertisement', and tell ActiveRecord to forget about the Advert class. This requires code that shouldn't be shown to impressionable children.
 
-    nuke_model_class(Advert)
+      nuke_model_class(Advert)
 
-    class Advertisement < ActiveRecord::Base
-      fields do
-        title :string, limit: 250, null: true
-        body :text, null: true
+      class Advertisement < ActiveRecord::Base
+        declare_schema do
+          string :title, limit: 250, null: true
+          text :body, null: true
+        end
       end
-    end
-
-    expect(Generators::DeclareSchema::Migration::Migrator.run("adverts" => "advertisements")).to(
-      migrate_up(<<~EOS.strip)
-        rename_table :adverts, :advertisements
-
-        add_column :advertisements, :title, :string, limit: 250, null: true#{charset_and_collation}
-        add_column :advertisements, :body, :text#{', limit: 4294967295' if defined?(Mysql2)}, null: true#{charset_and_collation}
-        remove_column :advertisements, :name
 
-        #{if defined?(SQLite3)
-            "add_index :advertisements, [:id], unique: true, name: 'PRIMARY'"
-          elsif defined?(Mysql2)
-            "execute \"ALTER TABLE advertisements DROP PRIMARY KEY, ADD PRIMARY KEY (id)\""
-          end}
+      expect(Generators::DeclareSchema::Migration::Migrator.run("adverts" => "advertisements")).to(
+          migrate_up(<<~EOS.strip)
+          rename_table :adverts, :advertisements
+
+          add_column :advertisements, :title, :string, limit: 250, null: true#{charset_and_collation}
+          add_column :advertisements, :body, :text#{', limit: 4294967295' if defined?(Mysql2)}, null: true#{charset_and_collation}
+          remove_column :advertisements, :name
+
+          #{if defined?(SQLite3)
+                                                                                                                                                                                                                                                     "add_index :advertisements, [:id], unique: true, name: 'PRIMARY'"
+            elsif defined?(Mysql2)
+              "execute \"ALTER TABLE advertisements DROP PRIMARY KEY, ADD PRIMARY KEY (id)\""
+            end}
+          EOS
+              .and migrate_down(<<~EOS.strip)
+          remove_column :advertisements, :title
+          remove_column :advertisements, :body
+          add_column :adverts, :name, :string, limit: 250, null: true#{charset_and_collation}
+
+          rename_table :advertisements, :adverts
+
+          #{if defined?(SQLite3)
+                                                                                                           "add_index :adverts, [:id], unique: true, name: 'PRIMARY'"
+            elsif defined?(Mysql2)
+              "execute \"ALTER TABLE adverts DROP PRIMARY KEY, ADD PRIMARY KEY (id)\""
+            end}
       EOS
-      .and migrate_down(<<~EOS.strip)
-        remove_column :advertisements, :title
-        remove_column :advertisements, :body
-        add_column :adverts, :name, :string, limit: 250, null: true#{charset_and_collation}
-
-        rename_table :advertisements, :adverts
-
-        #{if defined?(SQLite3)
-            "add_index :adverts, [:id], unique: true, name: 'PRIMARY'"
-          elsif defined?(Mysql2)
-            "execute \"ALTER TABLE adverts DROP PRIMARY KEY, ADD PRIMARY KEY (id)\""
-          end}
-      EOS
-    )
+      )
 
-    ### Drop a table
+      ### Drop a table
 
-    nuke_model_class(Advertisement)
+      nuke_model_class(Advertisement)
 
-    # If you delete a model, the migration generator will create a `drop_table` migration.
+      # If you delete a model, the migration generator will create a `drop_table` migration.
 
-    # Dropping tables is where the automatic down-migration really comes in handy:
+      # Dropping tables is where the automatic down-migration really comes in handy:
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to(
-      migrate_up(<<~EOS.strip)
-        drop_table :adverts
-      EOS
-      .and migrate_down(<<~EOS.strip)
-        create_table "adverts"#{table_options}, force: :cascade do |t|
-          t.string "name", limit: 250#{charset_and_collation}
-        end
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to(
+          migrate_up(<<~EOS.strip)
+          drop_table :adverts
+          EOS
+              .and migrate_down(<<~EOS.strip)
+          create_table "adverts"#{table_options}, force: :cascade do |t|
+            t.string "name", limit: 250#{charset_and_collation}
+          end
       EOS
-    )
+      )
 
-    ## STI
+      ## STI
 
-    ### Adding an STI subclass
+      ### Adding an STI subclass
 
-    # Adding a subclass or two should introduce the 'type' column and no other changes
+      # Adding a subclass or two should introduce the 'type' column and no other changes
 
-    class Advert < ActiveRecord::Base
-      fields do
-        body :text, null: true
-        title :string, default: "Untitled", limit: 250, null: true
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          text :body, null: true
+          string :title, default: "Untitled", limit: 250, null: true
+        end
       end
-    end
-    up = Generators::DeclareSchema::Migration::Migrator.run.first
-    ActiveRecord::Migration.class_eval(up)
+      up = Generators::DeclareSchema::Migration::Migrator.run.first
+      ActiveRecord::Migration.class_eval(up)
 
-    class FancyAdvert < Advert
-    end
-    class SuperFancyAdvert < FancyAdvert
-    end
+      class FancyAdvert < Advert
+      end
+      class SuperFancyAdvert < FancyAdvert
+      end
 
-    up, _ = Generators::DeclareSchema::Migration::Migrator.run do |migrations|
-      expect(migrations).to(
-        migrate_up(<<~EOS.strip)
-          add_column :adverts, :type, :string, limit: 250, null: true#{charset_and_collation}
+      up, _ = Generators::DeclareSchema::Migration::Migrator.run do |migrations|
+        expect(migrations).to(
+            migrate_up(<<~EOS.strip)
+            add_column :adverts, :type, :string, limit: 250, null: true#{charset_and_collation}
 
-          add_index :adverts, [:type], name: 'on_type'
-        EOS
-        .and migrate_down(<<~EOS.strip)
-          remove_column :adverts, :type
+            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
+            remove_index :adverts, name: :on_type rescue ActiveRecord::StatementInvalid
         EOS
-      )
-    end
+        )
+      end
 
-    Advert.field_specs.delete(:type)
-    nuke_model_class(SuperFancyAdvert)
-    nuke_model_class(FancyAdvert)
-    Advert.index_definitions.delete_if { |spec| spec.fields==["type"] }
+      Advert.field_specs.delete(:type)
+      nuke_model_class(SuperFancyAdvert)
+      nuke_model_class(FancyAdvert)
+      Advert.index_definitions.delete_if { |spec| spec.fields==["type"] }
 
-    ## Coping with multiple changes
+      ## Coping with multiple changes
 
-    # The migration generator is designed to create complete migrations even if many changes to the models have taken place.
+      # The migration generator is designed to create complete migrations even if many changes to the models have taken place.
 
-    # First let's confirm we're in a known state. One model, 'Advert', with a string 'title' and text 'body':
+      # First let's confirm we're in a known state. One model, 'Advert', with a string 'title' and text 'body':
 
-    ActiveRecord::Migration.class_eval up.gsub(/.*type.*/, '')
-    Advert.connection.schema_cache.clear!
-    Advert.reset_column_information
+      ActiveRecord::Migration.class_eval up.gsub(/.*type.*/, '')
+      Advert.connection.schema_cache.clear!
+      Advert.reset_column_information
 
-    expect(Advert.connection.tables - Generators::DeclareSchema::Migration::Migrator.always_ignore_tables).
-      to eq(["adverts"])
-    expect(Advert.columns.map(&:name).sort).to eq(["body", "id", "title"])
-    expect(Generators::DeclareSchema::Migration::Migrator.run).to eq(["", ""])
+      expect(Advert.connection.tables - Generators::DeclareSchema::Migration::Migrator.always_ignore_tables).
+          to eq(["adverts"])
+      expect(Advert.columns.map(&:name).sort).to eq(["body", "id", "title"])
+      expect(Generators::DeclareSchema::Migration::Migrator.run).to eq(["", ""])
 
 
-    ### Rename a column and change the default
+      ### Rename a column and change the default
 
-    Advert.field_specs.clear
+      Advert.field_specs.clear
 
-    class Advert < ActiveRecord::Base
-      fields do
-        name :string, default: "No Name", limit: 250, null: true
-        body :text, null: true
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          string :name, default: "No Name", limit: 250, null: true
+          text :body, null: true
+        end
       end
-    end
 
-    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: 250, null: true, default: "No Name"#{charset_and_collation}
-      EOS
-      .and migrate_down(<<~EOS.strip)
-        rename_column :adverts, :name, :title
-        change_column :adverts, :title, :string, limit: 250, null: true, default: "Untitled"#{charset_and_collation}
+      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: 250, null: true, default: "No Name"#{charset_and_collation}
+          EOS
+              .and migrate_down(<<~EOS.strip)
+          rename_column :adverts, :name, :title
+          change_column :adverts, :title, :string, limit: 250, null: true, default: "Untitled"#{charset_and_collation}
       EOS
-    )
+      )
 
-    ### Rename a table and add a column
+      ### Rename a table and add a column
 
-    nuke_model_class(Advert)
-    class Ad < ActiveRecord::Base
-      fields do
-        title      :string, default: "Untitled", limit: 250
-        body       :text, null: true
-        created_at :datetime
+      nuke_model_class(Advert)
+      class Ad < ActiveRecord::Base
+        declare_schema do
+          string   :title, default: "Untitled", limit: 250
+          text     :body, null: true
+          datetime :created_at
+        end
       end
-    end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run(adverts: :ads)).to(
-      migrate_up(<<~EOS.strip)
-        rename_table :adverts, :ads
+      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: 250, null: false, default: \"Untitled\"#{charset_and_collation}
+          add_column :ads, :created_at, :datetime, null: false
+          change_column :ads, :title, :string, limit: 250, null: false, default: \"Untitled\"#{charset_and_collation}
 
-        #{if defined?(SQLite3)
-            "add_index :ads, [:id], unique: true, name: 'PRIMARY'"
-          elsif defined?(Mysql2)
-            'execute "ALTER TABLE ads DROP PRIMARY KEY, ADD PRIMARY KEY (id)"'
-          end}
+          #{if defined?(SQLite3)
+                                                                                                                                   "add_index :ads, [:id], unique: true, name: 'PRIMARY'"
+            elsif defined?(Mysql2)
+              'execute "ALTER TABLE ads DROP PRIMARY KEY, ADD PRIMARY KEY (id)"'
+            end}
       EOS
-    )
+      )
 
-    class Advert < ActiveRecord::Base
-      fields do
-        body :text, null: true
-        title :string, default: "Untitled", limit: 250, null: true
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          text :body, null: true
+          string :title, default: "Untitled", limit: 250, null: true
+        end
       end
-    end
 
-    ## Legacy Keys
+      ## Legacy Keys
 
-    # DeclareSchema has some support for legacy keys.
+      # DeclareSchema has some support for legacy keys.
 
-    nuke_model_class(Ad)
+      nuke_model_class(Ad)
 
-    class Advert < ActiveRecord::Base
-      fields do
-        body :text, null: true
+      class Advert < ActiveRecord::Base
+        declare_schema do
+          text :body, null: true
+        end
+        self.primary_key = "advert_id"
       end
-      self.primary_key = "advert_id"
-    end
 
-    expect(Generators::DeclareSchema::Migration::Migrator.run(adverts: { id: :advert_id })).to(
-      migrate_up(<<~EOS.strip)
-        rename_column :adverts, :id, :advert_id
+      expect(Generators::DeclareSchema::Migration::Migrator.run(adverts: { id: :advert_id })).to(
+          migrate_up(<<~EOS.strip)
+          rename_column :adverts, :id, :advert_id
 
-        #{if defined?(SQLite3)
-            "add_index :adverts, [:advert_id], unique: true, name: 'PRIMARY'"
-          elsif defined?(Mysql2)
-          'execute "ALTER TABLE adverts DROP PRIMARY KEY, ADD PRIMARY KEY (advert_id)"'
-          end}
+          #{if defined?(SQLite3)
+              "add_index :adverts, [:advert_id], unique: true, name: 'PRIMARY'"
+            elsif defined?(Mysql2)
+              'execute "ALTER TABLE adverts DROP PRIMARY KEY, ADD PRIMARY KEY (advert_id)"'
+            end}
       EOS
-    )
+      )
 
-    nuke_model_class(Advert)
-    ActiveRecord::Base.connection.execute("drop table `adverts`;")
+      nuke_model_class(Advert)
+      ActiveRecord::Base.connection.execute("drop table `adverts`;")
 
-    ## DSL
+      ## DSL
 
-    # The DSL allows lambdas and constants
+      # The DSL allows lambdas and constants
 
-    class User < ActiveRecord::Base
-      fields do
-        company :string, limit: 250, ruby_default: -> { "BigCorp" }
+      class User < ActiveRecord::Base
+        declare_schema do
+          string :company, limit: 250, ruby_default: -> { "BigCorp" }
+        end
       end
-    end
-    expect(User.field_specs.keys).to eq(['company'])
-    expect(User.field_specs['company'].options[:ruby_default]&.call).to eq("BigCorp")
+      expect(User.field_specs.keys).to eq(['company'])
+      expect(User.field_specs['company'].options[:ruby_default]&.call).to eq("BigCorp")
 
-    ## validates
+      ## validates
 
-    # DeclareSchema can accept a validates hash in the field options.
+      # DeclareSchema can accept a validates hash in the field options.
 
-    class Ad < ActiveRecord::Base
-      class << self
-        def validates(field_name, options)
+      class Ad < ActiveRecord::Base
+        class << self
+          def validates(field_name, options)
+          end
         end
       end
-    end
-    expect(Ad).to receive(:validates).with(:company, presence: true, uniqueness: { case_sensitive: false })
-    class Ad < ActiveRecord::Base
-      fields do
-        company :string, limit: 250, index: true, unique: true, validates: { presence: true, uniqueness: { case_sensitive: false } }
+      expect(Ad).to receive(:validates).with(:company, presence: true, uniqueness: { case_sensitive: false })
+      class Ad < ActiveRecord::Base
+        declare_schema do
+          string :company, limit: 250, index: true, unique: true, validates: { presence: true, uniqueness: { case_sensitive: false } }
+        end
+        self.primary_key = "advert_id"
       end
-      self.primary_key = "advert_id"
+      up, _down = Generators::DeclareSchema::Migration::Migrator.run
+      ActiveRecord::Migration.class_eval(up)
+      expect(Ad.field_specs['company'].options[:validates].inspect).to eq("{:presence=>true, :uniqueness=>{:case_sensitive=>false}}")
     end
-    up, _down = Generators::DeclareSchema::Migration::Migrator.run
-    ActiveRecord::Migration.class_eval(up)
-    expect(Ad.field_specs['company'].options[:validates].inspect).to eq("{:presence=>true, :uniqueness=>{:case_sensitive=>false}}")
-  end
 
-  describe 'serialize' do
-    before do
-      class Ad < ActiveRecord::Base
-        @serialize_args = []
+    describe 'serialize' do
+      before do
+        class Ad < ActiveRecord::Base
+          @serialize_args = []
 
-        class << self
-          attr_reader :serialize_args
+          class << self
+            attr_reader :serialize_args
 
-          def serialize(*args)
-            @serialize_args << args
+            def serialize(*args)
+              @serialize_args << args
+            end
           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
+      describe 'untyped' do
+        it 'allows serialize: true' do
+          class Ad < ActiveRecord::Base
+            declare_schema do
+              text :allow_list, limit: 0xFFFF, serialize: true
+            end
           end
-        end
 
-        expect(Ad.serialize_args).to eq([[:allow_list]])
-      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: 250, serialize: true, null: true, default: []
-            allow_hash :string, limit: 250, serialize: true, null: true, default: {}
-            allow_string :string, limit: 250, serialize: true, null: true, default: ['abc']
-            allow_null :string, limit: 250, serialize: true, null: true, default: nil
+        it 'converts defaults with .to_yaml' do
+          class Ad < ActiveRecord::Base
+            declare_schema do
+              string :allow_list, limit: 250, serialize: true, null: true, default: []
+              string :allow_hash, limit: 250, serialize: true, null: true, default: {}
+              string :allow_string, limit: 250, serialize: true, null: true, default: ['abc']
+              string :allow_null, limit: 250, serialize: true, null: true, default: nil
+            end
           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)
+          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
-    end
 
-    describe 'Array' do
-      it 'allows serialize: Array' do
-        class Ad < ActiveRecord::Base
-          fields do
-            allow_list :string, limit: 250, serialize: Array, null: true
+      describe 'Array' do
+        it 'allows serialize: Array' do
+          class Ad < ActiveRecord::Base
+            declare_schema do
+              string :allow_list, limit: 250, serialize: Array, null: true
+            end
           end
-        end
 
-        expect(Ad.serialize_args).to eq([[:allow_list, Array]])
-      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: 250, serialize: Array, null: true, default: [2]
-            allow_string :string, limit: 250, serialize: Array, null: true, default: ['abc']
-            allow_empty :string, limit: 250, serialize: Array, null: true, default: []
-            allow_null :string, limit: 250, serialize: Array, null: true, default: nil
+        it 'allows Array defaults' do
+          class Ad < ActiveRecord::Base
+            declare_schema do
+              string :allow_list, limit: 250, serialize: Array, null: true, default: [2]
+              string :allow_string, limit: 250, serialize: Array, null: true, default: ['abc']
+              string :allow_empty, limit: 250, serialize: Array, null: true, default: []
+              string :allow_null, limit: 250, serialize: Array, null: true, default: nil
+            end
           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)
+          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
-    end
 
-    describe 'Hash' do
-      it 'allows serialize: Hash' do
-        class Ad < ActiveRecord::Base
-          fields do
-            allow_list :string, limit: 250, serialize: Hash, null: true
+      describe 'Hash' do
+        it 'allows serialize: Hash' do
+          class Ad < ActiveRecord::Base
+            declare_schema do
+              string :allow_list, limit: 250, serialize: Hash, null: true
+            end
           end
-        end
 
-        expect(Ad.serialize_args).to eq([[:allow_list, Hash]])
-      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: 250, serialize: Hash, null: true, default: { 'state' => 'CA' }
-            allow_hash :string, limit: 250, serialize: Hash, null: true, default: {}
-            allow_null :string, limit: 250, serialize: Hash, null: true, default: nil
+        it 'allows Hash defaults' do
+          class Ad < ActiveRecord::Base
+            declare_schema do
+              string :allow_loc, limit: 250, serialize: Hash, null: true, default: { 'state' => 'CA' }
+              string :allow_hash, limit: 250, serialize: Hash, null: true, default: {}
+              string :allow_null, limit: 250, serialize: Hash, null: true, default: nil
+            end
           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)
+          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
-    end
 
-    describe 'JSON' do
-      it 'allows serialize: JSON' do
-        class Ad < ActiveRecord::Base
-          fields do
-            allow_list :string, limit: 250, serialize: JSON
+      describe 'JSON' do
+        it 'allows serialize: JSON' do
+          class Ad < ActiveRecord::Base
+            declare_schema do
+              string :allow_list, limit: 250, serialize: JSON
+            end
           end
-        end
 
-        expect(Ad.serialize_args).to eq([[:allow_list, JSON]])
-      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: 250, serialize: JSON, null: true, default: { 'state' => 'CA' }
-            allow_empty_array :string, limit: 250, serialize: JSON, null: true, default: []
-            allow_empty_hash :string, limit: 250, serialize: JSON, null: true, default: {}
-            allow_null :string, limit: 250, serialize: JSON, null: true, default: nil
+        it 'allows JSON defaults' do
+          class Ad < ActiveRecord::Base
+            declare_schema do
+              string :allow_hash, limit: 250, serialize: JSON, null: true, default: { 'state' => 'CA' }
+              string :allow_empty_array, limit: 250, serialize: JSON, null: true, default: []
+              string :allow_empty_hash, limit: 250, serialize: JSON, null: true, default: {}
+              string :allow_null, limit: 250, serialize: JSON, null: true, default: nil
+            end
           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)
+          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
-    end
 
-    class ValueClass
-      delegate :present?, :inspect, to: :@value
+      class ValueClass
+        delegate :present?, :inspect, to: :@value
 
-      def initialize(value)
-        @value = value
-      end
+        def initialize(value)
+          @value = value
+        end
 
-      class << self
-        def dump(object)
-          if object&.present?
-            object.inspect
+        class << self
+          def dump(object)
+            if object&.present?
+              object.inspect
+            end
           end
-        end
 
-        def load(serialized)
-          if serialized
-            raise 'not used ???'
+          def load(serialized)
+            if serialized
+              raise 'not used ???'
+            end
           end
         end
       end
-    end
 
-    describe 'custom coder' do
-      it 'allows serialize: ValueClass' do
-        class Ad < ActiveRecord::Base
-          fields do
-            allow_list :string, limit: 250, serialize: ValueClass
+      describe 'custom coder' do
+        it 'allows serialize: ValueClass' do
+          class Ad < ActiveRecord::Base
+            declare_schema do
+              string :allow_list, limit: 250, serialize: ValueClass
+            end
           end
-        end
 
-        expect(Ad.serialize_args).to eq([[:allow_list, ValueClass]])
-      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: 250, serialize: ValueClass, null: true, default: ValueClass.new([2])
-            allow_empty_array :string, limit: 250, serialize: ValueClass, null: true, default: ValueClass.new([])
-            allow_null :string, limit: 250, serialize: ValueClass, null: true, default: nil
+        it 'allows ValueClass defaults' do
+          class Ad < ActiveRecord::Base
+            declare_schema do
+              string :allow_hash, limit: 250, serialize: ValueClass, null: true, default: ValueClass.new([2])
+              string :allow_empty_array, limit: 250, serialize: ValueClass, null: true, default: ValueClass.new([])
+              string :allow_null, limit: 250, serialize: ValueClass, null: true, default: nil
+            end
           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)
+          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
-    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
+      it 'disallows serialize: with a non-string column type' do
+        expect do
+          class Ad < ActiveRecord::Base
+            declare_schema do
+              integer :allow_list, limit: 8, serialize: true
+            end
           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.to raise_exception(ArgumentError, /must be :string or :text/)
+      end
     end
-    let(:optional_flag) { { false => optional_false, true => optional_true } }
 
-    describe 'belongs_to' do
-      before do
-        unless defined?(AdCategory)
-          class AdCategory < ActiveRecord::Base
-            fields { }
+    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
+              declare_schema { }
+            end
           end
-        end
 
-        class Advert < ActiveRecord::Base
-          fields do
-            name :string, limit: 250, null: true
-            category_id :integer, limit: 8
-            nullable_category_id :integer, limit: 8, null: true
+          class Advert < ActiveRecord::Base
+            declare_schema do
+              string :name, limit: 250, null: true
+              integer :category_id, limit: 8
+              integer :nullable_category_id, limit: 8, null: true
+            end
           end
+          up = Generators::DeclareSchema::Migration::Migrator.run.first
+          ActiveRecord::Migration.class_eval(up)
         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
+        it 'passes through optional: when given' do
           class AdvertBelongsTo < ActiveRecord::Base
             self.table_name = 'adverts'
-            fields { }
+            declare_schema { }
             reset_column_information
-            belongs_to :ad_category, optional: true, null: false
+            belongs_to :ad_category, optional: true
           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
+        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'
+              declare_schema { }
+              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
-          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)
+          it 'passes through optional: false, null: true' do
+            class AdvertBelongsTo < ActiveRecord::Base
+              self.table_name = 'adverts'
+              declare_schema { }
+              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
 
-          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)
+        [false, true].each do |nullable|
+          context "nullable=#{nullable}" do
+            it 'infers optional: from null:' do
+              eval <<~EOS
+                class AdvertBelongsTo < ActiveRecord::Base
+                  declare_schema { }
+                  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
+                  declare_schema { }
+                  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
-  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
+    describe 'migration base class' do
+      it 'adapts to Rails 4' do
+        class Advert < active_record_base_class.constantize
+          declare_schema do
+            string :title, limit: 100
+          end
         end
-      end
 
-      generate_migrations '-n', '-m'
+        generate_migrations '-n', '-m'
 
-      migrations = Dir.glob('db/migrate/*declare_schema_migration*.rb')
-      expect(migrations.size).to eq(1), migrations.inspect
+        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)")
+        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
 
-  context 'Does not generate migrations' do
-    it 'for aliased fields bigint -> integer limit 8' do
-      if Rails::VERSION::MAJOR >= 5 || !ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
-        class Advert < active_record_base_class.constantize
-          fields do
-            price :bigint
+    context 'Does not generate migrations' do
+      it 'for aliased fields bigint -> integer limit 8' do
+        if Rails::VERSION::MAJOR >= 5 || !ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
+          class Advert < active_record_base_class.constantize
+            declare_schema do
+              bigint :price
+            end
           end
-        end
 
-        generate_migrations '-n', '-m'
+          generate_migrations '-n', '-m'
 
-        migrations = Dir.glob('db/migrate/*declare_schema_migration*.rb')
-        expect(migrations.size).to eq(1), migrations.inspect
+          migrations = Dir.glob('db/migrate/*declare_schema_migration*.rb')
+          expect(migrations.size).to eq(1), migrations.inspect
 
-        if defined?(Mysql2) && Rails::VERSION::MAJOR < 5
-          ActiveRecord::Base.connection.execute("ALTER TABLE adverts ADD PRIMARY KEY (id)")
-        end
+          if defined?(Mysql2) && Rails::VERSION::MAJOR < 5
+            ActiveRecord::Base.connection.execute("ALTER TABLE adverts ADD PRIMARY KEY (id)")
+          end
 
-        class Advert < active_record_base_class.constantize
-          fields do
-            price :integer, limit: 8
+          class Advert < active_record_base_class.constantize
+            declare_schema do
+              integer :price, limit: 8
+            end
           end
-        end
 
-        expect { generate_migrations '-n', '-g' }.to output("Database and models match -- nothing to change\n").to_stdout
+          expect { generate_migrations '-n', '-g' }.to output("Database and models match -- nothing to change\n").to_stdout
+        end
       end
     end
   end