declare_schema 0.6.1 → 0.7.1

data/lib/declare_schema/model/field_spec.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
+require_relative 'column'
+
 module DeclareSchema
+  class MysqlTextMayNotHaveDefault < RuntimeError; end
+
   module Model
     class FieldSpec
-      class UnknownSqlTypeError < RuntimeError; end
 
       MYSQL_TINYTEXT_LIMIT    = 0xff
       MYSQL_TEXT_LIMIT        = 0xffff
@@ -30,7 +33,18 @@ module DeclareSchema
         end
       end
 
-      attr_reader :model, :name, :type, :position, :options
+      attr_reader :model, :name, :type, :sql_type, :position, :options, :sql_options
+
+      TYPE_SYNONYMS = { timestamp: :datetime }.freeze # TODO: drop this synonym. -Colin
+
+      SQL_OPTIONS     = [:limit, :precision, :scale, :null, :default, :charset, :collation].freeze
+      NON_SQL_OPTIONS = [:ruby_default, :validates].freeze
+      VALID_OPTIONS   = (SQL_OPTIONS + NON_SQL_OPTIONS).freeze
+      OPTION_INDEXES  = Hash[VALID_OPTIONS.each_with_index.to_a].freeze
+
+      VALID_OPTIONS.each do |option|
+        define_method(option) { @options[option] }
+      end
 
       def initialize(model, name, type, position: 0, **options)
         # TODO: TECH-5116
@@ -42,170 +56,72 @@ module DeclareSchema
         @model = model
         @name = name.to_sym
         type.is_a?(Symbol) or raise ArgumentError, "type must be a Symbol; got #{type.inspect}"
-        @type = type
+        @type = TYPE_SYNONYMS[type] || type
         @position = position
-        @options = options
+        @options = options.dup
+
+        @options.has_key?(:null) or @options[:null] = false
+
         case type
         when :text
-          @options[:default] and raise "default may not be given for :text field #{model}##{@name}"
           if self.class.mysql_text_limits?
+            @options[:default].nil? or raise MysqlTextMayNotHaveDefault, "when using MySQL, non-nil default may not be given for :text field #{model}##{@name}"
             @options[:limit] = self.class.round_up_mysql_text_limit(@options[:limit] || MYSQL_LONGTEXT_LIMIT)
+          else
+            @options[:limit] = nil
           end
         when :string
-          @options[:limit] or raise "limit must be given for :string field #{model}##{@name}: #{@options.inspect}; do you want `limit: 255`?"
+          @options[:limit] or raise "limit: must be given for :string field #{model}##{@name}: #{@options.inspect}; do you want `limit: 255`?"
         when :bigint
           @type = :integer
-          @options = options.merge(limit: 8)
+          @options[:limit] = 8
         end
 
-        if type.in?([:text, :string])
-          if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
-            @options[:charset]   ||= model.table_options[:charset]   || Generators::DeclareSchema::Migration::Migrator.default_charset
-            @options[:collation] ||= model.table_options[:collation] || Generators::DeclareSchema::Migration::Migrator.default_collation
-          end
+        # TODO: Do we really need to support a :sql_type option? Ideally, drop it. -Colin
+        @sql_type = @options.delete(:sql_type) || Column.sql_type(@type)
+
+        if @sql_type.in?([:string, :text, :binary, :varbinary, :integer, :enum])
+          @options[:limit] ||= Column.native_types[@sql_type][:limit]
         else
-          @options[:charset]   and raise "charset may only given for :string and :text fields"
-          @options[:collation] and raise "collation may only given for :string and :text fields"
+          @sql_type != :decimal && @options.has_key?(:limit) and warn("unsupported limit: for SQL type #{@sql_type} in field #{model}##{@name}")
+          @options.delete(:limit)
         end
-      end
 
-      TYPE_SYNONYMS = { timestamp: :datetime }.freeze
-
-      SQLITE_COLUMN_CLASS =
-        begin
-          ActiveRecord::ConnectionAdapters::SQLiteColumn
-        rescue NameError
-          NilClass
+        if @sql_type == :decimal
+          @options[:precision] or warn("precision: required for :decimal type in field #{model}##{@name}")
+          @options[:scale] or warn("scale: required for :decimal type in field #{model}##{@name}")
+        else
+          if @sql_type != :datetime
+            @options.has_key?(:precision) and warn("precision: only allowed for :decimal type or :datetime for SQL type #{@sql_type} in field #{model}##{@name}")
+          end
+          @options.has_key?(:scale) and warn("scale: only allowed for :decimal type for SQL type #{@sql_type} in field #{model}##{@name}")
         end
 
