declare_schema 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f3116a6fbb5a47de5809f3f813c88783284bad601452679fa59784f3598834b
-  data.tar.gz: 8f4b6fee7b4d17e5b644f32a4b624a3f77526f91826a8c0b82d61b6e25130332
+  metadata.gz: 1e5c665ec203dd84e445290bac1de190491560ddc409fe2bd3f5ba4831e065c5
+  data.tar.gz: 244148b892d2de22a692c4db50b136995f97d8da38573e87a443303fdee5be7a
 SHA512:
-  metadata.gz: b833000d28d64e7856de05c9ae822c88dcceeb7861f777f13177ea8017e56bf937aba42b9da14ae1ce4810fd275c5462cb08c18c32839255ab46f1de116eee1d
-  data.tar.gz: c41c8cbdafd96eeb92fcf5c646ff9d18f4ce2374f06ecc6977015fa8406bc4639ab3722354212d1a75274c5af982f10b6c2f4c838de94f4b9436da20f836d5d3
+  metadata.gz: 44994fd571b97768ffec2c9bbce779b8beef222ba50213a425a3021c66f1dc4e4fd7a50adc95cf3d1a1116e67eaf5c47b11e635408856c726118a22c18188b98
+  data.tar.gz: 7d3eb3be095a1dce65b6b39b35974a6c96ee940fec31dba3fddbfb528be8be3b42906ec81c6075cde5d8fa590df4afc8ca12887a956c772fc34c084791577526

data/CHANGELOG.md

@@ -4,6 +4,37 @@ 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.
+
+## [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
 - Automatically eager_load! all Rails::Engines before generating migrations.
@@ -13,7 +44,7 @@ Note: this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0
 
 ### Fixed
 - Fixed a bug where `:text limit: 0xffff_ffff` (max size) was omitted from migrations.
-- Fixed a bug where `:bigint` foreign keys were omitted from the migration. 
+- Fixed a bug where `:bigint` foreign keys were omitted from the migration.
 
 ## [0.1.3] - 2020-10-08
 ### Changed
@@ -29,6 +60,9 @@ 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
 [0.1.3]: https://github.com/Invoca/declare_schema/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/Invoca/declare_schema/compare/v0.1.1...v0.1.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    declare_schema (0.2.0)
+    declare_schema (0.4.0)
       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.0)
       msgpack (~> 1.0)
     builder (3.2.4)
     byebug (11.1.3)
@@ -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/README.md

@@ -50,6 +50,26 @@ Migration filename: [<enter>=declare_schema_migration_1|<custom_name>]: add_comp
 ```
 Note that the migration generator is interactive -- it can't tell the difference between renaming something vs. adding one thing and removing another, so sometimes it will ask you to clarify.
 
+## Migrator Configuration
+
+The following configuration options are available for the gem and can be used
+during the initialization of your Rails application.
+
+### before_generating_migration callback
+
+During the initializtion process for generating migrations, `DeclareSchema` will
+trigger the `eager_load!` on the `Rails` application and all `Rails::Engine`s loaded
+into scope.  If you need to generate migrations for models that aren't automatically loaded by `eager_load!`,
+load them in the `before_generating_migration` block.
+
+**Example Configuration**
+
+```ruby
+DeclareSchema::Migration::Migrator.before_generating_migration do
+  require 'lib/some/hidden/models.rb'
+end
+```
+
 ## Installing
 
 Install the `DeclareSchema` gem directly:

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,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