declare_schema 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b82febb09d3ef72dd3e219c6900abd790e6401e9b15c9ca05c8cd9fc20c5bf4
-  data.tar.gz: 3f2520292af5845df795dba3f26ee62385d1166da51ce5c6a980d1fdc52460a3
+  metadata.gz: 1e5c665ec203dd84e445290bac1de190491560ddc409fe2bd3f5ba4831e065c5
+  data.tar.gz: 244148b892d2de22a692c4db50b136995f97d8da38573e87a443303fdee5be7a
 SHA512:
-  metadata.gz: bb726c72430d5b44d94239c3d00abfa42a1c4e2a9c23ad316bd66ec6567857a81c6f7766136bf3d4d78d1df7a43edec2da7e0162cabd60080892b29a2f6b69ce
-  data.tar.gz: 4f39c4534895f33f5d30181ef18b09c2fd9eb535e9da14b0ce502c9117cf28e58404e4c6b2254ffb322a3faea99f0433de6450b9fca96a0585bc87d25047c7b8
+  metadata.gz: 44994fd571b97768ffec2c9bbce779b8beef222ba50213a425a3021c66f1dc4e4fd7a50adc95cf3d1a1116e67eaf5c47b11e635408856c726118a22c18188b98
+  data.tar.gz: 7d3eb3be095a1dce65b6b39b35974a6c96ee940fec31dba3fddbfb528be8be3b42906ec81c6075cde5d8fa590df4afc8ca12887a956c772fc34c084791577526

data/CHANGELOG.md

@@ -4,6 +4,19 @@ 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.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)
+or any custom serializable class.
+This invokes `ActiveSupport`'s `serialize` macro for that field, passing the serializable class, if given.
+
+  Note: when `serialize:` is used, any `default:` should be given in a matching Ruby type--for example, `[]` or `{}` or `{ 'currency' => 'USD' }`--in
+which case the serializeable class will be used to determine the serialized default value and that will be set as the SQL default.
+
+### Fixed
+- Sqlite now correctly infers the PRIMARY KEY so it won't attempt to add that index again.
+
 ## [0.3.1] - 2020-11-13
 ### Fixed
 - When passing `belongs_to` to Rails, suppress the `optional:` option in Rails 4, since that option was added in Rails 5.
@@ -47,6 +60,7 @@ using the appropriate Rails configuration attributes.
 ### Added
 - Initial version from https://github.com/Invoca/hobo_fields v4.1.0.
 