-      def sql_type
-        @options[:sql_type] || begin
-                                if native_type?(type)
-                                  type
-                                else
-                                  field_class = DeclareSchema.to_class(type)
-                                  field_class && field_class::COLUMN_TYPE or raise UnknownSqlTypeError, "#{type.inspect} for #{model}##{@name}"
-                                end
-                              end
-      end
-
-      def sql_options
-        @options.except(:ruby_default, :validates)
-      end
-
-      def limit
-        @options[:limit] || native_types[sql_type][:limit]
-      end
-
-      def precision
-        @options[:precision]
-      end
-
-      def scale
-        @options[:scale]
-      end
-
-      def null
-        !:null.in?(@options) || @options[:null]
-      end
-
-      def default
-        @options[:default]
-      end
-
-      def charset
-        @options[:charset]
-      end
-
-      def collation
-        @options[:collation]
-      end
-
-      def same_type?(col_spec)
-        type = sql_type
-        normalized_type           = TYPE_SYNONYMS[type] || type
-        normalized_col_spec_type  = TYPE_SYNONYMS[col_spec.type] || col_spec.type
-        normalized_type == normalized_col_spec_type
-      end
-
-      def different_to?(table_name, col_spec)
-        !same_as(table_name, col_spec)
-      end
-
-      def same_as(table_name, col_spec)
-        same_type?(col_spec) &&
-          same_attributes?(col_spec) &&
-          (!type.in?([:text, :string]) || same_charset_and_collation?(table_name, col_spec))
-      end
-
-      private
-
-      def same_attributes?(col_spec)
-        native_type = native_types[type]
-        check_attributes = [:null, :default]
-        check_attributes += [:precision, :scale] if sql_type == :decimal && !col_spec.is_a?(SQLITE_COLUMN_CLASS)  # remove when rails fixes https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2872
-        check_attributes -= [:default] if sql_type == :text && col_spec.class.name =~ /mysql/i
-        check_attributes << :limit if sql_type.in?([:string, :binary, :varbinary, :integer, :enum]) ||
-                                      (sql_type == :text && self.class.mysql_text_limits?)
-        check_attributes.all? do |k|
-          if k == :default
-            case Rails::VERSION::MAJOR
-            when 4
-              col_spec.type_cast_from_database(col_spec.default) == col_spec.type_cast_from_database(default)
-            else
-              cast_type = ActiveRecord::Base.connection.lookup_cast_type_from_column(col_spec) or raise "cast_type not found for #{col_spec.inspect}"
-              cast_type.deserialize(col_spec.default) == cast_type.deserialize(default)
-            end
+        if @type.in?([:text, :string])
+          if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
+            @options[:charset]   ||= model.table_options[:charset]   || Generators::DeclareSchema::Migration::Migrator.default_charset
+            @options[:collation] ||= model.table_options[:collation] || Generators::DeclareSchema::Migration::Migrator.default_collation
           else
-            col_value = col_spec.send(k)
-            if col_value.nil? && native_type
-              col_value = native_type[k]
-            end
-            col_value == send(k)
+            @options.delete(:charset)
+            @options.delete(:collation)
           end
-        end
-      end
-
-      def same_charset_and_collation?(table_name, col_spec)
-        current_collation_and_charset = collation_and_charset_for_column(table_name, col_spec)
-
-        collation == current_collation_and_charset[:collation] &&
-          charset == current_collation_and_charset[:charset]
-      end
-
-      def collation_and_charset_for_column(table_name, col_spec)
-        column_name   = col_spec.name
-        connection    = ActiveRecord::Base.connection
-
-        if connection.class.name.match?(/mysql/i)
-          database_name = connection.current_database
-
-          defaults = connection.select_one(<<~EOS)
-            SELECT C.character_set_name, C.collation_name
-            FROM information_schema.`COLUMNS` C
-            WHERE C.table_schema = '#{connection.quote_string(database_name)}' AND
-                  C.table_name = '#{connection.quote_string(table_name)}' AND
-                  C.column_name = '#{connection.quote_string(column_name)}';
-          EOS
-
-          defaults["character_set_name"] or raise "character_set_name missing from #{defaults.inspect}"
-          defaults["collation_name"]     or raise "collation_name missing from #{defaults.inspect}"
-
-          {
-            charset:   defaults["character_set_name"],
-            collation: defaults["collation_name"]
-          }
         else
-          {}
+          @options[:charset]   and warn("charset may only given for :string and :text fields for SQL type #{@sql_type} in field #{model}##{@name}")
+          @options[:collation] and warne("collation may only given for :string and :text fields for SQL type #{@sql_type} in field #{model}##{@name}")
         end
-      end
 
-      def native_type?(type)
-        type.to_sym != :primary_key && native_types.has_key?(type)
+        @options = Hash[@options.sort_by { |k, _v| OPTION_INDEXES[k] || 9999 }]
+
+        @sql_options = @options.slice(*SQL_OPTIONS)
       end
 
-      def native_types
-        Generators::DeclareSchema::Migration::Migrator.native_types
+      # returns the attributes for schema migrations as a Hash
+      # omits name and position since those are meta-data above the schema
+      # omits keys with nil values
+      def schema_attributes(col_spec)
+        @sql_options.merge(type: @type).tap do |attrs|
+          attrs[:default] = Column.deserialize_default_value(col_spec, @sql_type, attrs[:default])
+        end.compact
       end
     end
   end

