declare_schema 0.6.4 → 0.8.0.pre.3

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "0.6.4"
+  VERSION = "0.8.0.pre.3"
 end

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

@@ -96,7 +96,7 @@ module DeclareSchema
           end
         end
       end
-    rescue ::DeclareSchema::Model::FieldSpec::UnknownSqlTypeError => ex
+    rescue ::DeclareSchema::UnknownTypeError => ex
       say "Invalid field type: #{ex}"
     end
 

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'active_record'
+require 'active_record/connection_adapters/abstract_adapter'
 
 module Generators
   module DeclareSchema
@@ -116,20 +117,6 @@ module Generators
             ActiveRecord::Base.connection
           end
 
-          def fix_native_types(types)
-            case connection.class.name
-            when /mysql/i
-              types[:integer][:limit] ||= 11
-              types[:text][:limit]    ||= 0xffff
-              types[:binary][:limit]  ||= 0xffff
-            end
-            types
-          end
-
-          def native_types
-            @native_types ||= fix_native_types(connection.native_database_types)
-          end
-
           def before_generating_migration(&block)
             block or raise ArgumentError, 'A block is required when setting the before_generating_migration callback'
             @before_generating_migration_callback = block
@@ -299,7 +286,7 @@ module Generators
             "drop_table :#{t}"
           end * "\n"
           undo_drops = to_drop.map do |t|
-            revert_table(t)
+            add_table_back(t)
           end * "\n\n"
 
           creates = to_create.map do |t|
@@ -341,11 +328,11 @@ module Generators
         end
 
         def create_table(model)
-          longest_field_name       = model.field_specs.values.map { |f| f.sql_type.to_s.length }.max
+          longest_field_name       = model.field_specs.values.map { |f| f.type.to_s.length }.max
           disable_auto_increment   = model.respond_to?(:disable_auto_increment) && model.disable_auto_increment
           table_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.new(model.table_name, table_options_for_model(model))
           field_definitions        = [
-            disable_auto_increment ? "t.integer :id, limit: 8, auto_increment: false, primary_key: true" : nil,
+            ("t.integer :id, limit: 8, auto_increment: false, primary_key: true" if disable_auto_increment),
             *(model.field_specs.values.sort_by(&:position).map { |f| create_field(f, longest_field_name) })
           ].compact
 
@@ -390,9 +377,9 @@ module Generators
         end
 
         def create_field(field_spec, field_name_width)
-          options = fk_field_options(field_spec.model, field_spec.name).merge(field_spec.sql_options)
-          args = [field_spec.name.inspect] + format_options(options, field_spec.sql_type)
-          format("t.%-*s %s", field_name_width, field_spec.sql_type, args.join(', '))
+          options = field_spec.sql_options.merge(fk_field_options(field_spec.model, field_spec.name))
+          args = [field_spec.name.inspect] + format_options(options.compact)
+          format("t.%-*s %s", field_name_width, field_spec.type, args.join(', '))
         end
 
         def change_table(model, current_table_name)
@@ -429,8 +416,8 @@ module Generators
           adds = to_add.map do |c|
             args =
               if (spec = model.field_specs[c])
-                options = fk_field_options(model, c).merge(spec.sql_options)
-                [":#{spec.sql_type}", *format_options(options, spec.sql_type)]
+                options = spec.sql_options.merge(fk_field_options(model, c))
+                [":#{spec.type}", *format_options(options.compact)]
               else
                 [":integer"]
               end
@@ -444,34 +431,28 @@ module Generators
             "remove_column :#{new_table_name}, :#{c}"
           end
           undo_removes = to_remove.map do |c|
-            revert_column(current_table_name, c)
+            add_column_back(model, current_table_name, c)
           end
 
           old_names = to_rename.invert
           changes = []
           undo_changes = []
