declare_schema 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e1d3c68c4e9b2f6ce739eba37ed19c5f80204495a50a9240e9f1f68a09777e3
-  data.tar.gz: 63e0a3205c82c2b5e6dacbfbfd10e9aa2e63eee5898d11fd5c102618e73755aa
+  metadata.gz: 59ff5d6d1a71b80a0541e2430f77665914d0c354ec92f31db8bbf22630fa5bef
+  data.tar.gz: dcaedebe325290c8c625c099b4d3cd6e2a87694f1d3cfec68811618f635715c1
 SHA512:
-  metadata.gz: 34ab74d97dd53c426d3a289b622670a42846d84279c2e3967ad0663c8f4871b1470a90b309237b09b09724a7e7c2405fb0f614a00d33902f8000bb1df23459ef
-  data.tar.gz: 2bf6ca852f71807e362ef26b4ba14d75b8a452a6245094eb8023fa1889b94d6584cf15856962f9fb85168208e0de4dd23a7942fb18cdcc5335f7c744382ba826
+  metadata.gz: 0a62a4236edd68e1429d4949b6745f34ed186acc24935bb027d1108b59372c0b681abc514963730c8e9e092769aa4a614a286c8815aa704a8dc24378e6cbe4ee
+  data.tar.gz: f8a9b7e40ffe14aa35e0a33d66c4e7dd820535ceacbc488bf159b386e28f5edf0d69896ff2e96a2c521e41e59c36fb9d7f47a6d1b6089a3625d8664a41be5b95

data/.github/dependabot.yml

@@ -0,0 +1,14 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: weekly
+    day: friday
+    time: "22:00"
+    timezone: PST8PDT
+  open-pull-requests-limit: 99
+  versioning-strategy: lockfile-only
+  commit-message:
+    prefix: No-Jira
+    include: scope

data/CHANGELOG.md

@@ -4,6 +4,15 @@ Inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 Note: this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2020-12-21
+### Added
+- Added support for configuring the character set and collation for MySQL databases
+  at the global, table, and field level
+
+## [0.4.2] - 2020-12-05
+### Fixed
+- Generalize the fix below to sqlite || Rails 4.
+
 ## [0.4.1] - 2020-12-04
 ### Fixed
 - Fixed a bug detecting compound primary keys in Rails 4.
@@ -11,7 +20,7 @@ Note: this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0
 ## [0.4.0] - 2020-11-20
 ### Added
 - Fields may be declared with `serialize: true` (any value with a valid `.to_yaml` stored as YAML),
-or `serialize: <serializeable-class>`, where `<serializeable-class>` 
+or `serialize: <serializeable-class>`, where `<serializeable-class>`
 may be `Array` (`Array` stored as YAML) or `Hash` (`Hash` stored as YAML) or `JSON` (any value with a valid `.to_json`, stored as JSON)
 or any custom serializable class.
 This invokes `ActiveSupport`'s `serialize` macro for that field, passing the serializable class, if given.
@@ -64,6 +73,8 @@ using the appropriate Rails configuration attributes.
 ### Added
 - Initial version from https://github.com/Invoca/hobo_fields v4.1.0.
 
+[0.5.0]: https://github.com/Invoca/declare_schema/compare/v0.4.2...v0.5.0
+[0.4.2]: https://github.com/Invoca/declare_schema/compare/v0.4.1...v0.4.2
 [0.4.1]: https://github.com/Invoca/declare_schema/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/Invoca/declare_schema/compare/v0.3.1...v0.4.0
 [0.3.1]: https://github.com/Invoca/declare_schema/compare/v0.3.0...v0.3.1

data/Gemfile

@@ -14,6 +14,7 @@ gem 'bundler',          '< 2'
 gem "climate_control",  '~> 0.2'
 gem 'pry'
 gem 'pry-byebug'
+gem 'mysql2'
 gem 'rails',            '~> 5.2', '>= 5.2.4.3'
 gem 'responders'
 gem 'rspec'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (0.4.1)
+    declare_schema (0.5.0)
       rails (>= 4.2)
 
 GEM
@@ -85,6 +85,7 @@ GEM
     mini_portile2 (2.4.0)
     minitest (5.14.2)
     msgpack (1.3.3)
+    mysql2 (0.5.3)
     nio4r (2.5.4)
     nokogiri (1.10.10)
       mini_portile2 (~> 2.4.0)
@@ -187,6 +188,7 @@ DEPENDENCIES
   climate_control (~> 0.2)
   declare_schema!
   listen