+[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
 [0.2.0]: https://github.com/Invoca/declare_schema/compare/v0.1.3...v0.2.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (0.3.1)
+    declare_schema (0.4.0)
       rails (>= 4.2)
 
 GEM

data/lib/declare_schema.rb

@@ -39,6 +39,7 @@ require 'declare_schema/extensions/active_record/fields_declaration'
 require 'declare_schema/field_declaration_dsl'
 require 'declare_schema/model'
 require 'declare_schema/model/field_spec'
-require 'declare_schema/model/index_spec'
+require 'declare_schema/model/index_definition'
+require 'declare_schema/model/foreign_key_definition'
 
 require 'declare_schema/railtie' if defined?(Rails)

data/lib/declare_schema/model.rb

@@ -25,8 +25,8 @@ module DeclareSchema
           # and speeds things up a little.
           inheriting_cattr_reader field_specs: HashWithIndifferentAccess.new
 
-          # index_specs holds IndexSpec objects for all the declared indexes.
-          inheriting_cattr_reader index_specs: []
+          # index_definitions holds IndexDefinition objects for all the declared indexes.
+          inheriting_cattr_reader index_definitions: []
           inheriting_cattr_reader ignore_indexes: []
           inheriting_cattr_reader constraint_specs: []
 
@@ -51,19 +51,19 @@ module DeclareSchema
       def index(fields, options = {})
         # don't double-index fields
         index_fields_s = Array.wrap(fields).map(&:to_s)
-        unless index_specs.any? { |index_spec| index_spec.fields == index_fields_s }
-          index_specs << ::DeclareSchema::Model::IndexSpec.new(self, fields, options)
+        unless index_definitions.any? { |index_spec| index_spec.fields == index_fields_s }
+          index_definitions << ::DeclareSchema::Model::IndexDefinition.new(self, fields, options)
         end
       end
 
       def primary_key_index(*fields)
-        index(fields.flatten, unique: true, name: "PRIMARY_KEY")
+        index(fields.flatten, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
       end
 
       def constraint(fkey, options = {})
         fkey_s = fkey.to_s
         unless constraint_specs.any? { |constraint_spec| constraint_spec.foreign_key == fkey_s }
-          constraint_specs << DeclareSchema::Model::ForeignKeySpec.new(self, fkey, options)
+          constraint_specs << DeclareSchema::Model::ForeignKeyDefinition.new(self, fkey, options)
         end
       end
 
@@ -79,19 +79,20 @@ module DeclareSchema
       # declarations.
       def declare_field(name, type, *args)
         options = args.extract_options!
-        field_added(name, type, args, options) if respond_to?(:field_added)
-        add_formatting_for_field(name, type, args)
+        try(:field_added, name, type, args, options)
+        add_serialize_for_field(name, type, options)
+        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)
-        attr_order << name unless name.in?(attr_order)
+        attr_order << name unless attr_order.include?(name)
       end
 
-      def index_specs_with_primary_key
-        if index_specs.any?(&:primary_key?)
-          index_specs
+      def index_definitions_with_primary_key
+        if index_definitions.any?(&:primary_key?)
+          index_definitions
         else
-          index_specs + [rails_default_primary_key]
+          index_definitions + [rails_default_primary_key]
         end
       end
 
@@ -102,7 +103,7 @@ module DeclareSchema
       private
 
       def rails_default_primary_key
-        ::DeclareSchema::Model::IndexSpec.new(self, [primary_key.to_sym], unique: true, name: DeclareSchema::Model::IndexSpec::PRIMARY_KEY_NAME)
+        ::DeclareSchema::Model::IndexDefinition.new(self, [primary_key.to_sym], unique: true, name: DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
       end
 
       # Extend belongs_to so that it creates a FieldSpec for the foreign key
@@ -166,9 +167,8 @@ module DeclareSchema
       # does not effect the attribute in any way - it just records the
       # metadata.
       def declare_attr_type(name, type, options = {})
-        klass = DeclareSchema.to_class(type)
-        attr_types[name] = DeclareSchema.to_class(type)
-        klass.declared(self, name, options) if klass.respond_to?(:declared)
+        attr_types[name] = klass = DeclareSchema.to_class(type)
+        klass.try(:declared, self, name, options)
       end
 
       # Add field validations according to arguments in the
@@ -192,7 +192,37 @@ module DeclareSchema
         end
       end
 
-      def add_formatting_for_field(name, type, _args)
+      def add_serialize_for_field(name, type, options)
+        if (serialize_class = options.delete(:serialize))
+          type == :string || type == :text or raise ArgumentError, "serialize field type must be :string or :text"
+          serialize_args = Array((serialize_class unless serialize_class == true))
+          serialize(name, *serialize_args)
+          if options.has_key?(:default)
+            options[:default] = serialized_default(name, serialize_class == true ? Object : serialize_class, options[:default])
+          end
+        end
+      end
+
+      def serialized_default(attr_name, class_name_or_coder, default)
+        # copied from https://github.com/rails/rails/blob/7d6cb950e7c0e31c2faaed08c81743439156c9f5/activerecord/lib/active_record/attribute_methods/serialization.rb#L70-L76
+        coder = if class_name_or_coder == ::JSON
+                  ActiveRecord::Coders::JSON
+                elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+                  class_name_or_coder
+                elsif Rails::VERSION::MAJOR >= 5
+                  ActiveRecord::Coders::YAMLColumn.new(attr_name, class_name_or_coder)
+                else
+                  ActiveRecord::Coders::YAMLColumn.new(class_name_or_coder)
+                end
+
+        if default == coder.load(nil)
+          nil # handle Array default: [] or Hash default: {}
+        else
+          coder.dump(default)
+        end
+      end
+
+      def add_formatting_for_field(name, type)
         if (type_class = DeclareSchema.to_class(type))
           if "format".in?(type_class.instance_methods)
             before_validation do |record|

data/lib/declare_schema/model/foreign_key_definition.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  module Model
+    class ForeignKeyDefinition
+      include Comparable
+
+      attr_reader :constraint_name, :model, :foreign_key, :options, :on_delete_cascade
+
+      def initialize(model, foreign_key, options = {})
+        @model = model
+        @foreign_key = foreign_key.presence
+        @options = options
+
+        @child_table = model.table_name # unless a table rename, which would happen when a class is renamed??
+        @parent_table_name = options[:parent_table]
+        @foreign_key_name = options[:foreign_key] || self.foreign_key
+        @index_name = options[:index_name] || model.connection.index_name(model.table_name, column: foreign_key)
+        @constraint_name = options[:constraint_name] || @index_name || ''
+        @on_delete_cascade = options[:dependent] == :delete
+
+        # Empty constraint lets mysql generate the name
+      end
+
+      class << self
+        def for_model(model, old_table_name)
+          show_create_table = model.connection.select_rows("show create table #{model.connection.quote_table_name(old_table_name)}").first.last
+          constraints = show_create_table.split("\n").map { |line| line.strip if line['CONSTRAINT'] }.compact
+
+          constraints.map do |fkc|
+            options = {}
+            name, foreign_key, parent_table = fkc.match(/CONSTRAINT `([^`]*)` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)`/).captures
+            options[:constraint_name] = name
+            options[:parent_table] = parent_table
+            options[:foreign_key] = foreign_key
+            options[:dependent] = :delete if fkc['ON DELETE CASCADE']
+
+            new(model, foreign_key, options)
+          end
+        end
+      end
+
+      def parent_table_name
+        @parent_table_name ||=
+          if (klass = options[:class_name])
+            klass = klass.to_s.constantize unless klass.is_a?(Class)
+            klass.try(:table_name)
+          end || foreign_key.sub(/_id\z/, '').camelize.constantize.table_name
+      end
+
+      attr_writer :parent_table_name
+
+      def to_add_statement
+        statement = "ALTER TABLE #{@child_table} ADD CONSTRAINT #{@constraint_name} FOREIGN KEY #{@index_name}(#{@foreign_key_name}) REFERENCES #{parent_table_name}(id) #{'ON DELETE CASCADE' if on_delete_cascade}"
+        "execute #{statement.inspect}"
+      end
+
+      def key
+        @key ||= [@child_table, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
+      end
+
+      def hash
+        key.hash
+      end
+
+      def <=>(rhs)
+        key <=> rhs.key
+      end
+
+      alias eql? ==
+    end
+  end
+end

data/lib/declare_schema/model/index_definition.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  module Model
+    class IndexDefinition
+      include Comparable
+
+      # TODO: replace `fields` with `columns` and remove alias. -Colin
+      attr_reader :table, :fields, :explicit_name, :name, :unique, :where
+      alias columns fields
+
+      class IndexNameTooLongError < RuntimeError; end
+
+      PRIMARY_KEY_NAME = "PRIMARY"
+      MYSQL_INDEX_NAME_MAX_LENGTH = 64
+
+      def initialize(model, fields, options = {})
+        @model = model
+        @table = options.delete(:table_name) || model.table_name
+        @fields = Array.wrap(fields).map(&:to_s)
+        @explicit_name = options[:name] unless options.delete(:allow_equivalent)
+        @name = options.delete(:name) || model.connection.index_name(table, column: @fields).gsub(/index.*_on_/, 'on_')
+        @unique = options.delete(:unique) || name == PRIMARY_KEY_NAME || false
+
+        if @name.length > MYSQL_INDEX_NAME_MAX_LENGTH
+          raise IndexNameTooLongError, "Index '#{@name}' exceeds MySQL limit of #{MYSQL_INDEX_NAME_MAX_LENGTH} characters. Give it a shorter name."
+        end
+
+        if (where = options[:where])
+          @where = where.start_with?('(') ? where : "(#{where})"
+        end
+      end
+
+      class << self
+        # extract IndexSpecs from an existing table
+        # always includes the PRIMARY KEY index
+        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_found = false
+          index_definitions = model.connection.indexes(t).map do |i|
+            model.ignore_indexes.include?(i.name) and next
+            if i.name == PRIMARY_KEY_NAME
+              i.columns == primary_key_columns && i.unique or
+                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}"
+            end
+            new(model, i.columns, name: i.name, unique: i.unique, where: i.where, table_name: old_table_name)
+          end.compact
+
+          if !primary_key_found
+            index_definitions << new(model, primary_key_columns, name: PRIMARY_KEY_NAME, unique: true, where: nil, table_name: old_table_name)
+          end
+          index_definitions
+        end
+      end
+
+      def primary_key?
+        name == PRIMARY_KEY_NAME
+      end
+
+      def to_add_statement(new_table_name, existing_primary_key = nil)
+        if primary_key? && !ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
+          to_add_primary_key_statement(new_table_name, existing_primary_key)
+        else
+          # Note: + below keeps that interpolated string from being frozen, so we can << into it.
+          r = +"add_index #{new_table_name.to_sym.inspect}, #{fields.map(&:to_sym).inspect}"
+          r << ", unique: true"      if unique
+          r << ", where: '#{where}'" if where.present?
+          r << ", name: '#{name}'"
+          r
+        end
+      end
+
+      def to_add_primary_key_statement(new_table_name, existing_primary_key)
+        drop = "DROP PRIMARY KEY, " if existing_primary_key
+        statement = "ALTER TABLE #{new_table_name} #{drop}ADD PRIMARY KEY (#{fields.join(', ')})"
+        "execute #{statement.inspect}"
+      end
+
+      def to_key
+        @key ||= [table, fields, name, unique, where].map(&:to_s)
+      end
+
+      def settings
+        @settings ||= [table, fields, unique].map(&:to_s)
+      end
+
+      def hash
+        to_key.hash
+      end
+
+      def <=>(rhs)
+        to_key <=> rhs.to_key
+      end
+
+      def equivalent?(rhs)
+        settings == rhs.settings
+      end
+
+      def with_name(new_name)
+        self.class.new(@model, @fields, table_name: @table_name, index_name: @index_name, unique: @unique, name: new_name)
+      end
+
+      alias eql? ==
+    end
+  end
+end

