declare_schema 0.3.0.pre.2 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3364c39b6579bb69804417a10b5b287208e6fdfe5a23bf57b6b3f928f69fe539
-  data.tar.gz: 2fbc6abab32d750ef1af34d6888b5954ee27da2563acd8595728d3d23d184244
+  metadata.gz: bf6d8bf1670910eeadc3f7ed08860af6630f1b5edc271a0740fe8bb94e7f5c71
+  data.tar.gz: 4d058e02cb6b269f6b66fa20f8ac661ecdb7f8b31547cf43e65e27c869221902
 SHA512:
-  metadata.gz: 7e884c085c0d72f1146d7b7f52abbf1f44b19389e2f96e2858b855b11041c94406b0be159a300366d0abeec2f36cf9056d3eddd61352600c780a992ca3971817
-  data.tar.gz: 1d45f652bd8d0de74b71fec913c4005be8f3212de7fa7942ad587d67059f67115ce8d797be9d71121e792ab66aee84c2adaaa013766b6d96cb21eda1d35522b4
+  metadata.gz: d95d741db5f9279cfe39f7bd972581708a0ccae7e2d9d209318282a9980d2980e3611592ba08b6b53136e23b92ac4aaa51e2a66187002de04bf818c29715820f
+  data.tar.gz: 93c203bb2ff2255f014d76a3069d1530d97f9603293738844e2faf6f2c9cb6fb95dcc2aa9ad505df15c8e1e14567e076a5e2901b7b4847f804ce3dd85dc5b313

data/CHANGELOG.md

@@ -4,10 +4,45 @@ 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.3.0] - Unreleased
+## [0.4.2] - 2020-12-05
+### Fixed
+- Generalize the fix below to sqlite || Rails 4.
+
+## [0.4.1] - 2020-12-04
+### Fixed
+- Fixed a bug detecting compound primary keys in Rails 4.
+
+## [0.4.0] - 2020-11-20
 ### Added
+- Fields may be declared with `serialize: true` (any value with a valid `.to_yaml` stored as YAML),
+or `serialize: <serializeable-class>`, where `<serializeable-class>` 
+may be `Array` (`Array` stored as YAML) or `Hash` (`Hash` stored as YAML) or `JSON` (any value with a valid `.to_json`, stored as JSON)
+or any custom serializable class.
+This invokes `ActiveSupport`'s `serialize` macro for that field, passing the serializable class, if given.
+
+  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.
+
+## [0.3.0] - 2020-11-02
+### Added
+- Added support for `belongs_to optional:`.
+If given, it is passed through to `ActiveRecord`'s `belong_to`.
+If not given in Rails 5+, the `optional:` value is set equal to the `null:` value (default: `false`) and that
+is passed to `ActiveRecord`'s `belong_to`.
+Similarly, if `null:` is not given, it is inferred from `optional:`.
+If both are given, their values are respected, even if contradictory;
+this is a legitimate case when migrating to/from an optional association.
 - Added a new callback `before_generating_migration` to the `Migrator` that can be
 defined in order to custom load more models that might be missed by `eager_load!`
+### Fixed
+- Migrations are now generated where the `[4.2]` is only applied after `ActiveRecord::Migration` in Rails 5+ (since Rails 4 didn't know about that notation).
 
 ## [0.2.0] - 2020-10-26
 ### Added
@@ -29,11 +64,14 @@ using the appropriate Rails configuration attributes.
 ### Changed
 - Added travis support and created 2 specs as a starting point.
 
-
 ## [0.1.1] - 2020-09-24
 ### Added
 - Initial version from https://github.com/Invoca/hobo_fields v4.1.0.
 
+[0.4.2]: https://github.com/Invoca/declare_schema/compare/v0.4.1...v0.4.2
+[0.4.1]: https://github.com/Invoca/declare_schema/compare/v0.4.0...v0.4.1
+[0.4.0]: https://github.com/Invoca/declare_schema/compare/v0.3.1...v0.4.0
+[0.3.1]: https://github.com/Invoca/declare_schema/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/Invoca/declare_schema/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/Invoca/declare_schema/compare/v0.1.3...v0.2.0
 [0.1.3]: https://github.com/Invoca/declare_schema/compare/v0.1.2...v0.1.3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (0.3.0.pre.2)
+    declare_schema (0.4.2)
       rails (>= 4.2)
 
 GEM
@@ -54,7 +54,7 @@ GEM
       thor (>= 0.14.0)
     arel (9.0.0)
     ast (2.4.1)
-    bootsnap (1.4.8)
+    bootsnap (1.5.1)
       msgpack (~> 1.0)
     builder (3.2.4)
     byebug (11.1.3)
@@ -69,7 +69,7 @@ GEM
       activesupport (>= 4.2.0)
     i18n (1.8.5)
       concurrent-ruby (~> 1.0)
-    listen (3.2.1)
+    listen (3.3.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
     loofah (2.7.0)
@@ -134,19 +134,19 @@ GEM
       actionpack (>= 5.0)
       railties (>= 5.0)
     rexml (3.2.4)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.2)
-      rspec-support (~> 3.9.3)
-    rspec-expectations (3.9.2)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.3)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
     rubocop (0.91.0)
       parallel (~> 1.10)
       parser (>= 2.7.1.1)

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,21 +103,18 @@ 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
-      def belongs_to(name, *args, &block)
-        if args.size == 0 || (args.size == 1 && args[0].is_a?(Proc))
-          options = {}
-          args.push(options)
-        elsif args.size == 1
-          options = args[0]
-        else
-          options = args[1]
-        end
+      def belongs_to(name, scope = nil, **options)
         column_options = {}