+  mysql2
   pry
   pry-byebug
   rails (~> 5.2, >= 5.2.4.3)

data/README.md

@@ -70,6 +70,72 @@ DeclareSchema::Migration::Migrator.before_generating_migration do
 end
 ```
 
+## Declaring Character Set and Collation
+_Note: This feature currently only works for MySQL database configurations._
+
+MySQL originally supported UTF-8 in the range of 1-3 bytes (`mb3` or "multi-byte 3")
+which covered the full set of Unicode code points at the time: U+0000 - U+FFFF.
+But later, Unicode was extended beyond U+FFFF to make room for emojis, and with that
+UTF-8 require 1-4 bytes (`mb4` or "multi-byte 4"). With this addition, there has
+come a need to dynamically define the character set and collation for individual
+tables and columns in the database. With `declare_schema` this can be configured
+at three separate levels
+
+### Global Configuration
+The character set and collation for all tables and fields can be set at the global level
+using the `Generators::DeclareSchema::Migrator.default_charset=` and
+`Generators::DeclareSchema::Migrator.default_collation=` configuration methods.
+
+For example, adding the following to your `config/initializers` directory will
+turn all tables into `utf8mb4` supporting tables:
+
+**declare_schema.rb**
+```ruby
+# frozen_string_literal: true
+
+Generators::DeclareSchema::Migration::Migrator.default_charset   = "utf8mb4"
+Generators::DeclareSchema::Migration::Migrator.default_collation = "utf8mb4_general"
+```
+
+### Table Configuration
+In order to configure a table's default character set and collation, the `charset` and
+`collation` arguments can be added to the `fields` block.
+
+For example, if you have a comments model that needs `utf8mb4` support, it would look
+like the following:
+
+**app/models/comment.rb**
+```ruby
+# frozen_string_literal: true
+
+class Comment < ActiveRecord::Base
+  fields charset: "utf8mb4", collation: "utf8mb4_general" do
+    subject :string, limit: 255
+    content :text,   limit: 0xffff_ffff
+  end
+end
+```
+
+### Field Configuration
+If you're looking to only change the character set and collation for a single field
+in the table, simply set the `charset` and `collation` configuration options on the
+field definition itself.
+
+For example, if you only want to support `utf8mb4` for the content of a comment, it would
+look like the following:
+
+**app/models/comment.rb**
+```ruby
+# frozen_string_literal: true
+
+class Comment < ActiveRecord::Base
+  fields do
+    subject :string, limit: 255
+    context :text,   limit: 0xffff_ffff, charset: "utf8mb4", collation: "utf8mb4_general"
+  end
+end
+```
+
 ## Installing
 
 Install the `DeclareSchema` gem directly:

data/gemfiles/rails_4.gemfile

@@ -7,6 +7,7 @@ gem "bundler", "< 2"
 gem "climate_control", "~> 0.2"
 gem "pry"
 gem "pry-byebug"
+gem "mysql2"
 gem "rails", "~> 4.2"
 gem "responders"
 gem "rspec"

data/gemfiles/rails_5.gemfile

@@ -7,6 +7,7 @@ gem "bundler", "< 2"
 gem "climate_control", "~> 0.2"
 gem "pry"
 gem "pry-byebug"
+gem "mysql2"
 gem "rails", "~> 5.2"
 gem "responders"
 gem "rspec"

data/gemfiles/rails_6.gemfile

@@ -7,6 +7,7 @@ gem "bundler", "< 2"
 gem "climate_control", "~> 0.2"
 gem "pry"
 gem "pry-byebug"
+gem "mysql2"
 gem "rails", "~> 6.0"
 gem "responders"
 gem "rspec"

data/lib/declare_schema.rb

@@ -41,5 +41,6 @@ require 'declare_schema/model'
 require 'declare_schema/model/field_spec'
 require 'declare_schema/model/index_definition'
 require 'declare_schema/model/foreign_key_definition'
+require 'declare_schema/model/table_options_definition'
 
 require 'declare_schema/railtie' if defined?(Rails)

data/lib/declare_schema/extensions/active_record/fields_declaration.rb

@@ -6,12 +6,13 @@ require 'declare_schema/field_declaration_dsl'
 
 module DeclareSchema
   module FieldsDsl
-    def fields(&block)
+    def fields(table_options = {}, &block)
       # Any model that calls 'fields' gets DeclareSchema::Model behavior
       DeclareSchema::Model.mix_in(self)
 
       # @include_in_migration = false #||= options.fetch(:include_in_migration, true); options.delete(:include_in_migration)
       @include_in_migration = true
+      @table_options        = table_options
 
       if block
         dsl = DeclareSchema::FieldDeclarationDsl.new(self, null: false)

data/lib/declare_schema/model.rb

@@ -30,6 +30,10 @@ module DeclareSchema
           inheriting_cattr_reader ignore_indexes: []
           inheriting_cattr_reader constraint_specs: []
 
+          # table_options holds optional configuration for the create_table statement
+          # supported options include :charset and :collation
+          inheriting_cattr_reader table_options: HashWithIndifferentAccess.new
+
           # eval avoids the ruby 1.9.2 "super from singleton method ..." error
 
           eval %(

data/lib/declare_schema/model/field_spec.rb

@@ -54,6 +54,9 @@ 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`?"
+        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"
         end
         @position = position_option || model.field_specs.length
       end