-          to_change.each do |c|
-            col_name = old_names[c] || c
-            col = db_columns[col_name]
-            spec = model.field_specs[c]
-            if spec.different_to?(current_table_name, col) # TODO: TECH-4814 DRY this up to a diff function that returns the differences. It's different if it has differences. -Colin
-              change_spec = fk_field_options(model, c)
-              change_spec[:limit]     ||= spec.limit   if (spec.sql_type != :text ||
-                                                         ::DeclareSchema::Model::FieldSpec.mysql_text_limits?) &&
-                                                          (spec.limit || col.limit)
-              change_spec[:precision]     = spec.precision     unless spec.precision.nil?
-              change_spec[:scale]         = spec.scale         unless spec.scale.nil?
-              change_spec[:null]          = spec.null          unless spec.null && col.null
-              change_spec[:default]       = spec.default       unless spec.default.nil? && col.default.nil?
-              change_spec[:charset]       = spec.charset       unless spec.charset.nil?
-              change_spec[:collation]     = spec.collation     unless spec.collation.nil?
-
-              changes << "change_column :#{new_table_name}, :#{c}, " +
-                         ([":#{spec.sql_type}"] + format_options(change_spec, spec.sql_type, changing: true)).join(", ")
-              back = change_column_back(current_table_name, col_name)
-              undo_changes << back unless back.blank?
+          to_change.each do |col_name_to_change|
+            orig_col_name      = old_names[col_name_to_change] || col_name_to_change
+            column             = db_columns[orig_col_name] or raise "failed to find column info for #{orig_col_name.inspect}"
+            spec               = model.field_specs[col_name_to_change] or raise "failed to find field spec for #{col_name_to_change.inspect}"
+            spec_attrs         = spec.schema_attributes(column)
+            column_declaration = ::DeclareSchema::Model::Column.new(model, current_table_name, column)
+            col_attrs          = column_declaration.schema_attributes
+            normalized_schema_attrs = spec_attrs.merge(fk_field_options(model, col_name_to_change))
+
+            if !::DeclareSchema::Model::Column.equivalent_schema_attributes?(normalized_schema_attrs, col_attrs)
+              type = normalized_schema_attrs.delete(:type) or raise "no :type found in #{normalized_schema_attrs.inspect}"
+              changes << ["change_column #{new_table_name.to_sym.inspect}", col_name_to_change.to_sym.inspect,
+                          type.to_sym.inspect, *format_options(normalized_schema_attrs)].join(", ")
+              undo_changes << change_column_back(model, current_table_name, orig_col_name)
             end
-          end.compact
+          end
 
           index_changes, undo_index_changes = change_indexes(model, current_table_name, to_remove)
           fk_changes, undo_fk_changes = if ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
@@ -485,26 +466,26 @@ module Generators
                                                                 [[], []]
                                                               end
 
-          [(renames + adds + removes + changes) * "\n",
+          [(renames + adds + removes + changes)                     * "\n",
            (undo_renames + undo_adds + undo_removes + undo_changes) * "\n",
-           index_changes * "\n",
-           undo_index_changes * "\n",
-           fk_changes * "\n",
-           undo_fk_changes * "\n",
-           table_options_changes * "\n",
-           undo_table_options_changes * "\n"]
+           index_changes                                            * "\n",
+           undo_index_changes                                       * "\n",
+           fk_changes                                               * "\n",
+           undo_fk_changes                                          * "\n",
+           table_options_changes                                    * "\n",
+           undo_table_options_changes                               * "\n"]
         end
 
         def change_indexes(model, old_table_name, to_remove)
-          return [[], []] if Migrator.disable_constraints
+          Migrator.disable_constraints and return [[], []]
 
           new_table_name = model.table_name
           existing_indexes = ::DeclareSchema::Model::IndexDefinition.for_model(model, old_table_name)
           model_indexes_with_equivalents = model.index_definitions_with_primary_key
           model_indexes = model_indexes_with_equivalents.map do |i|
             if i.explicit_name.nil?
-              if ex = existing_indexes.find { |e| i != e && e.equivalent?(i) }
-                i.with_name(ex.name)
+              if (existing = existing_indexes.find { |e| i != e && e.equivalent?(i) })
+                i.with_name(existing.name)
               end
             end || i
           end
