declare_schema 0.4.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf6d8bf1670910eeadc3f7ed08860af6630f1b5edc271a0740fe8bb94e7f5c71
-  data.tar.gz: 4d058e02cb6b269f6b66fa20f8ac661ecdb7f8b31547cf43e65e27c869221902
+  metadata.gz: c0c13793a5b263a2f1134ee19168a42ceb57c472cf8fb656b8e86fcdd9500b79
+  data.tar.gz: ee92620b0a091538958957205ba940d97cd9f67bc606751cb52a8ae44370e541
 SHA512:
-  metadata.gz: d95d741db5f9279cfe39f7bd972581708a0ccae7e2d9d209318282a9980d2980e3611592ba08b6b53136e23b92ac4aaa51e2a66187002de04bf818c29715820f
-  data.tar.gz: 93c203bb2ff2255f014d76a3069d1530d97f9603293738844e2faf6f2c9cb6fb95dcc2aa9ad505df15c8e1e14567e076a5e2901b7b4847f804ce3dd85dc5b313
+  metadata.gz: 3bc0e18dd1b3a998640cc2e983c86182e19b855d8ce42b3f7233b3471a7849d0dc28fa2653d110b42d0544c513267f8066386496b1469085bb507541c068b87a
+  data.tar.gz: 34b9e31862291b85becf7eeb908c4ef1da5b29178b1ab387b35c6678680299cd921fa65b49e0ba89604518a66515092d3e7d6c38678267301c9399b4572d372e

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/.github/workflows/declare_schema_build.yml

@@ -0,0 +1,44 @@
+---
+on: [push]
+
+name: DeclareSchema Build
+
+jobs:
+  build:
+    name: DeclareSchema Build
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [ 2.4.5, 2.5.8, 2.6.5, 2.7.1 ]
+        gemfile: [ gemfiles/rails_4.gemfile, gemfiles/rails_5.gemfile, gemfiles/rails_6.gemfile ]
+        exclude:
+          - { gemfile: gemfiles/rails_4.gemfile, ruby: 2.7.1 }
+          - { gemfile: gemfiles/rails_5.gemfile, ruby: 2.4.5 }
+          - { gemfile: gemfiles/rails_6.gemfile, ruby: 2.4.5 }
+    env:
+      BUNDLE_GEMFILE: "${{ matrix.gemfile }}"
+    steps:
+      - name: Checkout Branch
+        id: checkout_branch
+        uses: actions/checkout@v2
+      - name: Setup Ruby
+        id: setup_ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler: 1.17.3
+          ruby-version: ${{matrix.ruby}}
+      - name: Remove Bundler 2
+        id: remove_bundler_2
+        if: ${{ matrix.ruby >= '2.6.5' }}
+        run: |
+          rm -f /opt/hostedtoolcache/Ruby/2.*/x64/lib/ruby/gems/2.*/specifications/default/bundler-2.*.gemspec
+          gem install bundler:1.17.3 --force --default
+          gem install bundler -v 1.17.3
+      - name: Appraisals
+        id: appraisals
+        run: |
+          bundle install --jobs=3 --retry=3 --path=${BUNDLE_PATH:-vendor/bundle} --gemfile=${{ matrix.gemfile }}
+          git config --global user.email "dummy@example.com"
+          git config --global user.name "dummy"
+          bundle exec rake test:prepare_testapp[force]
+          bundle exec rake test:all < test_responses.txt

data/.gitignore