@@ -102,6 +105,18 @@ 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
+      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
+      end
+
       def same_type?(col_spec)
         type = sql_type
         normalized_type           = TYPE_SYNONYMS[type] || type
@@ -109,36 +124,77 @@ module DeclareSchema
         normalized_type == normalized_col_spec_type
       end
 
-      def different_to?(col_spec)
-        !same_type?(col_spec) ||
-          begin
-            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.any? 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
-              else
-                col_value = col_spec.send(k)
-                if col_value.nil? && native_type
-                  col_value = native_type[k]
-                end
-                col_value != send(k)
-              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
+          else
+            col_value = col_spec.send(k)
+            if col_value.nil? && native_type
+              col_value = native_type[k]
             end
+            col_value == send(k)
           end
+        end
       end
 
-      private
+      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
+          {}
+        end
+      end
 
       def native_type?(type)
         type.to_sym != :primary_key && native_types.has_key?(type)

data/lib/declare_schema/model/index_definition.rb

@@ -62,9 +62,9 @@ module DeclareSchema
 
         private
 
-        # This is the old approach which is still needed for SQLite
+        # This is the old approach which is still needed for MySQL in Rails 4 and SQLite
         def sqlite_compound_primary_key(model, table)
-          ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) or return nil
+          ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) || Rails::VERSION::MAJOR < 5 or return nil
 
           connection = model.connection.dup
 

data/lib/declare_schema/model/table_options_definition.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  module Model
+    class TableOptionsDefinition
+      include Comparable
+
+      TABLE_OPTIONS_TO_SQL_MAPPINGS = {
+        charset:   'CHARACTER SET',
+        collation: 'COLLATE'
+      }.freeze
+
+      class << self
+        def for_model(model, old_table_name = nil)
+          table_name    = old_table_name || model.table_name
+          table_options = if model.connection.class.name.match?(/mysql/i)
+                            mysql_table_options(model.connection, table_name)
+                          else
+                            {}
+                          end
+
+          new(table_name, table_options)
+        end
+
+        private
+
+        def mysql_table_options(connection, table_name)
+          database = connection.current_database
+          defaults = connection.select_one(<<~EOS)
+            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)}';
+          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"]
+          }
+        end
+      end
+
+      attr_reader :table_name, :table_options
+
+      def initialize(table_name, table_options = {})
+        @table_name    = table_name
+        @table_options = table_options
+      end
+
+      def to_key
+        @key ||= [table_name, table_options].map(&:to_s)
+      end
+
+      def settings
+        @settings ||= table_options.map { |name, value| "#{TABLE_OPTIONS_TO_SQL_MAPPINGS[name]} #{value}" if value }.compact.join(" ")
+      end
+
+      def hash
+        to_key.hash
+      end
+
+      def <=>(rhs)
+        to_key <=> rhs.to_key
+      end
+
+      def equivalent?(rhs)
+        settings == rhs.settings
+      end
+
+      alias eql? ==
+      alias to_s settings
+
+      def alter_table_statement
+        statement = "ALTER TABLE #{ActiveRecord::Base.connection.quote_table_name(table_name)} #{to_s};"
+        "execute #{statement.inspect}"
+      end
+    end
+  end
+end

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

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

@@ -23,6 +23,10 @@ module Generators
           end
         end
 
+        def table_options
+          {}
+        end
+
         def table_name
           join_table
         end
@@ -69,13 +73,19 @@ module Generators
       class Migrator
         class Error < RuntimeError; end
 