@@ -514,15 +495,13 @@ module Generators
           end
           model_has_primary_key    = model_indexes.any?    { |i| i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME }
 
-          add_indexes_init = model_indexes - existing_indexes
-          drop_indexes_init = existing_indexes - model_indexes
           undo_add_indexes = []
-          undo_drop_indexes = []
-          add_indexes = add_indexes_init.map do |i|
+          add_indexes = (model_indexes - existing_indexes).map do |i|
             undo_add_indexes << drop_index(old_table_name, i.name) unless i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME
             i.to_add_statement(new_table_name, existing_has_primary_key)
           end
-          drop_indexes = drop_indexes_init.map do |i|
+          undo_drop_indexes = []
+          drop_indexes = (existing_indexes - model_indexes).map do |i|
             undo_drop_indexes << i.to_add_statement(old_table_name, model_has_primary_key)
             drop_index(new_table_name, i.name) unless i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME
           end.compact
@@ -538,24 +517,22 @@ module Generators
         end
 
         def change_foreign_key_constraints(model, old_table_name)
-          ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) and raise 'SQLite does not support foreign keys'
-          return [[], []] if Migrator.disable_indexing
+          ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) and raise ArgumentError, 'SQLite does not support foreign keys'
+          Migrator.disable_indexing and return [[], []]
 
           new_table_name = model.table_name
           existing_fks = ::DeclareSchema::Model::ForeignKeyDefinition.for_model(model, old_table_name)
           model_fks = model.constraint_specs
-          add_fks = model_fks - existing_fks
-          drop_fks = existing_fks - model_fks
-          undo_add_fks = []
-          undo_drop_fks = []
 
-          add_fks.map! do |fk|
+          undo_add_fks = []
+          add_fks = (model_fks - existing_fks).map do |fk|
             # next if fk.parent.constantize.abstract_class || fk.parent == fk.model.class_name
             undo_add_fks << remove_foreign_key(old_table_name, fk.constraint_name)
             fk.to_add_statement
-          end.compact
+          end
 
-          drop_fks.map! do |fk|
+          undo_drop_fks = []
+          drop_fks = (existing_fks - model_fks).map do |fk|
             undo_drop_fks << fk.to_add_statement
             remove_foreign_key(new_table_name, fk.constraint_name)
           end
@@ -567,22 +544,14 @@ module Generators
           "remove_foreign_key(#{old_table_name.inspect}, name: #{fk_name.to_s.inspect})"
         end
 
-        def format_options(options, type, changing: false)
+        def format_options(options)
           options.map do |k, v|
-            if !changing && ((k == :limit && type == :decimal) || (k == :null && v == true))
-              next
-            end
-
-            if !::DeclareSchema::Model::FieldSpec.mysql_text_limits? && k == :limit && type == :text
-              next
-            end
-
             if k.is_a?(Symbol)
               "#{k}: #{v.inspect}"
             else
               "#{k.inspect} => #{v.inspect}"
             end
-          end.compact
+          end
         end
 
         def fk_field_options(model, field_name)
@@ -620,7 +589,33 @@ module Generators
           end
         end
 
-        # TODO: TECH-4814 remove all methods from here through end of file
+        def with_previous_model_table_name(model, table_name)
+          model_table_name, model.table_name = model.table_name, table_name
+          yield
+        ensure
+          model.table_name = model_table_name
+        end
+
+        def add_column_back(model, current_table_name, col_name)
+          with_previous_model_table_name(model, current_table_name) do
+            column = model.columns_hash[col_name] or raise "no columns_hash entry found for #{col_name} in #{model.inspect}"
+            col_spec = ::DeclareSchema::Model::Column.new(model, current_table_name, column)
+            schema_attributes = col_spec.schema_attributes
+            type = schema_attributes.delete(:type) or raise "no :type found in #{schema_attributes.inspect}"
+            ["add_column :#{current_table_name}, :#{col_name}, #{type.inspect}", *format_options(schema_attributes)].join(', ')
+          end
+        end
+
+        def change_column_back(model, current_table_name, col_name)
+          with_previous_model_table_name(model, current_table_name) do
+            column = model.columns_hash[col_name] or raise "no columns_hash entry found for #{col_name} in #{model.inspect}"
+            col_spec = ::DeclareSchema::Model::Column.new(model, current_table_name, column)
+            schema_attributes = col_spec.schema_attributes
+            type = schema_attributes.delete(:type) or raise "no :type found in #{schema_attributes.inspect}"
+            ["change_column #{current_table_name.to_sym.inspect}", col_name.to_sym.inspect, type.to_sym.inspect, *format_options(schema_attributes)].join(', ')
+          end
+        end
+
         def default_collation_from_charset(charset)
           case charset
           when "utf8"
