declare_schema 0.6.0 → 0.7.0

data/lib/declare_schema/model/table_options_definition.rb

@@ -26,12 +26,14 @@ module DeclareSchema
 
         def mysql_table_options(connection, table_name)
           database = connection.current_database
-          defaults = connection.select_one(<<~EOS)
+          defaults = connection.select_one(<<~EOS) or raise "no defaults found for table #{table_name}"
             SELECT CCSA.character_set_name, CCSA.collation_name
-            FROM information_schema.`TABLES` T, information_schema.`COLLATION_CHARACTER_SET_APPLICABILITY` CCSA
-            WHERE CCSA.collation_name = T.table_collation AND
-                  T.table_schema = '#{connection.quote_string(database)}' AND
-                  T.table_name = '#{connection.quote_string(table_name)}';
+            FROM information_schema.TABLES as T
+              JOIN information_schema.COLLATION_CHARACTER_SET_APPLICABILITY as CCSA
+                ON CCSA.collation_name = T.table_collation
+            WHERE
+              T.table_schema = '#{connection.quote_string(database)}' AND
+              T.table_name = '#{connection.quote_string(table_name)}'
           EOS
 
           defaults["character_set_name"] or raise "character_set_name missing from #{defaults.inspect}"
@@ -75,7 +77,7 @@ module DeclareSchema
       alias to_s settings
 
       def alter_table_statement
-        statement = "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name)} #{to_s};"
+        statement = "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name)} #{to_s}"
         "execute #{statement.inspect}"
       end
     end

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 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
@@ -71,8 +72,8 @@ module Generators
       class Migrator
         class Error < RuntimeError; end
 
-        DEFAULT_CHARSET   = :utf8mb4
-        DEFAULT_COLLATION = :utf8mb4_general
+        DEFAULT_CHARSET   = "utf8mb4"
+        DEFAULT_COLLATION = "utf8mb4_bin"
 
         @ignore_models                        = []
         @ignore_tables                        = []
@@ -82,9 +83,18 @@ module Generators
         @default_collation                    = DEFAULT_COLLATION
 
         class << self
-          attr_accessor :ignore_models, :ignore_tables, :disable_indexing, :disable_constraints,
-                        :active_record_class, :default_charset, :default_collation
-          attr_reader :before_generating_migration_callback
+          attr_accessor :ignore_models, :ignore_tables, :disable_indexing, :disable_constraints
+          attr_reader :active_record_class, :default_charset, :default_collation, :before_generating_migration_callback
+
+          def default_charset=(charset)
+            charset.is_a?(String) or raise ArgumentError, "charset must be a string (got #{charset.inspect})"
+            @default_charset = charset
+          end
+
+          def default_collation=(collation)
+            collation.is_a?(String) or raise ArgumentError, "collation must be a string (got #{collation.inspect})"
+            @default_collation = collation
+          end
 
           def active_record_class
             @active_record_class.is_a?(Class) or @active_record_class = @active_record_class.to_s.constantize
@@ -107,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
@@ -290,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|
@@ -336,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
 
@@ -377,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
 
@@ -420,12 +416,12 @@ 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
-            "add_column :#{new_table_name}, :#{c}, #{args.join(', ')}"
+            ["add_column :#{new_table_name}, :#{c}", *args].join(', ')
           end
           undo_adds = to_add.map do |c|
             "remove_column :#{new_table_name}, :#{c}"
@@ -435,36 +431,30 @@ 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[:collation]     = spec.collation     unless spec.collation.nil?
-              change_spec[:charset]       = spec.charset       unless spec.charset.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
+            if !::DeclareSchema::Model::Column.equivalent_schema_attributes?(spec_attrs, col_attrs)
+              normalized_schema_attributes = spec_attrs.merge(fk_field_options(model, col_name_to_change))
+
+              type = normalized_schema_attributes.delete(:type) or raise "no :type found in #{normalized_schema_attributes.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_attributes)].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)
+          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/)
                                           [[], []]
                                         else
@@ -476,41 +466,42 @@ 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)
-          return [[], []] if Migrator.disable_constraints
+        def change_indexes(model, old_table_name, to_remove)
+          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
-          existing_has_primary_key = existing_indexes.any? { |i| i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME }
+          existing_has_primary_key = existing_indexes.any? do |i|
+            i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME &&
+              !i.fields.all? { |f| to_remove.include?(f) } # if we're removing the primary key column(s), the primary key index will be removed too
+          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
@@ -526,59 +517,50 @@ 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|
-            unless changing
-              next if k == :limit && (type == :decimal || v == native_types[type][:limit])
-              next if k == :null && v == true
-            end
-
-            next if k == :limit && type == :text && !::DeclareSchema::Model::FieldSpec.mysql_text_limits?
-
             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)
           foreign_key = model.constraint_specs.find { |fk| field_name == fk.foreign_key.to_s }
           if foreign_key && (parent_table = foreign_key.parent_table_name)
             parent_columns = connection.columns(parent_table) rescue []
-            pk_limit  =
+            pk_limit =
               if (pk_column = parent_columns.find { |column| column.name.to_s == "id" }) # right now foreign keys assume id is the target
-                if Rails::VERSION::MAJOR <= 4
+                if Rails::VERSION::MAJOR < 5
                   pk_column.cast_type.limit
                 else
                   pk_column.limit
@@ -607,39 +589,83 @@ 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)
-          res.string.strip.gsub("\n  ", "\n")
+        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 column_options_from_reverted_table(table, col_name)
-          revert = revert_table(table)
-          if (md = revert.match(/\s*t\.column\s+"#{col_name}",\s+(:[a-zA-Z0-9_]+)(?:,\s+(.*?)$)?/m))
-            # Ugly migration
-            _, type, options = *md
-          elsif (md = revert.match(/\s*t\.([a-z_]+)\s+"#{col_name}"(?:,\s+(.*?)$)?/m))
-            # Sexy migration
-            _, type, options = *md
-            type = ":#{type}"
+        def default_collation_from_charset(charset)
+          case charset
+          when "utf8"
+            "utf8_general_ci"
+          when "utf8mb4"
+            "utf8mb4_general_ci"
           end
-          [type, options]
         end
 
-        def change_column_back(table, col_name)
-          type, options = column_options_from_reverted_table(table, col_name)
-          "change_column :#{table}, :#{col_name}, #{type}#{', ' + options.strip if options}"
+        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)
+
+          dumped_schema = dumped_schema_stream.string.strip.gsub!("\n  ", "\n")
+          if connection.class.name.match?(/mysql/i)
+            fix_mysql_charset_and_collation(dumped_schema)
+          else
+            dumped_schema
+          end
         end
 
-        def revert_column(table, column)
-          type, options = column_options_from_reverted_table(table, column)
-          "add_column :#{table}, :#{column}, #{type}#{', ' + options.strip if options}"
+        # 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
+          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