-        @ignore_models                    = []
-        @ignore_tables                    = []
+        DEFAULT_CHARSET   = :utf8mb4
+        DEFAULT_COLLATION = :utf8mb4_general
+
+        @ignore_models                        = []
+        @ignore_tables                        = []
         @before_generating_migration_callback = nil
-        @active_record_class              = ActiveRecord::Base
+        @active_record_class                  = ActiveRecord::Base
+        @default_charset                      = DEFAULT_CHARSET
+        @default_collation                    = DEFAULT_COLLATION
 
         class << self
-          attr_accessor :ignore_models, :ignore_tables, :disable_indexing, :disable_constraints, :active_record_class
+          attr_accessor :ignore_models, :ignore_tables, :disable_indexing, :disable_constraints,
+                        :active_record_class, :default_charset, :default_collation
           attr_reader :before_generating_migration_callback
 
           def active_record_class
@@ -292,52 +302,76 @@ module Generators
             "drop_table :#{t}"
           end * "\n"
 
-          changes = []
-          undo_changes = []
-          index_changes = []
-          undo_index_changes = []
-          fk_changes = []
-          undo_fk_changes = []
+          changes                    = []
+          undo_changes               = []
+          index_changes              = []
+          undo_index_changes         = []
+          fk_changes                 = []
+          undo_fk_changes            = []
+          table_options_changes      = []
+          undo_table_options_changes = []
+
           to_change.each do |t|
             model = models_by_table_name[t]
             table = to_rename.key(t) || model.table_name
             if table.in?(db_tables)
-              change, undo, index_change, undo_index, fk_change, undo_fk = change_table(model, table)
+              change, undo, index_change, undo_index, fk_change, undo_fk, table_options_change, undo_table_options_change = change_table(model, table)
               changes << change
               undo_changes << undo
               index_changes << index_change
               undo_index_changes << undo_index
               fk_changes << fk_change
               undo_fk_changes << undo_fk
+              table_options_changes << table_options_change
+              undo_table_options_changes << undo_table_options_change
             end
           end
 
-          up = [renames, drops, creates, changes, index_changes, fk_changes].flatten.reject(&:blank?) * "\n\n"
-          down = [undo_changes, undo_renames, undo_drops, undo_creates, undo_index_changes, undo_fk_changes].flatten.reject(&:blank?) * "\n\n"
+          up = [renames, drops, creates, changes, index_changes, fk_changes, table_options_changes].flatten.reject(&:blank?) * "\n\n"
+          down = [undo_changes, undo_renames, undo_drops, undo_creates, undo_index_changes, undo_fk_changes, undo_table_options_changes].flatten.reject(&:blank?) * "\n\n"
 
           [up, down]
         end
 
         def create_table(model)
-          longest_field_name = model.field_specs.values.map { |f| f.sql_type.to_s.length }.max
-          disable_auto_increment = model.respond_to?(:disable_auto_increment) && model.disable_auto_increment
-          primary_key_option =
-            if model.primary_key.blank? || disable_auto_increment
-              ", id: false"
-            elsif model.primary_key == "id"
-              ", id: :bigint"
-            else
-              ", primary_key: :#{model.primary_key}"
+          longest_field_name       = model.field_specs.values.map { |f| f.sql_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,
+            *(model.field_specs.values.sort_by(&:position).map { |f| create_field(f, longest_field_name) })
+          ].compact
+
+          <<~EOS.strip
+            create_table :#{model.table_name}, #{create_table_options(model, disable_auto_increment)} do |t|
+              #{field_definitions.join("\n")}
             end
-          (["create_table :#{model.table_name}#{primary_key_option} do |t|"] +
-          [(disable_auto_increment ? "  t.integer :id, limit: 8, auto_increment: false, primary_key: true" : nil)] +
-           model.field_specs.values.sort_by(&:position).map { |f| create_field(f, longest_field_name) } +
-           ["end"] + (if Migrator.disable_indexing
-                        []
-                      else
-                        create_indexes(model) +
-                           create_constraints(model)
-                      end)).compact * "\n"
+
+            #{table_options_definition.alter_table_statement unless ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)}
+            #{create_indexes(model).join("\n")               unless Migrator.disable_indexing}
+            #{create_constraints(model).join("\n")           unless Migrator.disable_indexing}
+          EOS
+        end
+
+        def create_table_options(model, disable_auto_increment)
+          if model.primary_key.blank? || disable_auto_increment
+            "id: false"
+          elsif model.primary_key == "id"
+            "id: :bigint"
+          else
+            "primary_key: :#{model.primary_key}"
+          end
+        end
+
+        def table_options_for_model(model)
+          if ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
+            {}
+          else
+            {
+              charset:   model.table_options[:charset] || Migrator.default_charset,
+              collation: model.table_options[:collation] || Migrator.default_collation
+            }
+          end
         end
 
         def create_indexes(model)