@@ -630,64 +625,47 @@ module Generators
           end
         end
 
-        def revert_table(table)
-          res = StringIO.new
-          schema_dumper_klass = case Rails::VERSION::MAJOR
-                                when 4
-                                  ActiveRecord::SchemaDumper
-                                else
-                                  ActiveRecord::ConnectionAdapters::SchemaDumper
-                                end
-          schema_dumper_klass.send(:new, ActiveRecord::Base.connection).send(:table, table, res)
+        SchemaDumper = case Rails::VERSION::MAJOR
+                       when 4
+                         ActiveRecord::SchemaDumper
+                       else
+                         ActiveRecord::ConnectionAdapters::SchemaDumper
+                       end
+
+        def add_table_back(table)
+          dumped_schema_stream = StringIO.new
+          SchemaDumper.send(:new, ActiveRecord::Base.connection).send(:table, table, dumped_schema_stream)
 
-          result = res.string.strip.gsub("\n  ", "\n")
+          dumped_schema = dumped_schema_stream.string.strip.gsub!("\n  ", "\n")
           if connection.class.name.match?(/mysql/i)
-            if !result['options: ']
-              result = result.sub('",', "\", options: \"DEFAULT CHARSET=#{Generators::DeclareSchema::Migration::Migrator.default_charset} "+
-                                   "COLLATE=#{Generators::DeclareSchema::Migration::Migrator.default_collation}\",")
-            end
-            default_charset   = result[/CHARSET=(\w+)/, 1]   or raise "unable to find charset in #{result.inspect}"
-            default_collation = result[/COLLATE=(\w+)/, 1] || default_collation_from_charset(default_charset) or
-              raise "unable to find collation in #{result.inspect} or charset #{default_charset.inspect}"
-            result = result.split("\n").map do |line|
-              if line['t.text'] || line['t.string']
-                if !line['charset: ']
-                  if line['collation: ']
-                    line = line.sub('collation: ', "charset: #{default_charset.inspect}, collation: ")
-                  else
-                    line += ", charset: #{default_charset.inspect}"
-                  end
-                end
-                line['collation: '] or line += ", collation: #{default_collation.inspect}"
-              end
-              line
-            end.join("\n")
+            fix_mysql_charset_and_collation(dumped_schema)
+          else
+            dumped_schema
           end
-          result
         end
 
-        def column_options_from_reverted_table(table, column)
-          revert = revert_table(table)
-          if (md = revert.match(/\s*t\.column\s+"#{column}",\s+(:[a-zA-Z0-9_]+)(?:,\s+(.*?)$)?/m))
-            # Ugly migration
-            _, type, options = *md
-          elsif (md = revert.match(/\s*t\.([a-z_]+)\s+"#{column}"(?:,\s+(.*?)$)?/m))
-            # Sexy migration
-            _, string_type, options = *md
-            type = ":#{string_type}"
+        # TODO: rewrite this method to use charset and collation variables rather than manipulating strings. -Colin
+        def fix_mysql_charset_and_collation(dumped_schema)
+          if !dumped_schema['options: ']
+            dumped_schema.sub!('",', "\", options: \"DEFAULT CHARSET=#{Generators::DeclareSchema::Migration::Migrator.default_charset} "+
+              "COLLATE=#{Generators::DeclareSchema::Migration::Migrator.default_collation}\",")
           end