data/lib/declare_schema/version.rb

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

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

@@ -45,14 +45,14 @@ module Generators
           false # no single-column primary key
         end
 
-        def index_specs_with_primary_key
+        def index_definitions_with_primary_key
           [
-            ::DeclareSchema::Model::IndexSpec.new(self, foreign_keys, unique: true, name: "PRIMARY_KEY"),
-            ::DeclareSchema::Model::IndexSpec.new(self, foreign_keys.last) # not unique by itself; combines with primary key to be unique
+            ::DeclareSchema::Model::IndexDefinition.new(self, foreign_keys, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME),
+            ::DeclareSchema::Model::IndexDefinition.new(self, foreign_keys.last) # not unique by itself; combines with primary key to be unique
           ]
         end
 
-        alias_method :index_specs, :index_specs_with_primary_key
+        alias_method :index_definitions, :index_definitions_with_primary_key
 
         def ignore_indexes
           []
@@ -60,8 +60,8 @@ module Generators
 
         def constraint_specs
           [
-            ::DeclareSchema::Model::ForeignKeySpec.new(self, foreign_keys.first, parent_table: foreign_key_classes.first.table_name, constraint_name: "#{join_table}_FK1", dependent: :delete),
-            ::DeclareSchema::Model::ForeignKeySpec.new(self, foreign_keys.last,  parent_table: foreign_key_classes.last.table_name,  constraint_name: "#{join_table}_FK2", dependent: :delete)
+            ::DeclareSchema::Model::ForeignKeyDefinition.new(self, foreign_keys.first, parent_table: foreign_key_classes.first.table_name, constraint_name: "#{join_table}_FK1", dependent: :delete),
+            ::DeclareSchema::Model::ForeignKeyDefinition.new(self, foreign_keys.last, parent_table: foreign_key_classes.last.table_name, constraint_name: "#{join_table}_FK2", dependent: :delete)
           ]
         end
       end