@@ -351,7 +385,7 @@ module Generators
         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(', '))
+          format("t.%-*s %s", field_name_width, field_spec.sql_type, args.join(', '))
         end
 
         def change_table(model, current_table_name)
@@ -413,15 +447,17 @@ module Generators
             col_name = old_names[c] || c
             col = db_columns[col_name]
             spec = model.field_specs[c]
-            if spec.different_to?(col) # TODO: TECH-4814 DRY this up to a diff function that returns the differences. It's different if it has differences. -Colin
+            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[: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(", ")
@@ -436,13 +472,20 @@ module Generators
                                         else
                                           change_foreign_key_constraints(model, current_table_name)
                                         end
+          table_options_changes, undo_table_options_changes = if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
+                                                                change_table_options(model, current_table_name)
+                                                              else
+                                                                [[], []]
+                                                              end
 
           [(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"]
+           undo_fk_changes * "\n",
+           table_options_changes * "\n",
+           undo_table_options_changes * "\n"]
         end
 
         def change_indexes(model, old_table_name)
@@ -552,6 +595,20 @@ module Generators
           end
         end
 
+        def change_table_options(model, current_table_name)
+          old_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.for_model(model, current_table_name)
+          new_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.new(model.table_name, table_options_for_model(model))
+
+          if old_options_definition.equivalent?(new_options_definition)
+            [[], []]
+          else
+            [
+              [new_options_definition.alter_table_statement],
+              [old_options_definition.alter_table_statement]
+            ]
+          end
+        end
+
         def revert_table(table)
           res = StringIO.new
           schema_dumper_klass = case Rails::VERSION::MAJOR

data/spec/lib/declare_schema/generator_spec.rb

@@ -27,15 +27,28 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     EOS
 
-    expect_test_definition_to_eq('alpha/beta', <<~EOS)
-      require 'test_helper'
-
-      class Alpha::BetaTest < ActiveSupport::TestCase
-        # test "the truth" do
-        #   assert true
-        # end
-      end
-    EOS
+    case Rails::VERSION::MAJOR
+    when 4, 5
+      expect_test_definition_to_eq('alpha/beta', <<~EOS)
+        require 'test_helper'
+
+        class Alpha::BetaTest < ActiveSupport::TestCase
+          # test "the truth" do
+          #   assert true
+          # end
+        end
+      EOS
+    else
+      expect_test_definition_to_eq('alpha/beta', <<~EOS)
+        require "test_helper"
+
+        class Alpha::BetaTest < ActiveSupport::TestCase
+          # test "the truth" do
+          #   assert true
+          # end
+        end
+      EOS
+    end
 
     case Rails::VERSION::MAJOR
     when 4

data/spec/lib/declare_schema/model/table_options_definition_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/mysql2_adapter'
+require_relative '../../../../lib/declare_schema/model/table_options_definition'
+
+RSpec.describe DeclareSchema::Model::TableOptionsDefinition do
+  before do
+    load File.expand_path('../prepare_testapp.rb', __dir__)
+
+    class TableOptionsDefinitionTestModel < ActiveRecord::Base
+      fields do
+        name :string, limit: 127, index: true
+      end
+    end
+  end
+
+  let(:model_class) { TableOptionsDefinitionTestModel }
+
+  context 'instance methods' do
+    let(:table_options) { { charset: "utf8", collation: "utf8_general"} }
+    let(:model) { described_class.new('table_options_definition_test_models', table_options) }
+
+    describe '#to_key' do
+      subject { model.to_key }
+      it { should eq(["table_options_definition_test_models", "{:charset=>\"utf8\", :collation=>\"utf8_general\"}"]) }
+    end
+
+    describe '#settings' do
+      subject { model.settings }
+      it { should eq("CHARACTER SET utf8 COLLATE utf8_general") }
+    end
+
+    describe '#hash' do
+      subject { model.hash }
+      it { should eq(["table_options_definition_test_models", "{:charset=>\"utf8\", :collation=>\"utf8_general\"}"].hash) }
+    end
+
+    describe '#to_s' do
+      subject { model.to_s }
+      it { should eq("CHARACTER SET utf8 COLLATE utf8_general") }
+    end
+
+    describe '#alter_table_statement' do
+      subject { model.alter_table_statement }
+      it { should eq('execute "ALTER TABLE \"table_options_definition_test_models\" CHARACTER SET utf8 COLLATE utf8_general;"') }
+    end
+  end
+
+
+  context 'class << self' do
+    describe '#for_model' do
+      context 'when using a SQLite connection' do
+        subject { described_class.for_model(model_class) }
+        it { should eq(described_class.new(model_class.table_name, {})) }
+      end
+      # TODO: Convert these tests to run against a MySQL database so that we can
+      #       perform them without mocking out so much
+      context 'when using a MySQL connection' do
+        before do
+          double(ActiveRecord::ConnectionAdapters::Mysql2Adapter).tap do |stub_connection|
+            expect(stub_connection).to receive(:class).and_return(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
+            expect(stub_connection).to receive(:current_database).and_return('test_database')
+            expect(stub_connection).to receive(:quote_string).with('test_database').and_return('test_database')
+            expect(stub_connection).to receive(:quote_string).with(model_class.table_name).and_return(model_class.table_name)
+            expect(stub_connection).to(
+              receive(:select_one).with(<<~EOS)
+                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 = 'test_database' AND
+                      T.table_name = '#{model_class.table_name}';
+              EOS
+              .and_return({ "character_set_name" => "utf8", "collation_name" => "utf8_general" })
+            )
+            allow(model_class).to receive(:connection).and_return(stub_connection)
+          end
+        end
+
+        subject { described_class.for_model(model_class) }
+        it { should eq(described_class.new(model_class.table_name, { charset: "utf8", collation: "utf8_general" })) }
+      end
+    end
+  end
+end

data/spec/lib/generators/declare_schema/migration/migrator_spec.rb

@@ -43,6 +43,34 @@ module Generators
           end
         end
 
+        describe '#default_charset' do
+          subject { described_class.default_charset }
+
+          context 'when not explicitly set' do
+            it { should eq(:utf8mb4) }
+          end
+
+          context 'when explicitly set' do
+            before { described_class.default_charset = :utf8 }
+            after  { described_class.default_charset = described_class::DEFAULT_CHARSET }
+            it     { should eq(:utf8) }
+          end
+        end
+
+        describe '#default_collation' do
+          subject { described_class.default_collation }
+
+          context 'when not explicitly set' do
+            it { should eq(:utf8mb4_general) }
+          end
+
+          context 'when explicitly set' do
+            before { described_class.default_collation = :utf8mb4_general_ci }
+            after  { described_class.default_collation = described_class::DEFAULT_COLLATION }
+            it     { should eq(:utf8mb4_general_ci) }
+          end
+        end
+
         describe 'load_rails_models' do
           before do
             expect(Rails.application).to receive(:eager_load!)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: declare_schema
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-05 00:00:00.000000000 Z
+date: 2020-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -32,7 +32,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".dependabot/config.yml"
+- ".github/dependabot.yml"
 - ".github/workflows/gem_release.yml"
 - ".gitignore"
 - ".rspec"
@@ -61,6 +61,7 @@ files:
 - lib/declare_schema/model/field_spec.rb
 - lib/declare_schema/model/foreign_key_definition.rb
 - lib/declare_schema/model/index_definition.rb
+- lib/declare_schema/model/table_options_definition.rb
 - lib/declare_schema/railtie.rb
 - lib/declare_schema/version.rb
 - lib/generators/declare_schema/migration/USAGE
@@ -78,6 +79,7 @@ files:
 - spec/lib/declare_schema/interactive_primary_key_spec.rb
 - spec/lib/declare_schema/migration_generator_spec.rb
 - spec/lib/declare_schema/model/index_definition_spec.rb
+- spec/lib/declare_schema/model/table_options_definition_spec.rb
 - spec/lib/declare_schema/prepare_testapp.rb
 - spec/lib/generators/declare_schema/migration/migrator_spec.rb
 - spec/spec_helper.rb
@@ -87,7 +89,7 @@ homepage: https://github.com/Invoca/declare_schema
 licenses: []
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -103,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Database migration generator for Rails
 test_files: []

data/.dependabot/config.yml

@@ -1,10 +0,0 @@
----
-version: 1
-update_configs:
-- package_manager: "ruby:bundler"
-  directory: "/"
-  update_schedule: "weekly"
-  version_requirement_updates: "off"
-  commit_message:
-    prefix: "No-Jira"
-    include_scope: true