data/lib/declare_schema/model/foreign_key_definition.rb

@@ -5,21 +5,21 @@ module DeclareSchema
     class ForeignKeyDefinition
       include Comparable
 
-      attr_reader :constraint_name, :model, :foreign_key, :options, :on_delete_cascade
+      attr_reader :constraint_name, :model, :foreign_key, :foreign_key_name, :options, :on_delete_cascade
 
       def initialize(model, foreign_key, options = {})
         @model = model
-        @foreign_key = foreign_key.presence
+        @foreign_key = foreign_key.to_s.presence
         @options = options
 
         @child_table = model.table_name # unless a table rename, which would happen when a class is renamed??
-        @parent_table_name = options[:parent_table]
-        @foreign_key_name = options[:foreign_key] || self.foreign_key
-        @index_name = options[:index_name] || model.connection.index_name(model.table_name, column: foreign_key)
-        @constraint_name = options[:constraint_name] || @index_name || ''
-        @on_delete_cascade = options[:dependent] == :delete
+        @parent_table_name = options[:parent_table]&.to_s
+        @foreign_key_name = options[:foreign_key]&.to_s || @foreign_key
+        @index_name = options[:index_name]&.to_s || model.connection.index_name(model.table_name, column: @foreign_key_name)
 
         # Empty constraint lets mysql generate the name
+        @constraint_name = options[:constraint_name]&.to_s || @index_name&.to_s || ''
+        @on_delete_cascade = options[:dependent] == :delete
       end
 
       class << self
@@ -28,11 +28,12 @@ module DeclareSchema
           constraints = show_create_table.split("\n").map { |line| line.strip if line['CONSTRAINT'] }.compact
 
           constraints.map do |fkc|
-            options = {}
             name, foreign_key, parent_table = fkc.match(/CONSTRAINT `([^`]*)` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)`/).captures
-            options[:constraint_name] = name
-            options[:parent_table] = parent_table
-            options[:foreign_key] = foreign_key
+            options = {
+              constraint_name: name,
+              parent_table:    parent_table,
+              foreign_key:     foreign_key
+            }
             options[:dependent] = :delete if fkc['ON DELETE CASCADE']
 
             new(model, foreign_key, options)
@@ -40,21 +41,37 @@ module DeclareSchema
         end
       end
 
+      # returns the parent class as a Class object
+      # or nil if no :class_name option given
+      def parent_class
+        if (class_name = options[:class_name])
+          if class_name.is_a?(Class)
+            class_name
+          else
+            class_name.to_s.constantize
+          end
+        end
+      end
+
       def parent_table_name
         @parent_table_name ||=
-          if (klass = options[:class_name])
-            klass = klass.to_s.constantize unless klass.is_a?(Class)
-            klass.try(:table_name)
-          end || foreign_key.sub(/_id\z/, '').camelize.constantize.table_name
+          parent_class&.try(:table_name) ||
+            foreign_key.sub(/_id\z/, '').camelize.constantize.table_name
       end
 
-      attr_writer :parent_table_name
-
       def to_add_statement
-        statement = "ALTER TABLE #{@child_table} ADD CONSTRAINT #{@constraint_name} FOREIGN KEY #{@index_name}(#{@foreign_key_name}) REFERENCES #{parent_table_name}(id) #{'ON DELETE CASCADE' if on_delete_cascade}"
-        "execute #{statement.inspect}"
+        "add_foreign_key(#{@child_table.inspect}, #{parent_table_name.inspect}, " +
+          "column: #{@foreign_key_name.inspect}, name: #{@constraint_name.inspect})"
+      end
+
+      def <=>(rhs)
+        key <=> rhs.send(:key)
       end
 
+      alias eql? ==
+
+      private
+
       def key
         @key ||= [@child_table, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
       end
@@ -62,12 +79,6 @@ module DeclareSchema
       def hash
         key.hash
       end
-
-      def <=>(rhs)
-        key <=> rhs.key
-      end
-
-      alias eql? ==
     end
   end
 end

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "0.6.1"
+  VERSION = "0.7.1"
 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::UnknownSqlTypeError => 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|
@@ -345,7 +332,7 @@ module Generators
           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
 
@@ -386,12 +373,12 @@ module Generators
         end
 
         def create_constraints(model)
-          model.constraint_specs.map { |fk| fk.to_add_statement(model.table_name) }
+          model.constraint_specs.map { |fk| fk.to_add_statement }
         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)
+          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.sql_type, args.join(', '))
         end
 
@@ -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.sql_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,51 +517,41 @@ 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.options[:constraint_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.options[:constraint_name])
+            remove_foreign_key(new_table_name, fk.constraint_name)
           end
 
           [drop_fks + add_fks, undo_add_fks + undo_drop_fks]
         end
 
         def remove_foreign_key(old_table_name, fk_name)
-          "remove_foreign_key('#{old_table_name}', name: '#{fk_name}')"
+          "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