declare_schema 0.4.0 → 0.5.0.pre.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e5c665ec203dd84e445290bac1de190491560ddc409fe2bd3f5ba4831e065c5
-  data.tar.gz: 244148b892d2de22a692c4db50b136995f97d8da38573e87a443303fdee5be7a
+  metadata.gz: d0fc9a936c7e14850eb00ae650edd879d4da0971c90d54ccc573293e8a2a690a
+  data.tar.gz: 5ce7613f80340733d6775f5416fb2d27d34c1497032b5c87adef9ff9988c6057
 SHA512:
-  metadata.gz: 44994fd571b97768ffec2c9bbce779b8beef222ba50213a425a3021c66f1dc4e4fd7a50adc95cf3d1a1116e67eaf5c47b11e635408856c726118a22c18188b98
-  data.tar.gz: 7d3eb3be095a1dce65b6b39b35974a6c96ee940fec31dba3fddbfb528be8be3b42906ec81c6075cde5d8fa590df4afc8ca12887a956c772fc34c084791577526
+  metadata.gz: 589b1f1de17bad311a9182fb30fac5e05b1ed151c4e430b449600efb4ed95f795d25f9cf7357298ffd803e40bb720ec01d6536923dc880c9ea7648d25876a369
+  data.tar.gz: 80b8d072e0ecb96302df946e529bdf32f590f3acfc7cbc0dd47bd0ecb4b22be87dd0a9a22defbd1b1e7cf3746e8542c3b233254234eafaf0592724b331bddcfc

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,10 +4,24 @@ 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] - Unreleased
+### 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.
+
 ## [0.4.0] - 2020-11-20
 ### Added
-- Fields may be declared with `serialize: true` or `serialize: <serializeable-class>`, where `<serializeable-class>` 
-may be `Array` (`Array` stored as YAML) or `Hash` (`Hash` stored as YAML), (`Array` or `Hash` or any scalar value stored as JSON)
+- Fields may be declared with `serialize: true` (any value with a valid `.to_yaml` stored as YAML),
+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.
 
@@ -55,11 +69,13 @@ using the appropriate Rails configuration attributes.
 ### Changed
 - Added travis support and created 2 specs as a starting point.
 
-
 ## [0.1.1] - 2020-09-24
 ### 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
 [0.3.0]: https://github.com/Invoca/declare_schema/compare/v0.2.0...v0.3.0

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.0)
+    declare_schema (0.5.0.pre.3)
       rails (>= 4.2)
 
 GEM
@@ -54,7 +54,7 @@ GEM
       thor (>= 0.14.0)
     arel (9.0.0)
     ast (2.4.1)
-    bootsnap (1.5.0)
+    bootsnap (1.5.1)
       msgpack (~> 1.0)
     builder (3.2.4)
     byebug (11.1.3)
@@ -69,7 +69,7 @@ GEM
       activesupport (>= 4.2.0)
     i18n (1.8.5)
       concurrent-ruby (~> 1.0)