-          type or raise "unable to find column options for #{table}.#{column} in #{revert.inspect}"
-          [type, options]
-        end
-
-        def change_column_back(table, column)
-          type, options = column_options_from_reverted_table(table, column)
-          ["change_column :#{table}, :#{column}, #{type}", options&.strip].compact.join(', ')
-        end
-
-        def revert_column(table, column)
-          type, options = column_options_from_reverted_table(table, column)
-          ["add_column :#{table}, :#{column}, #{type}", options&.strip].compact.join(', ')
+          default_charset   = dumped_schema[/CHARSET=(\w+)/, 1]   or raise "unable to find charset in #{dumped_schema.inspect}"
+          default_collation = dumped_schema[/COLLATE=(\w+)/, 1] || default_collation_from_charset(default_charset) or
+            raise "unable to find collation in #{dumped_schema.inspect} or charset #{default_charset.inspect}"
+          dumped_schema.split("\n").map do |line|
+            if line['t.text'] || line['t.string']
+              if !line['charset: ']
+                if line['collation: ']
+                  line.sub!('collation: ', "charset: #{default_charset.inspect}, collation: ")
+                else
+                  line << ", charset: #{default_charset.inspect}"
+                end
+              end
+              line['collation: '] or line << ", collation: #{default_collation.inspect}"
+            end
+            line
+          end.join("\n")
         end
       end
     end

data/spec/lib/declare_schema/field_declaration_dsl_spec.rb

@@ -25,7 +25,7 @@ RSpec.describe DeclareSchema::FieldDeclarationDsl do
   end
 
   it 'stores limits' do
-    expect(TestModel.field_specs['name'].limit).to eq(127)
+    expect(TestModel.field_specs['name'].limit).to eq(127), TestModel.field_specs['name'].inspect
   end
 
   # TODO: fill out remaining tests

data/spec/lib/declare_schema/field_spec_spec.rb

@@ -1,69 +1,179 @@
 # frozen_string_literal: true
 
-RSpec.describe 'DeclareSchema Model FieldSpec' do
+begin
+  require 'mysql2'
+rescue LoadError
+end
+
+RSpec.describe DeclareSchema::Model::FieldSpec do
+  let(:model) { double('model', table_options: {}) }
+  let(:col_spec) { double('col_spec', type: :string) }
+
   before do
     load File.expand_path('prepare_testapp.rb', __dir__)
+
+    if Rails::VERSION::MAJOR < 5
+      allow(col_spec).to receive(:type_cast_from_database, &:itself)
+    end
   end
 
-  context 'There are no model columns to change' do
-    it '#different_to should return false for int8 == int8' do
-      subject = DeclareSchema::Model::FieldSpec.new(Object, :price, :integer, limit: 8, null: false, position: 0)
+  describe '#initialize' do
+    it 'normalizes option order' do
+      subject = described_class.new(model, :price, :integer, anonymize_using: 'x', null: false, position: 0, limit: 4)
+      expect(subject.options.keys).to eq([:limit, :null, :anonymize_using])
+    end
 
-      case Rails::VERSION::MAJOR
-      when 4
-        cast_type = ActiveRecord::Type::Integer.new(limit: 8)
-        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, cast_type, "integer(8)", false)
-      else
-        sql_type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: "integer(8)", type: :integer, limit: 8)
-        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, sql_type_metadata, false, "adverts")
-      end
+    it 'raises exception on unknown field type' do
+      expect do
+        described_class.new(model, :location, :lat_long, position: 0)
+      end.to raise_exception(::DeclareSchema::UnknownTypeError, /:lat_long not found in /)
+    end
+  end
 
-      expect(subject.different_to?(subject.name, col)).to eq(false)
+  describe '#schema_attributes' do
+    describe 'integer 4' do
+      it 'returns schema attributes' do
+        subject = described_class.new(model, :price, :integer, limit: 4, null: false, position: 0)
+        expect(subject.schema_attributes(col_spec)).to eq(type: :integer, limit: 4, null: false)
+      end
     end
 