@@ -341,7 +341,7 @@ module Generators
         end
 
         def create_indexes(model)
-          model.index_specs.map { |i| i.to_add_statement(model.table_name) }
+          model.index_definitions.map { |i| i.to_add_statement(model.table_name) }
         end
 
         def create_constraints(model)
@@ -449,8 +449,8 @@ module Generators
           return [[], []] if Migrator.disable_constraints
 
           new_table_name = model.table_name
-          existing_indexes = ::DeclareSchema::Model::IndexSpec.for_model(model, old_table_name)
-          model_indexes_with_equivalents = model.index_specs_with_primary_key
+          existing_indexes = ::DeclareSchema::Model::IndexDefinition.for_model(model, old_table_name)
+          model_indexes_with_equivalents = model.index_definitions_with_primary_key
           model_indexes = model_indexes_with_equivalents.map do |i|
             if i.explicit_name.nil?
               if ex = existing_indexes.find { |e| i != e && e.equivalent?(i) }
@@ -458,20 +458,20 @@ module Generators
               end
             end || i
           end
-          existing_has_primary_key = existing_indexes.any? { |i| i.name == 'PRIMARY_KEY' }
-          model_has_primary_key    = model_indexes.any?    { |i| i.name == 'PRIMARY_KEY' }
+          existing_has_primary_key = existing_indexes.any? { |i| i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME }
+          model_has_primary_key    = model_indexes.any?    { |i| i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME }
 
           add_indexes_init = model_indexes - existing_indexes
           drop_indexes_init = existing_indexes - model_indexes
           undo_add_indexes = []
           undo_drop_indexes = []
           add_indexes = add_indexes_init.map do |i|
-            undo_add_indexes << drop_index(old_table_name, i.name) unless i.name == "PRIMARY_KEY"
+            undo_add_indexes << drop_index(old_table_name, i.name) unless i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME
             i.to_add_statement(new_table_name, existing_has_primary_key)
           end
           drop_indexes = drop_indexes_init.map do |i|
             undo_drop_indexes << i.to_add_statement(old_table_name, model_has_primary_key)
-            drop_index(new_table_name, i.name) unless i.name == "PRIMARY_KEY"
+            drop_index(new_table_name, i.name) unless i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME
           end.compact
 
           # the order is important here - adding a :unique, for instance needs to remove then add
@@ -489,7 +489,7 @@ module Generators
           return [[], []] if Migrator.disable_indexing
 
           new_table_name = model.table_name
-          existing_fks = ::DeclareSchema::Model::ForeignKeySpec.for_model(model, old_table_name)
+          existing_fks = ::DeclareSchema::Model::ForeignKeyDefinition.for_model(model, old_table_name)
           model_fks = model.constraint_specs
           add_fks = model_fks - existing_fks
           drop_fks = existing_fks - model_fks

data/spec/lib/declare_schema/interactive_primary_key_spec.rb

@@ -31,21 +31,23 @@ RSpec.describe 'DeclareSchema Migration Generator interactive primary key' do
 
     ### migrate to
 
-    # rename to custom primary_key
-    class Foo < ActiveRecord::Base
-      fields do
+    if Rails::VERSION::MAJOR >= 5
+      # rename to custom primary_key
+      class Foo < ActiveRecord::Base
+        fields do
+        end
+        self.primary_key = "foo_id"
       end
-      self.primary_key = "foo_id"
-    end
 
-    puts "\n\e[45m Please enter 'drop id' (no quotes) at the next prompt \e[0m"
-    generate_migrations '-n', '-m'
-    expect(Foo.primary_key).to eq('foo_id')
+      puts "\n\e[45m Please enter 'drop id' (no quotes) at the next prompt \e[0m"
+      generate_migrations '-n', '-m'
+      expect(Foo.primary_key).to eq('foo_id')
 
-    ### ensure it doesn't cause further migrations
+      ### ensure it doesn't cause further migrations
 
-    # check no further migrations
-    up, down = Generators::DeclareSchema::Migration::Migrator.run
-    expect(up).to eq("")
+      # check no further migrations
+      up = Generators::DeclareSchema::Migration::Migrator.run.first
+      expect(up).to eq("")
+    end
   end
 end

data/spec/lib/declare_schema/migration_generator_spec.rb

@@ -51,19 +51,19 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       end
     end
 