-    listen (3.2.1)
+    listen (3.3.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
     loofah (2.7.0)
@@ -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::Migrator.default_charset   = "utf8mb4"
+Generators::DeclareSchema::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

@@ -37,16 +37,9 @@ module DeclareSchema
         def for_model(model, old_table_name = nil)
           t = old_table_name || model.table_name
 
-          primary_key_columns = Array(model.connection.primary_key(t)).presence || begin
-            cols = model.connection.columns(t)
-            Array(
-              if cols.any? { |col| col.name == 'id' }
-                'id'
-              else
-                cols.find { |col| col.type.to_s.include?('int') }&.name or raise "could not guess primary key for #{t} in #{cols.inspect}"
-              end
-            )
-          end
+          primary_key_columns = Array(model.connection.primary_key(t)).presence || sqlite_compound_primary_key(model, t) or
+            raise "could not find primary key for table #{t} in #{model.connection.columns(t).inspect}"
+
           primary_key_found = false
           index_definitions = model.connection.indexes(t).map do |i|
             model.ignore_indexes.include?(i.name) and next
@@ -55,7 +48,8 @@ module DeclareSchema
                 raise "primary key on #{t} was not unique on #{primary_key_columns} (was unique=#{i.unique} on #{i.columns})"
               primary_key_found = true
             elsif i.columns == primary_key_columns && i.unique
-              raise "found primary key index on #{t}.#{primary_key_columns} but it was called #{i.name}"
+              # skip this primary key index since we'll create it below, with PRIMARY_KEY_NAME
+              next
             end
             new(model, i.columns, name: i.name, unique: i.unique, where: i.where, table_name: old_table_name)
           end.compact
@@ -65,6 +59,30 @@ module DeclareSchema
           end
           index_definitions
         end
+
+        private
+
+        # 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/) || Rails::VERSION::MAJOR < 5 or return nil
+
+          connection = model.connection.dup
+
+          class << connection   # defeat Rails MySQL driver code that skips the primary key by changing its name to a symbol
+            def each_hash(result)
+              super do |hash|
+                if hash[:Key_name] == PRIMARY_KEY_NAME
+                  hash[:Key_name] = PRIMARY_KEY_NAME.to_sym
+                end
+                yield hash
+              end
+            end
+          end
+
+          pk_index = connection.indexes(table).find { |index| index.name.to_s == PRIMARY_KEY_NAME } or return nil
+
+          Array(pk_index.columns)
+        end
       end
 
       def primary_key?

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.0"
+  VERSION = "0.5.0.pre.3"
 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/api_spec.rb

@@ -39,7 +39,7 @@ RSpec.describe 'DeclareSchema API' do
 
       load_models
 
-      unless Rails::VERSION::MAJOR >= 6
+      if Rails::VERSION::MAJOR == 5
         # TODO: get this to work on Travis for Rails 6
         generate_migrations '-n', '-m'
       end

data/spec/lib/declare_schema/migration_generator_spec.rb

@@ -43,6 +43,12 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     ActiveRecord::Migration.class_eval(up)
     expect(Advert.columns.map(&:name)).to eq(["id", "name"])
 
+    if Rails::VERSION::MAJOR < 5
+      # Rails 4 sqlite driver doesn't create PK properly. Fix that by dropping and recreating.
+      ActiveRecord::Base.connection.execute("drop table adverts")
+      ActiveRecord::Base.connection.execute('CREATE TABLE "adverts" ("id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, "name" varchar(255))')
+    end
+
     class Advert < ActiveRecord::Base
       fields do
         name :string, limit: 255, null: true
@@ -610,9 +616,8 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     # Dropping tables is where the automatic down-migration really comes in handy:
 
     rails4_table_create = <<~EOS.strip
-      create_table "adverts", id: false, force: :cascade do |t|
-        t.integer "id",   limit: 8
-        t.string  "name", limit: 255
+      create_table "adverts", force: :cascade do |t|
+        t.string "name", limit: 255
       end
     EOS
 

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

@@ -13,16 +13,25 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
   before do
     load File.expand_path('../prepare_testapp.rb', __dir__)
 
-    class IndexSettingsTestModel < ActiveRecord::Base
+    class IndexDefinitionTestModel < ActiveRecord::Base
       fields do
         name :string, limit: 127, index: true
 
         timestamps
       end
     end
+
+    class IndexDefinitionCompoundIndexModel < ActiveRecord::Base
+      fields do
+        fk1_id :integer
+        fk2_id :integer
+
+        timestamps
+      end
+    end
   end
 
-  let(:model_class) { IndexSettingsTestModel }
+  let(:model_class) { IndexDefinitionTestModel }
 
   describe 'instance methods' do
     let(:model) { model_class.new }
@@ -53,13 +62,20 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
     context 'with a migrated database' do
       before do
         ActiveRecord::Base.connection.execute <<~EOS
-            CREATE TABLE index_settings_test_models (
+            CREATE TABLE index_definition_test_models (
               id INTEGER NOT NULL PRIMARY KEY,
               name TEXT NOT NULL
             )
         EOS
         ActiveRecord::Base.connection.execute <<~EOS
-          CREATE UNIQUE INDEX index_settings_test_models_on_name ON index_settings_test_models(name)
+          CREATE UNIQUE INDEX index_definition_test_models_on_name ON index_definition_test_models(name)
+        EOS
+        ActiveRecord::Base.connection.execute <<~EOS
+            CREATE TABLE index_definition_compound_index_models (
+              fk1_id INTEGER NULL,
+              fk2_id INTEGER NULL,
+              PRIMARY KEY (fk1_id, fk2_id)
+            )
         EOS
         ActiveRecord::Base.connection.schema_cache.clear!
       end
@@ -67,14 +83,38 @@ RSpec.describe DeclareSchema::Model::IndexDefinition do
       describe 'for_model' do
         subject { described_class.for_model(model_class) }
 
-        it 'returns the indexes for the model' do
-          expect(subject.size).to eq(2), subject.inspect
-          expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
-            ['index_settings_test_models_on_name', ['name'], true]
-          )
-          expect([:name, :columns, :unique].map { |attr| subject[1].send(attr) }).to eq(
-            ['PRIMARY', ['id'], true]
-          )
+        context 'with single-column PK' do
+          it 'returns the indexes for the model' do
+            expect(subject.size).to eq(2), subject.inspect
+            expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
+              ['index_definition_test_models_on_name', ['name'], true]
+            )
+            expect([:name, :columns, :unique].map { |attr| subject[1].send(attr) }).to eq(
+              ['PRIMARY', ['id'], true]
+            )
+          end
+        end
+
+        context 'with compound-column PK' do
+          let(:model_class) { IndexDefinitionCompoundIndexModel }
+
+          it 'returns the indexes for the model' do
+            # Simulate MySQL for Rails 4 work-around
+            if Rails::VERSION::MAJOR < 5
+              expect(model_class.connection).to receive(:primary_key).with('index_definition_compound_index_models').and_return(nil)
+              connection_stub = instance_double(ActiveRecord::ConnectionAdapters::SQLite3Adapter, "connection")
+              expect(connection_stub).to receive(:indexes).
+                with('index_definition_compound_index_models').
+                and_return([DeclareSchema::Model::IndexDefinition.new(model_class, ['fk1_id', 'fk2_id'], name: 'PRIMARY')])
+
+              expect(model_class.connection).to receive(:dup).and_return(connection_stub)
+            end
+
+            expect(subject.size).to eq(1), subject.inspect
+            expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
+              ['PRIMARY', ['fk1_id', 'fk2_id'], true]
+            )
+          end
         end
       end
     end

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.0
+  version: 0.5.0.pre.3
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-20 00:00:00.000000000 Z
+date: 2020-12-17 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