-    it '#different_to should return false for bigint == bigint' do
-      subject = DeclareSchema::Model::FieldSpec.new(Object, :price, :bigint, null: false, position: 0)
+    describe 'integer 8' do
+      it 'returns schema attributes' do
+        subject = described_class.new(model, :price, :integer, limit: 8, null: true, position: 2)
+        expect(subject.schema_attributes(col_spec)).to eq(type: :integer, limit: 8, null: true)
+      end
+    end
 
-      case Rails::VERSION::MAJOR
-      when 4
-        cast_type = ActiveRecord::Type::BigInteger.new(limit: 8)
-        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, cast_type, "bigint(20)", false)
-      else
-        sql_type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: "bigint(20)", type: :integer, limit: 8)
-        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, sql_type_metadata, false, "adverts")
+    describe 'bigint' do
+      it 'returns schema attributes' do
+        subject = described_class.new(model, :price, :bigint, null: false, position: 2)
+        expect(subject.schema_attributes(col_spec)).to eq(type: :integer, limit: 8, null: false)
       end
+    end
 
-      expect(subject.different_to?(subject.name, col)).to eq(false)
+    describe 'string' do
+      it 'returns schema attributes (including charset/collation iff mysql)' do
+        subject = described_class.new(model, :title, :string, limit: 100, null: true, charset: 'utf8mb4', position: 0)
+        if defined?(Mysql2)
+          expect(subject.schema_attributes(col_spec)).to eq(type: :string, limit: 100, null: true, charset: 'utf8mb4', collation: 'utf8mb4_bin')
+        else
+          expect(subject.schema_attributes(col_spec)).to eq(type: :string, limit: 100, null: true)
+        end
+      end
     end
 
-    it '#different_to should return false for int8 == bigint' do
-      subject = DeclareSchema::Model::FieldSpec.new(Object, :price, :integer, limit: 8, null: false, position: 0)
+    describe 'text' do
+      it 'returns schema attributes (including charset/collation iff mysql)' do
+        subject = described_class.new(model, :title, :text, limit: 200, null: true, charset: 'utf8mb4', position: 2)
+        if defined?(Mysql2)
+          expect(subject.schema_attributes(col_spec)).to eq(type: :text, limit: 255, null: true, charset: 'utf8mb4', collation: 'utf8mb4_bin')
+        else
+          expect(subject.schema_attributes(col_spec)).to eq(type: :text, null: true)
+        end
+      end
 
-      case Rails::VERSION::MAJOR
-      when 4
-        cast_type = ActiveRecord::Type::BigInteger.new(limit: 8)
-        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, cast_type, "bigint(20)", false)
-      else
-        sql_type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: "bigint(20)", type: :integer, limit: 8)
-        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, sql_type_metadata, false, "adverts")
+      it 'allows a default to be set unless mysql' do
+        if defined?(Mysql2)
+          expect do
+            described_class.new(model, :title, :text, limit: 200, null: true, default: 'none', charset: 'utf8mb4', position: 2)
+          end.to raise_exception(DeclareSchema::MysqlTextMayNotHaveDefault)
+        else
+          subject = described_class.new(model, :title, :text, limit: 200, null: true, default: 'none', charset: 'utf8mb4', position: 2)
+          expect(subject.schema_attributes(col_spec)).to eq(type: :text, null: true, default: 'none')
+        end
       end
 