@@ -12,3 +12,4 @@
 
 # appraisal
 gemfiles/*.lock
+.idea

data/CHANGELOG.md

@@ -4,6 +4,22 @@ 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.6.0] - 2020-12-23
+### Added
+- Fields may now be declared with `:bigint` type which is identical to `:integer, limit 8`
+- FieldSpec#initialize interface now includes `position` keyword argument and `**options` hash.
+
+### Fixed
+- Fixed cycle in which FieldSpec#initialize was calling `model.field_specs` 
+
+### Changed
+- Changed ci support from Travis to Github Workflow
+
+## [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.
@@ -15,7 +31,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.
@@ -68,6 +84,8 @@ using the appropriate Rails configuration attributes.
 ### Added
 - Initial version from https://github.com/Invoca/hobo_fields v4.1.0.
 
+[0.6.0]: https://github.com/Invoca/declare_schema/compare/v0.5.0...v0.6.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

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.2)
+    declare_schema (0.6.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 %(
@@ -84,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

@@ -33,7 +33,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 +44,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,8 +54,15 @@ 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
+
+        unless type.in?([:text, :string])
+          @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
 
       TYPE_SYNONYMS = { timestamp: :datetime }.freeze
@@ -102,6 +109,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 +128,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/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.2"
+  VERSION = "0.6.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
@@ -33,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
 
@@ -69,13 +71,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 +300,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 +383,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 +445,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 +470,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 +593,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/field_spec_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+RSpec.describe 'DeclareSchema Model FieldSpec' do
+  before do
+    load File.expand_path('prepare_testapp.rb', __dir__)
+  end
+
+  context 'There are no model columns to change' do
+    it '#different_to should return false for int8 == int8' do
+      subject = DeclareSchema::Model::FieldSpec.new(Object, :price, :integer, limit: 8, null: false, position: 0)
+
+      case Rails::VERSION::MAJOR
+      when 4
+        cast_type = ActiveRecord::Type::Integer.new(limit: 8)
+        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, cast_type, "integer(8)", false)
+      else
+        sql_type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: "integer(8)", type: :integer, limit: 8)
+        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, sql_type_metadata, false, "adverts")
+      end
+
+      expect(subject.different_to?(subject.name, col)).to eq(false)
+    end
+
+    it '#different_to should return false for bigint == bigint' do
+      subject = DeclareSchema::Model::FieldSpec.new(Object, :price, :bigint, null: false, position: 0)
+
+      case Rails::VERSION::MAJOR
+      when 4
+        cast_type = ActiveRecord::Type::BigInteger.new(limit: 8)
+        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, cast_type, "bigint(20)", false)
+      else
+        sql_type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: "bigint(20)", type: :integer, limit: 8)
+        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, sql_type_metadata, false, "adverts")
+      end
+
+      expect(subject.different_to?(subject.name, col)).to eq(false)
+    end
+
+    it '#different_to should return false for int8 == bigint' do
+      subject = DeclareSchema::Model::FieldSpec.new(Object, :price, :integer, limit: 8, null: false, position: 0)
+
+      case Rails::VERSION::MAJOR
+      when 4
+        cast_type = ActiveRecord::Type::BigInteger.new(limit: 8)
+        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, cast_type, "bigint(20)", false)
+      else
+        sql_type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: "bigint(20)", type: :integer, limit: 8)
+        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, sql_type_metadata, false, "adverts")
+      end
+
+      expect(subject.different_to?(subject.name, col)).to eq(false)
+    end
+
+    it '#different_to should return false for bigint == int8' do
+      subject = DeclareSchema::Model::FieldSpec.new(Object, :price, :bigint, null: false, position: 0)
+
+      case Rails::VERSION::MAJOR
+      when 4
+        cast_type = ActiveRecord::Type::Integer.new(limit: 8)
+        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, cast_type, "integer(8)", false)
+      else
+        sql_type_metadata = ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(sql_type: "integer(8)", type: :integer, limit: 8)
+        col = ActiveRecord::ConnectionAdapters::Column.new("price", nil, sql_type_metadata, false, "adverts")
+      end
+
+      expect(subject.different_to?(subject.name, col)).to eq(false)
+    end
+  end
+end

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/migration_generator_spec.rb

@@ -1093,4 +1093,29 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       expect(base_class).to eq("(Rails::VERSION::MAJOR >= 5 ? ActiveRecord::Migration[4.2] : ActiveRecord::Migration)")
     end
   end
+
+  context 'Does not generate migrations' do
+    it 'for aliased fields bigint -> integer limit 8' do
+      if Rails::VERSION::MAJOR >= 5 || !ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
+        class Advert < active_record_base_class.constantize
+          fields do
+            price :bigint
+          end
+        end
+
+        generate_migrations '-n', '-m'
+
+        migrations = Dir.glob('db/migrate/*declare_schema_migration*.rb')
+        expect(migrations.size).to eq(1), migrations.inspect
+
+        class Advert < active_record_base_class.constantize
+          fields do
+            price :integer, limit: 8
+          end
+        end
+
+        expect { generate_migrations '-n', '-g' }.to output("Database and models match -- nothing to change\n").to_stdout
+      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.2
+  version: 0.6.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-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -32,13 +32,13 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".dependabot/config.yml"
+- ".github/dependabot.yml"
+- ".github/workflows/declare_schema_build.yml"
 - ".github/workflows/gem_release.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
-- ".travis.yml"
 - Appraisals
 - CHANGELOG.md
 - Gemfile
@@ -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
@@ -74,10 +75,12 @@ files:
 - lib/generators/declare_schema/support/thor_shell.rb
 - spec/lib/declare_schema/api_spec.rb
 - spec/lib/declare_schema/field_declaration_dsl_spec.rb
+- spec/lib/declare_schema/field_spec_spec.rb
 - spec/lib/declare_schema/generator_spec.rb
 - 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 +90,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 +106,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

data/.travis.yml

@@ -1,37 +0,0 @@
----
-dist: trusty
-os: linux
-language: ruby
-cache: bundler
-rvm:
-  - 2.4.5
-  - 2.5.8
-  - 2.6.5
-  - 2.7.1
-  - ruby-head
-gemfile:
-  - gemfiles/rails_4.gemfile
-  - gemfiles/rails_5.gemfile
-  - gemfiles/rails_6.gemfile
-jobs:
-  fast_finish: false
-  exclude:
-    - gemfile: gemfiles/rails_4.gemfile
-      rvm: 2.7.1
-    - gemfile: gemfiles/rails_5.gemfile
-      rvm: 2.4.5
-    - gemfile: gemfiles/rails_6.gemfile
-      rvm: 2.4.5
-  allow_failures:
-    - rvm: ruby-head
-before_install:
-  - rm -f /home/travis/.rvm/rubies/ruby-2.*/lib/ruby/gems/2.*/specifications/default/bundler-2.*.gemspec
-  - echo y | rvm @global do gem install bundler -v 1.17.3 --force --default
-  - gem install bundler -v 1.17.3 --force --default
-  - gem install bundler -v 1.17.3
-install:
-  - bundle --version
-  - bundle install --jobs=3 --retry=3 --path=${BUNDLE_PATH:-vendor/bundle}
-script:
-  - bundle exec rake test:prepare_testapp[force]
-  - bundle exec rake test:all < test_responses.txt