declare_schema 0.5.0 → 0.6.4

data/lib/declare_schema/model.rb

@@ -88,7 +88,7 @@ module DeclareSchema
         add_formatting_for_field(name, type)
         add_validations_for_field(name, type, args, options)
         add_index_for_field(name, args, options)
-        field_specs[name] = ::DeclareSchema::Model::FieldSpec.new(self, name, type, options)
+        field_specs[name] = ::DeclareSchema::Model::FieldSpec.new(self, name, type, position: field_specs.size, **options)
         attr_order << name unless attr_order.include?(name)
       end
 

data/lib/declare_schema/model/field_spec.rb

@@ -13,7 +13,6 @@ module DeclareSchema
       MYSQL_TEXT_LIMITS_ASCENDING = [MYSQL_TINYTEXT_LIMIT, MYSQL_TEXT_LIMIT, MYSQL_MEDIUMTEXT_LIMIT, MYSQL_LONGTEXT_LIMIT].freeze
 
       class << self
-        # method for easy stubbing in tests
         def mysql_text_limits?
           if defined?(@mysql_text_limits)
             @mysql_text_limits
@@ -33,7 +32,8 @@ module DeclareSchema
 
       attr_reader :model, :name, :type, :position, :options
 
-      def initialize(model, name, type, options = {})
+      def initialize(model, name, type, position: 0, **options)
+        # TODO: TECH-5116
         # Invoca change - searching for the primary key was causing an additional database read on every model load.  Assume
         # "id" which works for invoca.
         # raise ArgumentError, "you cannot provide a field spec for the primary key" if name == model.primary_key
@@ -43,9 +43,8 @@ module DeclareSchema
         @name = name.to_sym
         type.is_a?(Symbol) or raise ArgumentError, "type must be a Symbol; got #{type.inspect}"
         @type = type
-        position_option = options.delete(:position)
+        @position = position
         @options = options
-
         case type
         when :text
           @options[:default] and raise "default may not be given for :text field #{model}##{@name}"
@@ -54,11 +53,20 @@ module DeclareSchema
           end
         when :string
           @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)
+        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
         else
-          @options[:collation] and raise "collation may only given for :string and :text fields"
           @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"
         end
-        @position = position_option || model.field_specs.length
       end
 
       TYPE_SYNONYMS = { timestamp: :datetime }.freeze
@@ -105,16 +113,12 @@ module DeclareSchema
         @options[:default]
       end
 
-      def collation
-        if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
-          (@options[:collation] || model.table_options[:collation] || Generators::DeclareSchema::Migration::Migrator.default_collation).to_s
-        end
+      def charset
+        @options[:charset]
       end
 
-      def charset
-        if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
-          (@options[:charset] || model.table_options[:charset] || Generators::DeclareSchema::Migration::Migrator.default_charset).to_s
-        end
+      def collation
+        @options[:collation]
       end
 
       def same_type?(col_spec)

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/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.5.0"
+  VERSION = "0.6.4"
 end

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

@@ -37,11 +37,9 @@ module Generators
 
         def field_specs
           i = 0
-          foreign_keys.reduce({}) do |h, v|
-            # some trickery to avoid an infinite loop when FieldSpec#initialize tries to call model.field_specs
-            h[v] = ::DeclareSchema::Model::FieldSpec.new(self, v, :integer, position: i, null: false)
+          foreign_keys.each_with_object({}) do |v, result|
+            result[v] = ::DeclareSchema::Model::FieldSpec.new(self, v, :integer, position: i, null: false)
             i += 1
-            h
           end
         end
 
@@ -73,8 +71,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                        = []
@@ -84,9 +82,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
@@ -379,7 +386,7 @@ 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)
@@ -427,7 +434,7 @@ module Generators
               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}"
@@ -456,8 +463,8 @@ module Generators
               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?
+              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(", ")
@@ -466,7 +473,7 @@ module Generators
             end
           end.compact
 
-          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
@@ -488,7 +495,7 @@ module Generators
            undo_table_options_changes * "\n"]
         end
 
-        def change_indexes(model, old_table_name)
+        def change_indexes(model, old_table_name, to_remove)
           return [[], []] if Migrator.disable_constraints
 
           new_table_name = model.table_name
@@ -501,7 +508,10 @@ module Generators
               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
@@ -541,30 +551,31 @@ module Generators
 
           add_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
 
           drop_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)
           options.map do |k, v|
-            unless changing
-              next if k == :limit && (type == :decimal || v == native_types[type][:limit])
-              next if k == :null && v == true
+            if !changing && ((k == :limit && type == :decimal) || (k == :null && v == true))
+              next
             end
 
-            next if k == :limit && type == :text && !::DeclareSchema::Model::FieldSpec.mysql_text_limits?
+            if !::DeclareSchema::Model::FieldSpec.mysql_text_limits? && k == :limit && type == :text
+              next
+            end
 
             if k.is_a?(Symbol)
               "#{k}: #{v.inspect}"
@@ -578,9 +589,9 @@ module Generators
           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
@@ -609,6 +620,16 @@ module Generators
           end
         end
 
+        # TODO: TECH-4814 remove all methods from here through end of file
+        def default_collation_from_charset(charset)
+          case charset
+          when "utf8"
+            "utf8_general_ci"
+          when "utf8mb4"
+            "utf8mb4_general_ci"
+          end
+        end
+
         def revert_table(table)
           res = StringIO.new
           schema_dumper_klass = case Rails::VERSION::MAJOR
@@ -618,30 +639,55 @@ module Generators
                                   ActiveRecord::ConnectionAdapters::SchemaDumper
                                 end
           schema_dumper_klass.send(:new, ActiveRecord::Base.connection).send(:table, table, res)
-          res.string.strip.gsub("\n  ", "\n")
+
+          result = res.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")
+          end
+          result
         end
 
-        def column_options_from_reverted_table(table, col_name)
+        def column_options_from_reverted_table(table, column)
           revert = revert_table(table)
-          if (md = revert.match(/\s*t\.column\s+"#{col_name}",\s+(:[a-zA-Z0-9_]+)(?:,\s+(.*?)$)?/m))
+          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+"#{col_name}"(?:,\s+(.*?)$)?/m))
+          elsif (md = revert.match(/\s*t\.([a-z_]+)\s+"#{column}"(?:,\s+(.*?)$)?/m))
             # Sexy migration
-            _, type, options = *md
-            type = ":#{type}"
+            _, string_type, options = *md
+            type = ":#{string_type}"
           end
+          type or raise "unable to find column options for #{table}.#{column} in #{revert.inspect}"
           [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}"
+        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 if options}"
+          ["add_column :#{table}, :#{column}, #{type}", options&.strip].compact.join(', ')
         end
       end
     end