+    Advert.connection.schema_cache.clear!
+    Advert.reset_column_information
+
     expect(migrate).to(
       migrate_up(<<~EOS.strip)
         add_column :adverts, :body, :text
         add_column :adverts, :published_at, :datetime
-
-        add_index :adverts, [:id], unique: true, name: 'PRIMARY_KEY'
       EOS
       .and migrate_down(<<~EOS.strip)
         remove_column :adverts, :body
         remove_column :adverts, :published_at
       EOS
     )
-    # TODO: ^ TECH-4975 add_index should not be there
 
     Advert.field_specs.clear # not normally needed
     class Advert < ActiveRecord::Base
@@ -329,7 +329,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     )
 
     Advert.field_specs.delete(:category_id)
-    Advert.index_specs.delete_if { |spec| spec.fields==["category_id"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields==["category_id"] }
 
     # If you specify a custom foreign key, the migration generator observes that:
 
@@ -348,7 +348,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     )
 
     Advert.field_specs.delete(:c_id)
-    Advert.index_specs.delete_if { |spec| spec.fields == ["c_id"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["c_id"] }
 
     # You can avoid generating the index by specifying `index: false`
 
@@ -365,7 +365,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     )
 
     Advert.field_specs.delete(:category_id)
-    Advert.index_specs.delete_if { |spec| spec.fields == ["category_id"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
 
     # You can specify the index name with :index
 
@@ -384,7 +384,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     )
 
     Advert.field_specs.delete(:category_id)
-    Advert.index_specs.delete_if { |spec| spec.fields == ["category_id"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["category_id"] }
 
     ### Timestamps and Optimimistic Locking
 
@@ -433,7 +433,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       EOS
     )
 
-    Advert.index_specs.delete_if { |spec| spec.fields==["title"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields==["title"] }
 
     # You can ask for a unique index
 
@@ -451,7 +451,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       EOS
     )
 
-    Advert.index_specs.delete_if { |spec| spec.fields == ["title"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
 
     # You can specify the name for the index
 
@@ -469,7 +469,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       EOS
     )
 
-    Advert.index_specs.delete_if { |spec| spec.fields==["title"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields==["title"] }
 
     # You can ask for an index outside of the fields block
 
@@ -485,7 +485,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       EOS
     )
 
-    Advert.index_specs.delete_if { |spec| spec.fields == ["title"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
 
     # The available options for the index function are `:unique` and `:name`
 
@@ -501,7 +501,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       EOS
     )
 
-    Advert.index_specs.delete_if { |spec| spec.fields == ["title"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields == ["title"] }
 
     # You can create an index on more than one field
 
@@ -517,7 +517,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       EOS
     )
 
-    Advert.index_specs.delete_if { |spec| spec.fields==["title", "category_id"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields==["title", "category_id"] }
 
     # Finally, you can specify that the migration generator should completely ignore an
     # index by passing its name to ignore_index in the model.
@@ -545,7 +545,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         add_column :ads, :title, :string, limit: 255
         add_column :ads, :body, :text
 
-        add_index :ads, [:id], unique: true, name: 'PRIMARY_KEY'
+        add_index :ads, [:id], unique: true, name: 'PRIMARY'
       EOS
       .and migrate_down(<<~EOS.strip)
         remove_column :ads, :title
@@ -553,7 +553,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
 
         rename_table :ads, :adverts
 
-        add_index :adverts, [:id], unique: true, name: 'PRIMARY_KEY'
+        add_index :adverts, [:id], unique: true, name: 'PRIMARY'
       EOS
     )
 
@@ -588,7 +588,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         add_column :advertisements, :body, :text
         remove_column :advertisements, :name
 
-        add_index :advertisements, [:id], unique: true, name: 'PRIMARY_KEY'
+        add_index :advertisements, [:id], unique: true, name: 'PRIMARY'
       EOS
       .and migrate_down(<<~EOS.strip)
         remove_column :advertisements, :title
@@ -597,7 +597,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
 
         rename_table :advertisements, :adverts
 
-        add_index :adverts, [:id], unique: true, name: 'PRIMARY_KEY'
+        add_index :adverts, [:id], unique: true, name: 'PRIMARY'
       EOS
     )
 
@@ -614,14 +614,11 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         t.integer "id",   limit: 8
         t.string  "name", limit: 255
       end
-
-      add_index "adverts", ["id"], name: "PRIMARY_KEY", unique: true
     EOS
 
     rails5_table_create = <<~EOS.strip
       create_table "adverts", id: :integer, force: :cascade do |t|
         t.string "name", limit: 255
-        t.index ["id"], name: "PRIMARY_KEY", unique: true
       end
     EOS
 
@@ -670,7 +667,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     Advert.field_specs.delete(:type)
     nuke_model_class(SuperFancyAdvert)
     nuke_model_class(FancyAdvert)
-    Advert.index_specs.delete_if { |spec| spec.fields==["type"] }
+    Advert.index_definitions.delete_if { |spec| spec.fields==["type"] }
 
     ## Coping with multiple changes
 
@@ -728,7 +725,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
         add_column :ads, :created_at, :datetime, null: false
         change_column :ads, :title, :string, limit: 255, null: false, default: \"Untitled\"
 
-        add_index :ads, [:id], unique: true, name: 'PRIMARY_KEY'
+        add_index :ads, [:id], unique: true, name: 'PRIMARY'
       EOS
     )
 
@@ -756,7 +753,7 @@ RSpec.describe 'DeclareSchema Migration Generator' do
       migrate_up(<<~EOS.strip)
         rename_column :adverts, :id, :advert_id
 
-        add_index :adverts, [:advert_id], unique: true, name: 'PRIMARY_KEY'
+        add_index :adverts, [:advert_id], unique: true, name: 'PRIMARY'
       EOS
     )
 