-        column_options[:null] = options.delete(:null) || false
+
+        column_options[:null] = if options.has_key?(:null)
+                                  options.delete(:null)
+                                elsif options.has_key?(:optional)
+                                  options[:optional] # infer :null from :optional
+                                end || false
         column_options[:default] = options.delete(:default) if options.has_key?(:default)
         column_options[:limit] = options.delete(:limit) if options.has_key?(:limit)
 
@@ -129,20 +127,30 @@ module DeclareSchema
         fk_options[:constraint_name] = options.delete(:constraint) if options.has_key?(:constraint)
         fk_options[:index_name] = index_options[:name]
 
+        fk = options[:foreign_key]&.to_s || "#{name}_id"
+
+        if !options.has_key?(:optional)
+          options[:optional] = column_options[:null] # infer :optional from :null
+        end
+
         fk_options[:dependent] = options.delete(:far_end_dependent) if options.has_key?(:far_end_dependent)
-        super(name, *args, &block).tap do |_bt|
-          refl = reflections[name.to_s] or raise "Couldn't find reflection #{name} in #{reflections.keys}"
-          fkey = refl.foreign_key
-          declare_field(fkey.to_sym, :integer, column_options)
-          if refl.options[:polymorphic]
-            foreign_type = options[:foreign_type] || "#{name}_type"
-            declare_polymorphic_type_field(foreign_type, column_options)
-            index([foreign_type, fkey], index_options) if index_options[:name] != false
-          else
-            index(fkey, index_options) if index_options[:name] != false
-            options[:constraint_name] = options
-            constraint(fkey, fk_options) if fk_options[:constraint_name] != false
-          end
+
+        if Rails::VERSION::MAJOR >= 5
+          super
+        else
+          super(name, scope, options.except(:optional))
+        end
+
+        refl = reflections[name.to_s] or raise "Couldn't find reflection #{name} in #{reflections.keys}"
+        fkey = refl.foreign_key or raise "Couldn't find foreign_key for #{name} in #{refl.inspect}"
+        declare_field(fkey.to_sym, :integer, column_options)
+        if refl.options[:polymorphic]
+          foreign_type = options[:foreign_type] || "#{name}_type"
+          declare_polymorphic_type_field(foreign_type, column_options)
+          index([foreign_type, fkey], index_options) if index_options[:name] != false
+        else
+          index(fkey, index_options) if index_options[:name] != false
+          constraint(fkey, fk_options) if fk_options[:constraint_name] != false
         end
       end
 
@@ -159,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
@@ -185,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,138 @@
+# 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 || sqlite_compound_primary_key(model, t) or
+            raise "could not find primary key for table #{t} in #{model.connection.columns(t).inspect}"
+
+          primary_key_found = false
+          index_definitions = model.connection.indexes(t).map do |i|
+            model.ignore_indexes.include?(i.name) and next
+            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
+              # skip this primary key index since we'll create it below, with PRIMARY_KEY_NAME
+              next
+            end
+            new(model, i.columns, name: i.name, unique: i.unique, where: i.where, table_name: old_table_name)
+          end.compact
+
+          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
+
+        private
+
+        # This is the old approach which is still needed for MySQL in Rails 4 and SQLite
+        def sqlite_compound_primary_key(model, table)
+          ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) || Rails::VERSION::MAJOR < 5 or return nil
+
+          connection = model.connection.dup
+
+          class << connection   # defeat Rails MySQL driver code that skips the primary key by changing its name to a symbol
+            def each_hash(result)
+              super do |hash|
+                if hash[:Key_name] == PRIMARY_KEY_NAME
+                  hash[:Key_name] = PRIMARY_KEY_NAME.to_sym
+                end
+                yield hash
+              end
+            end
+          end
+
+          pk_index = connection.indexes(table).find { |index| index.name.to_s == PRIMARY_KEY_NAME } or return nil
+
+          Array(pk_index.columns)
+        end
+      end
+
+      def primary_key?
+        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