-      expect(subject.different_to?(subject.name, col)).to eq(false)
+      describe 'decimal' do
+        it 'allows precision: and scale:' do
+          subject = described_class.new(model, :quantity, :decimal, precision: 8, scale: 10, null: true, position: 3)
+          expect(subject.schema_attributes(col_spec)).to eq(type: :decimal, precision: 8, scale: 10, null: true)
+        end
+
+        it 'requires precision:' do
+          expect_any_instance_of(described_class).to receive(:warn).with(/precision: required for :decimal type/)
+          described_class.new(model, :quantity, :decimal, scale: 10, null: true, position: 3)
+        end
+
+        it 'requires scale:' do
+          expect_any_instance_of(described_class).to receive(:warn).with(/scale: required for :decimal type/)
+          described_class.new(model, :quantity, :decimal, precision: 8, null: true, position: 3)
+        end
+      end
+
+      [:integer, :bigint, :string, :text, :binary, :datetime, :date, :time].each do |t|
+        describe t.to_s do
+          let(:extra) { t == :string ? { limit: 100 } : {} }
+
+          it 'does not allow precision:' do
+            expect_any_instance_of(described_class).to receive(:warn).with(/precision: only allowed for :decimal type/)
+            described_class.new(model, :quantity, t, { precision: 8, null: true, position: 3 }.merge(extra))
+          end unless t == :datetime
+
+          it 'does not allow scale:' do
+            expect_any_instance_of(described_class).to receive(:warn).with(/scale: only allowed for :decimal type/)
+            described_class.new(model, :quantity, t, { scale: 10, null: true, position: 3 }.merge(extra))
+          end
+        end
+      end
+    end
+
+    describe 'datetime' do
+      it 'keeps type as "datetime"' do
+        subject = described_class.new(model, :created_at, :datetime, null: false, position: 1)
+        expect(subject.schema_attributes(col_spec)).to eq(type: :datetime, null: false)
+      end
     end
 
-    it '#different_to should return false for bigint == int8' do
-      subject = DeclareSchema::Model::FieldSpec.new(Object, :price, :bigint, null: false, position: 0)
+    describe 'timestamp' do
+      it 'normalizes type to "datetime"' do
+        subject = described_class.new(model, :created_at, :timestamp, null: true, position: 2)
+        expect(subject.schema_attributes(col_spec)).to eq(type: :datetime, null: true)
+      end
+    end
 
+    describe 'default:' do
+      let(:col_spec) { double('col_spec', type: :integer) }
+
+      it 'typecasts default value' do
+        allow(col_spec).to receive(:type_cast_from_database) { |default| Integer(default) }
+        subject = described_class.new(model, :price, :integer, limit: 4, default: '42', null: true, position: 2)
+        expect(subject.schema_attributes(col_spec)).to eq(type: :integer, limit: 4, default: 42, null: true)
+      end
+    end
+  end
+
+  describe '#schema_attributes' do
+    let(:col_spec) do
       case Rails::VERSION::MAJOR
       when 4
         cast_type = ActiveRecord::Type::Integer.new(limit: 8)
-        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, cast_type, "integer(8)", false)
+        ActiveRecord::ConnectionAdapters::Column.new("price", nil, cast_type, "integer(8)", false)
       else
         sql_type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: "integer(8)", type: :integer, limit: 8)
-        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, sql_type_metadata, false, "adverts")
+        ActiveRecord::ConnectionAdapters::Column.new("price", nil, sql_type_metadata, false, "adverts")
       end
+    end
+
+    it 'returns the attributes except name, position, and non-SQL options' do
+      subject = described_class.new(model, :price, :bigint, null: true, default: 0, ruby_default: -> { }, encrypt_using: -> { }, position: 2)
+      expect(subject.schema_attributes(col_spec)).to eq(type: :integer, limit: 8, null: true, default: 0)
+    end
+
+    it 'aliases :bigint and :integer limit: 8' do
+      int8 = described_class.new(model, :price, :integer, limit: 8, null: false, position: 0)
+      bigint = described_class.new(model, :price, :bigint,          null: false, position: 0)
+
+      expected_attributes = { type: :integer, limit: 8, null: false }
+      expect(int8.schema_attributes(col_spec)).to eq(expected_attributes)
+      expect(bigint.schema_attributes(col_spec)).to eq(expected_attributes)
+    end
+  end
 
-      expect(subject.different_to?(subject.name, col)).to eq(false)
+  describe '#sql_options' do
+    subject { described_class.new(model, :price, :integer, limit: 4, null: true, default: 0, position: 2, encrypt_using: ->(field) { field }) }
+    it 'excludes non-sql options' do
+      expect(subject.sql_options).to eq(limit: 4, null: true, default: 0)
     end
   end
 end