@@ -797,6 +794,190 @@ RSpec.describe 'DeclareSchema Migration Generator' do
     expect(Ad.field_specs['company'].options[:validates].inspect).to eq("{:presence=>true, :uniqueness=>{:case_sensitive=>false}}")
   end
 
+  describe 'serialize' do
+    before do
+      class Ad < ActiveRecord::Base
+        @serialize_args = []
+
+        class << self
+          attr_reader :serialize_args
+
+          def serialize(*args)
+            @serialize_args << args
+          end
+        end
+      end
+    end
+
+    describe 'untyped' do
+      it 'allows serialize: true' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :text, limit: 0xFFFF, serialize: true
+          end
+        end
+
+        expect(Ad.serialize_args).to eq([[:allow_list]])
+      end
+
+      it 'converts defaults with .to_yaml' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: true, null: true, default: []
+            allow_hash :string, limit: 255, serialize: true, null: true, default: {}
+            allow_string :string, limit: 255, serialize: true, null: true, default: ['abc']
+            allow_null :string, limit: 255, serialize: true, null: true, default: nil
+          end
+        end
+
+        expect(Ad.field_specs['allow_list'].default).to eq("--- []\n")
+        expect(Ad.field_specs['allow_hash'].default).to eq("--- {}\n")
+        expect(Ad.field_specs['allow_string'].default).to eq("---\n- abc\n")
+        expect(Ad.field_specs['allow_null'].default).to eq(nil)
+      end
+    end
+
+    describe 'Array' do
+      it 'allows serialize: Array' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: Array, null: true
+          end
+        end
+
+        expect(Ad.serialize_args).to eq([[:allow_list, Array]])
+      end
+
+      it 'allows Array defaults' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: Array, null: true, default: [2]
+            allow_string :string, limit: 255, serialize: Array, null: true, default: ['abc']
+            allow_empty :string, limit: 255, serialize: Array, null: true, default: []
+            allow_null :string, limit: 255, serialize: Array, null: true, default: nil
+          end
+        end
+
+        expect(Ad.field_specs['allow_list'].default).to eq("---\n- 2\n")
+        expect(Ad.field_specs['allow_string'].default).to eq("---\n- abc\n")
+        expect(Ad.field_specs['allow_empty'].default).to eq(nil)
+        expect(Ad.field_specs['allow_null'].default).to eq(nil)
+      end
+    end
+
+    describe 'Hash' do
+      it 'allows serialize: Hash' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: Hash, null: true
+          end
+        end
+
+        expect(Ad.serialize_args).to eq([[:allow_list, Hash]])
+      end
+
+      it 'allows Hash defaults' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_loc :string, limit: 255, serialize: Hash, null: true, default: { 'state' => 'CA' }
+            allow_hash :string, limit: 255, serialize: Hash, null: true, default: {}
+            allow_null :string, limit: 255, serialize: Hash, null: true, default: nil
+          end
+        end
+
+        expect(Ad.field_specs['allow_loc'].default).to eq("---\nstate: CA\n")
+        expect(Ad.field_specs['allow_hash'].default).to eq(nil)
+        expect(Ad.field_specs['allow_null'].default).to eq(nil)
+      end
+    end
+
+    describe 'JSON' do
+      it 'allows serialize: JSON' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: JSON
+          end
+        end
+
+        expect(Ad.serialize_args).to eq([[:allow_list, JSON]])
+      end
+
+      it 'allows JSON defaults' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_hash :string, limit: 255, serialize: JSON, null: true, default: { 'state' => 'CA' }
+            allow_empty_array :string, limit: 255, serialize: JSON, null: true, default: []
+            allow_empty_hash :string, limit: 255, serialize: JSON, null: true, default: {}
+            allow_null :string, limit: 255, serialize: JSON, null: true, default: nil
+          end
+        end
+
+        expect(Ad.field_specs['allow_hash'].default).to eq("{\"state\":\"CA\"}")
+        expect(Ad.field_specs['allow_empty_array'].default).to eq("[]")
+        expect(Ad.field_specs['allow_empty_hash'].default).to eq("{}")
+        expect(Ad.field_specs['allow_null'].default).to eq(nil)
+      end
+    end
+
+    class ValueClass
+      delegate :present?, :inspect, to: :@value
+
+      def initialize(value)
+        @value = value
+      end
+
+      class << self
+        def dump(object)
+          if object&.present?
+            object.inspect
+          end
+        end
+
+        def load(serialized)
+          if serialized
+            raise 'not used ???'
+          end
+        end
+      end
+    end
+
+    describe 'custom coder' do
+      it 'allows serialize: ValueClass' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :string, limit: 255, serialize: ValueClass
+          end
+        end
+
+        expect(Ad.serialize_args).to eq([[:allow_list, ValueClass]])
+      end
+
+      it 'allows ValueClass defaults' do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_hash :string, limit: 255, serialize: ValueClass, null: true, default: ValueClass.new([2])
+            allow_empty_array :string, limit: 255, serialize: ValueClass, null: true, default: ValueClass.new([])
+            allow_null :string, limit: 255, serialize: ValueClass, null: true, default: nil
+          end
+        end
+
+        expect(Ad.field_specs['allow_hash'].default).to eq("[2]")
+        expect(Ad.field_specs['allow_empty_array'].default).to eq(nil)
+        expect(Ad.field_specs['allow_null'].default).to eq(nil)
+      end
+    end
+
+    it 'disallows serialize: with a non-string column type' do
+      expect do
+        class Ad < ActiveRecord::Base
+          fields do
+            allow_list :integer, limit: 8, serialize: true
+          end
+        end
+      end.to raise_exception(ArgumentError, /must be :string or :text/)
+    end
+  end
+
   context "for Rails #{Rails::VERSION::MAJOR}" do
     if Rails::VERSION::MAJOR >= 5
       let(:optional_true) { { optional: true } }

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative '../../../../lib/declare_schema/model/index_definition'
+
+# Beware: It looks out that Rails' sqlite3 driver has a bug in retrieving indexes.
+# In sqlite3/schema_statements, it skips over any index that starts with sqlite_:
+#    next if row["name"].starts_with?("sqlite_")
+# but this will skip over any indexes created to support "unique" column constraints.
+# This gem provides an explicit name for all indexes so it shouldn't be affected by the bug...
+# unless you manually create any Sqlite tables with UNIQUE constraints.
+
+RSpec.describe DeclareSchema::Model::IndexDefinition do
+  before do
+    load File.expand_path('../prepare_testapp.rb', __dir__)
+
+    class IndexSettingsTestModel < ActiveRecord::Base
+      fields do
+        name :string, limit: 127, index: true
+
+        timestamps
+      end
+    end
+  end
+
+  let(:model_class) { IndexSettingsTestModel }
+
+  describe 'instance methods' do
+    let(:model) { model_class.new }
+    subject { declared_class.new(model_class) }
+
+    it 'has index_definitions' do
+      expect(model_class.index_definitions).to be_kind_of(Array)
+      expect(model_class.index_definitions.map(&:name)).to eq(['on_name'])
+      expect([:name, :fields, :unique].map { |attr| model_class.index_definitions[0].send(attr)}).to eq(
+        ['on_name', ['name'], false]
+      )
+    end
+
+    it 'has index_definitions_with_primary_key' do
+      expect(model_class.index_definitions_with_primary_key).to be_kind_of(Array)
+      result = model_class.index_definitions_with_primary_key.sort_by(&:name)
+      expect(result.map(&:name)).to eq(['PRIMARY', 'on_name'])
+      expect([:name, :fields, :unique].map { |attr| result[0].send(attr)}).to eq(
+        ['PRIMARY', ['id'], true]
+      )
+      expect([:name, :fields, :unique].map { |attr| result[1].send(attr)}).to eq(
+        ['on_name', ['name'], false]
+      )
+    end
+  end
+
+  describe 'class << self' do
+    context 'with a migrated database' do
+      before do
+        ActiveRecord::Base.connection.execute <<~EOS
+            CREATE TABLE index_settings_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)
+        EOS
+        ActiveRecord::Base.connection.schema_cache.clear!
+      end
+
+      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]
+          )
+        end
+      end
+    end
+  end
+  # TODO: fill out remaining tests
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: declare_schema
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-13 00:00:00.000000000 Z
+date: 2020-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -59,7 +59,8 @@ files:
 - lib/declare_schema/field_declaration_dsl.rb
 - lib/declare_schema/model.rb
 - lib/declare_schema/model/field_spec.rb
-- lib/declare_schema/model/index_spec.rb
+- lib/declare_schema/model/foreign_key_definition.rb
+- lib/declare_schema/model/index_definition.rb
 - lib/declare_schema/railtie.rb
 - lib/declare_schema/version.rb
 - lib/generators/declare_schema/migration/USAGE
@@ -76,6 +77,7 @@ files:
 - 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/prepare_testapp.rb
 - spec/lib/generators/declare_schema/migration/migrator_spec.rb
 - spec/spec_helper.rb

data/lib/declare_schema/model/index_spec.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-module DeclareSchema
-  module Model
-    class IndexSpec
-      include Comparable
-
-      attr_reader :table, :fields, :explicit_name, :name, :unique, :where
-
-      class IndexNameTooLongError < RuntimeError; end
-
-      PRIMARY_KEY_NAME = "PRIMARY_KEY"
-      MYSQL_INDEX_NAME_MAX_LENGTH = 64
-
-      def initialize(model, fields, options = {})
-        @model = model
-        @table = options.delete(:table_name) || model.table_name
-        @fields = Array.wrap(fields).map(&:to_s)
-        @explicit_name = options[:name] unless options.delete(:allow_equivalent)
-        @name = options.delete(:name) || model.connection.index_name(table, column: @fields).gsub(/index.*_on_/, 'on_')
-        @unique = options.delete(:unique) || name == PRIMARY_KEY_NAME || false
-
-        if @name.length > MYSQL_INDEX_NAME_MAX_LENGTH
-          raise IndexNameTooLongError, "Index '#{@name}' exceeds MySQL limit of #{MYSQL_INDEX_NAME_MAX_LENGTH} characters. Give it a shorter name."
-        end
-
-        if (where = options[:where])
-          @where = where.start_with?('(') ? where : "(#{where})"
-        end
-      end
-
-      class << self
-        # extract IndexSpecs from an existing table
-        def for_model(model, old_table_name = nil)
-          t = old_table_name || model.table_name
-          connection = model.connection.dup
-          # TODO: Change below to use prepend
-          class << connection              # defeat Rails code that skips the primary keys by changing their name to PRIMARY_KEY_NAME
-            def each_hash(result)
-              super do |hash|
-                if hash[:Key_name] == "PRIMARY"
-                  hash[:Key_name] = PRIMARY_KEY_NAME
-                end
-                yield hash
-              end
-            end
-          end
-          connection.indexes(t).map do |i|
-            new(model, i.columns, name: i.name, unique: i.unique, where: i.where, table_name: old_table_name) unless model.ignore_indexes.include?(i.name)
-          end.compact
-        end
-      end
-
-      def primary_key?
-        name == PRIMARY_KEY_NAME
-      end
-
-      def to_add_statement(new_table_name, existing_primary_key = nil)
-        if primary_key? && !ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
-          to_add_primary_key_statement(new_table_name, existing_primary_key)
-        else
-          r = +"add_index #{new_table_name.to_sym.inspect}, #{fields.map(&:to_sym).inspect}"
-          r += ", unique: true"      if unique
-          r += ", where: '#{where}'" if where.present?
-          r += ", name: '#{name}'"
-          r
-        end
-      end
-
-      def to_add_primary_key_statement(new_table_name, existing_primary_key)
-        drop = "DROP PRIMARY KEY, " if existing_primary_key
-        statement = "ALTER TABLE #{new_table_name} #{drop}ADD PRIMARY KEY (#{fields.join(', ')})"
-        "execute #{statement.inspect}"
-      end
-
-      def to_key
-        @key ||= [table, fields, name, unique, where].map(&:to_s)
-      end
-
-      def settings
-        @settings ||= [table, fields, unique].map(&:to_s)
-      end
-
-      def hash
-        to_key.hash
-      end
-
-      def <=>(rhs)
-        to_key <=> rhs.to_key
-      end
-
-      def equivalent?(rhs)
-        settings == rhs.settings
-      end
-
-      def with_name(new_name)
-        self.class.new(@model, @fields, table_name: @table_name, index_name: @index_name, unique: @unique, name: new_name)
-      end
-
-      alias eql? ==
-    end
-
-    class ForeignKeySpec
-      include Comparable
-
-      attr_reader :constraint_name, :model, :foreign_key, :options, :on_delete_cascade
-
-      def initialize(model, foreign_key, options = {})
-        @model = model
-        @foreign_key = foreign_key.presence
-        @options = options
-
-        @child_table = model.table_name # unless a table rename, which would happen when a class is renamed??
-        @parent_table_name = options[:parent_table]
-        @foreign_key_name = options[:foreign_key] || self.foreign_key
-        @index_name = options[:index_name] || model.connection.index_name(model.table_name, column: foreign_key)
-        @constraint_name = options[:constraint_name] || @index_name || ''
-        @on_delete_cascade = options[:dependent] == :delete
-
-        # Empty constraint lets mysql generate the name
-      end
-
-      class << self
-        def for_model(model, old_table_name)
-          show_create_table = model.connection.select_rows("show create table #{model.connection.quote_table_name(old_table_name)}").first.last
-          constraints = show_create_table.split("\n").map { |line| line.strip if line['CONSTRAINT'] }.compact
-
-          constraints.map do |fkc|
-            options = {}
-            name, foreign_key, parent_table = fkc.match(/CONSTRAINT `([^`]*)` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)`/).captures
-            options[:constraint_name] = name
-            options[:parent_table] = parent_table
-            options[:foreign_key] = foreign_key
-            options[:dependent] = :delete if fkc['ON DELETE CASCADE']
-
-            new(model, foreign_key, options)
-          end
-        end
-      end
-
-      def parent_table_name
-        @parent_table_name ||=
-          options[:class_name]&.is_a?(Class) &&
-          options[:class_name].respond_to?(:table_name) &&
-          options[:class_name]&.table_name
-        @parent_table_name ||=
-          options[:class_name]&.constantize &&
-          options[:class_name].constantize.respond_to?(:table_name) &&
-          options[:class_name].constantize.table_name ||
-          foreign_key.gsub(/_id/, '').camelize.constantize.table_name
-      end
-
-      attr_writer :parent_table_name
-
-      def to_add_statement(_ = true)
-        statement = "ALTER TABLE #{@child_table} ADD CONSTRAINT #{@constraint_name} FOREIGN KEY #{@index_name}(#{@foreign_key_name}) REFERENCES #{parent_table_name}(id) #{'ON DELETE CASCADE' if on_delete_cascade}"
-        "execute #{statement.inspect}"
-      end
-
-      def to_key
-        @key ||= [@child_table, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
-      end
-
-      def hash
-        to_key.hash
-      end
-
-      def <=>(rhs)
-        to_key <=> rhs.to_key
-      end
-
-      alias eql? ==
-    end
-  end
-end