declare_schema 0.8.0.pre.3 → 0.9.0

data/lib/declare_schema/model/field_spec.rb

@@ -47,11 +47,9 @@ module DeclareSchema
       end
 
       def initialize(model, name, type, position: 0, **options)
-        # TODO: TECH-5116
-        # Invoca change - searching for the primary key was causing an additional database read on every model load.  Assume
-        # "id" which works for invoca.
-        # raise ArgumentError, "you cannot provide a field spec for the primary key" if name == model.primary_key
-        name == "id" and raise ArgumentError, "you cannot provide a field spec for the primary key"
+        _defined_primary_key = model._defined_primary_key
+
+        name.to_s == _defined_primary_key and raise ArgumentError, "you may not provide a field spec for the primary key #{name.inspect}"
 
         @model = model
         @name = name.to_sym
@@ -60,18 +58,21 @@ module DeclareSchema
         @position = position
         @options = options.dup
 
-        @options.has_key?(:null) or @options[:null] = false
+        @options.has_key?(:null) or @options[:null] = ::DeclareSchema.default_null
+        @options[:null].nil? and raise "null: must be provided for field #{model}##{@name}: #{@options.inspect} since ::DeclareSchema#default_null is set to 'nil'; do you want `null: false`?"
 
         case @type
         when :text
           if self.class.mysql_text_limits?
             @options[:default].nil? or raise MysqlTextMayNotHaveDefault, "when using MySQL, non-nil default may not be given for :text field #{model}##{@name}"
-            @options[:limit] = self.class.round_up_mysql_text_limit(@options[:limit] || MYSQL_LONGTEXT_LIMIT)
+            @options[:limit] ||= ::DeclareSchema.default_text_limit or
+                  raise("limit: must be provided for :text field #{model}##{@name}: #{@options.inspect} since ::DeclareSchema#default_text_limit is set to 'nil'; do you want `limit: 0xffff_ffff`?")
+            @options[:limit] = self.class.round_up_mysql_text_limit(@options[:limit])
           else
             @options.delete(:limit)
           end
         when :string
-          @options[:limit] or raise "limit: must be given for :string field #{model}##{@name}: #{@options.inspect}; do you want `limit: 255`?"
+          @options[:limit] ||= ::DeclareSchema.default_string_limit or raise "limit: must be provided for :string field #{model}##{@name}: #{@options.inspect} since ::DeclareSchema#default_string_limit is set to 'nil'; do you want `limit: 255`?"
         when :bigint
           @type = :integer
           @options[:limit] = 8
@@ -80,7 +81,7 @@ module DeclareSchema
         Column.native_type?(@type) or raise UnknownTypeError, "#{@type.inspect} not found in #{Column.native_types.inspect} for adapter #{ActiveRecord::Base.connection.class.name}"
 
         if @type.in?([:string, :text, :binary, :varbinary, :integer, :enum])
-          @options[:limit] ||= Column.native_types[@type][:limit]
+          @options[:limit] ||= Column.native_types.dig(@type, :limit)
         else
           @type != :decimal && @options.has_key?(:limit) and warn("unsupported limit: for SQL type #{@type} in field #{model}##{@name}")
           @options.delete(:limit)
@@ -98,15 +99,15 @@ module DeclareSchema
 
         if @type.in?([:text, :string])
           if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
-            @options[:charset]   ||= model.table_options[:charset]   || Generators::DeclareSchema::Migration::Migrator.default_charset
-            @options[:collation] ||= model.table_options[:collation] || Generators::DeclareSchema::Migration::Migrator.default_collation
+            @options[:charset]   ||= model.table_options[:charset]   || ::DeclareSchema.default_charset
+            @options[:collation] ||= model.table_options[:collation] || ::DeclareSchema.default_collation
           else
             @options.delete(:charset)
             @options.delete(:collation)
           end
         else
           @options[:charset]   and warn("charset may only given for :string and :text fields for SQL type #{@type} in field #{model}##{@name}")
-          @options[:collation] and warne("collation may only given for :string and :text fields for SQL type #{@type} in field #{model}##{@name}")
+          @options[:collation] and warn("collation may only given for :string and :text fields for SQL type #{@type} in field #{model}##{@name}")
         end
 
         @options = Hash[@options.sort_by { |k, _v| OPTION_INDEXES[k] || 9999 }]

data/lib/declare_schema/model/foreign_key_definition.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'index_definition'
+
 module DeclareSchema
   module Model
     class ForeignKeyDefinition
@@ -15,10 +17,10 @@ module DeclareSchema
         @child_table = model.table_name # unless a table rename, which would happen when a class is renamed??
         @parent_table_name = options[:parent_table]&.to_s
         @foreign_key_name = options[:foreign_key]&.to_s || @foreign_key
-        @index_name = options[:index_name]&.to_s || model.connection.index_name(model.table_name, column: @foreign_key_name)
 
-        # Empty constraint lets mysql generate the name
-        @constraint_name = options[:constraint_name]&.to_s || @index_name&.to_s || ''
+        @constraint_name = options[:constraint_name]&.to_s ||
+                             options[:index_name]&.to_s ||
+                             IndexDefinition.index_name(@foreign_key_name)
         @on_delete_cascade = options[:dependent] == :delete
       end
 

data/lib/declare_schema/model/habtm_model_shim.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  module Model
+    class HabtmModelShim
+      class << self
+        def from_reflection(refl)
+          join_table = refl.join_table
+          foreign_keys_and_classes = [
+            [refl.foreign_key.to_s, refl.active_record],
+            [refl.association_foreign_key.to_s, refl.class_name.constantize]
+          ].sort { |a, b| a.first <=> b.first }
+          foreign_keys = foreign_keys_and_classes.map(&:first)
+          foreign_key_classes = foreign_keys_and_classes.map(&:last)
+          # this may fail in weird ways if HABTM is running across two DB connections (assuming that's even supported)
+          # figure that anybody who sets THAT up can deal with their own migrations...
+          connection = refl.active_record.connection
+
+          new(join_table, foreign_keys, foreign_key_classes, connection)
+        end
+      end
+
+      attr_reader :join_table, :foreign_keys, :foreign_key_classes, :connection
+
+      def initialize(join_table, foreign_keys, foreign_key_classes, connection)
+        @join_table = join_table
+        @foreign_keys = foreign_keys
+        @foreign_key_classes = foreign_key_classes
+        @connection = connection
+      end
+
+      def table_options
+        {}
+      end
+
+      def table_name
+        join_table
+      end
+
+      def field_specs
+        foreign_keys.each_with_index.each_with_object({}) do |(v, position), result|
+          result[v] = ::DeclareSchema::Model::FieldSpec.new(self, v, :integer, position: position, null: false)
+        end
+      end
+
+      def primary_key
+        false # no single-column primary key in database
+      end
+
+      def _defined_primary_key
+        false # no single-column primary key declared
+      end
+
+      def index_definitions_with_primary_key
+        [
+          IndexDefinition.new(self, foreign_keys, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME),
+          IndexDefinition.new(self, foreign_keys.last) # not unique by itself; combines with primary key to be unique
+        ]
+      end
+
+      alias_method :index_definitions, :index_definitions_with_primary_key
+
+      def ignore_indexes
+        []
+      end
+
+      def constraint_specs
+        [
+          ForeignKeyDefinition.new(self, foreign_keys.first, parent_table: foreign_key_classes.first.table_name, constraint_name: "#{join_table}_FK1", dependent: :delete),
+          ForeignKeyDefinition.new(self, foreign_keys.last, parent_table: foreign_key_classes.last.table_name, constraint_name: "#{join_table}_FK2", dependent: :delete)
+        ]
+      end
+    end
+  end
+end

data/lib/declare_schema/model/index_definition.rb

@@ -19,7 +19,7 @@ module DeclareSchema
         @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_')
+        @name = options.delete(:name) || self.class.index_name(@fields)
         @unique = options.delete(:unique) || name == PRIMARY_KEY_NAME || false
 
         if @name.length > MYSQL_INDEX_NAME_MAX_LENGTH
@@ -60,6 +60,10 @@ module DeclareSchema
           index_definitions
         end
 
+        def index_name(columns)
+          "on_#{Array(columns).join("_and_")}"
+        end
+
         private
 
         # This is the old approach which is still needed for MySQL in Rails 4 and SQLite

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "0.8.0.pre.3"
+  VERSION = "0.9.0"
 end

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

@@ -6,95 +6,17 @@ require 'active_record/connection_adapters/abstract_adapter'
 module Generators
   module DeclareSchema
     module Migration
-      HabtmModelShim = Struct.new(:join_table, :foreign_keys, :foreign_key_classes, :connection) do
-        class << self
-          def from_reflection(refl)
-            join_table = refl.join_table
-            foreign_keys_and_classes = [
-              [refl.foreign_key.to_s, refl.active_record],
-              [refl.association_foreign_key.to_s, refl.class_name.constantize]
-            ].sort { |a, b| a.first <=> b.first }
-            foreign_keys = foreign_keys_and_classes.map(&:first)
-            foreign_key_classes = foreign_keys_and_classes.map(&:last)
-            # this may fail in weird ways if HABTM is running across two DB connections (assuming that's even supported)
-            # figure that anybody who sets THAT up can deal with their own migrations...
-            connection = refl.active_record.connection
-
-            new(join_table, foreign_keys, foreign_key_classes, connection)
-          end
-        end
-
-        def table_options
-          {}
-        end
-
-        def table_name
-          join_table
-        end
-
-        def table_exists?
-          ActiveRecord::Migration.table_exists? table_name
-        end
-
-        def field_specs
-          i = 0
-          foreign_keys.each_with_object({}) do |v, result|
-            result[v] = ::DeclareSchema::Model::FieldSpec.new(self, v, :integer, position: i, null: false)
-            i += 1
-          end
-        end
-
-        def primary_key
-          false # no single-column primary key
-        end
-
-        def index_definitions_with_primary_key
-          [
-            ::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_definitions, :index_definitions_with_primary_key
-
-        def ignore_indexes
-          []
-        end
-
-        def constraint_specs
-          [
-            ::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
-
       class Migrator
         class Error < RuntimeError; end
 
-        DEFAULT_CHARSET   = "utf8mb4"
-        DEFAULT_COLLATION = "utf8mb4_bin"
-
         @ignore_models                        = []
         @ignore_tables                        = []
         @before_generating_migration_callback = nil
         @active_record_class                  = ActiveRecord::Base
-        @default_charset                      = DEFAULT_CHARSET
-        @default_collation                    = DEFAULT_COLLATION
 
         class << self
-          attr_accessor :ignore_models, :ignore_tables, :disable_indexing, :disable_constraints
-          attr_reader :active_record_class, :default_charset, :default_collation, :before_generating_migration_callback
-
-          def default_charset=(charset)
-            charset.is_a?(String) or raise ArgumentError, "charset must be a string (got #{charset.inspect})"
-            @default_charset = charset
-          end
-
-          def default_collation=(collation)
-            collation.is_a?(String) or raise ArgumentError, "collation must be a string (got #{collation.inspect})"
-            @default_collation = collation
-          end
+          attr_accessor :ignore_models, :ignore_tables
+          attr_reader :active_record_class, :before_generating_migration_callback
 
           def active_record_class
             @active_record_class.is_a?(Class) or @active_record_class = @active_record_class.to_s.constantize
@@ -121,6 +43,9 @@ module Generators
             block or raise ArgumentError, 'A block is required when setting the before_generating_migration callback'
             @before_generating_migration_callback = block
           end
+
+          delegate :default_charset=, :default_collation=, :default_charset, :default_collation, to: ::DeclareSchema
+          deprecate :default_charset=, :default_collation=, :default_charset, :default_collation, deprecator: ActiveSupport::Deprecation.new('1.0', 'declare_schema')
         end
 
         def initialize(ambiguity_resolver = {})
@@ -266,7 +191,7 @@ module Generators
           end
           # generate shims for HABTM models
           habtm_tables.each do |name, refls|
-            models_by_table_name[name] = HabtmModelShim.from_reflection(refls.first)
+            models_by_table_name[name] = ::DeclareSchema::Model::HabtmModelShim.from_reflection(refls.first)
           end
           model_table_names = models_by_table_name.keys
 
@@ -342,18 +267,19 @@ module Generators
             end
 
             #{table_options_definition.alter_table_statement unless ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)}
-            #{create_indexes(model).join("\n")               unless Migrator.disable_indexing}
-            #{create_constraints(model).join("\n")           unless Migrator.disable_indexing}
+            #{create_indexes(model).join("\n")               if ::DeclareSchema.default_generate_indexing}
+            #{create_constraints(model).join("\n")           if ::DeclareSchema.default_generate_foreign_keys}
           EOS
         end
 
         def create_table_options(model, disable_auto_increment)
-          if model.primary_key.blank? || disable_auto_increment
+          primary_key = model._defined_primary_key
+          if primary_key.blank? || disable_auto_increment
             "id: false"
-          elsif model.primary_key == "id"
+          elsif primary_key == "id"
             "id: :bigint"
           else
-            "primary_key: :#{model.primary_key}"
+            "primary_key: :#{primary_key}"
           end
         end
 
@@ -362,8 +288,8 @@ module Generators
             {}
           else
             {
-              charset:   model.table_options[:charset] || Migrator.default_charset,
-              collation: model.table_options[:collation] || Migrator.default_collation
+              charset:   model.table_options[:charset] || ::DeclareSchema.default_charset,
+              collation: model.table_options[:collation] || ::DeclareSchema.default_collation
             }
           end
         end
@@ -386,18 +312,18 @@ module Generators
           new_table_name = model.table_name
 
           db_columns = model.connection.columns(current_table_name).index_by(&:name)
-          key_missing = db_columns[model.primary_key].nil? && model.primary_key.present?
-          if model.primary_key.present?
-            db_columns.delete(model.primary_key)
+          key_missing = db_columns[model._defined_primary_key].nil? && model._defined_primary_key.present?
+          if model._defined_primary_key.present?
+            db_columns.delete(model._defined_primary_key)
           end
 
           model_column_names = model.field_specs.keys.map(&:to_s)
           db_column_names = db_columns.keys.map(&:to_s)
 
           to_add = model_column_names - db_column_names
-          to_add += [model.primary_key] if key_missing && model.primary_key.present?
+          to_add += [model._defined_primary_key] if key_missing && model._defined_primary_key.present?
           to_remove = db_column_names - model_column_names
-          to_remove -= [model.primary_key.to_sym] if model.primary_key.present?
+          to_remove -= [model._defined_primary_key.to_sym] if model._defined_primary_key.present?
 
           to_rename = extract_column_renames!(to_add, to_remove, new_table_name)
 
@@ -477,7 +403,7 @@ module Generators
         end
 
         def change_indexes(model, old_table_name, to_remove)
-          Migrator.disable_constraints and return [[], []]
+          ::DeclareSchema.default_generate_indexing or return [[], []]
 
           new_table_name = model.table_name
           existing_indexes = ::DeclareSchema::Model::IndexDefinition.for_model(model, old_table_name)
@@ -518,7 +444,7 @@ module Generators
 
         def change_foreign_key_constraints(model, old_table_name)
           ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) and raise ArgumentError, 'SQLite does not support foreign keys'
-          Migrator.disable_indexing and return [[], []]
+          ::DeclareSchema.default_generate_foreign_keys or return [[], []]
 
           new_table_name = model.table_name
           existing_fks = ::DeclareSchema::Model::ForeignKeyDefinition.for_model(model, old_table_name)
@@ -647,8 +573,8 @@ module Generators
         # TODO: rewrite this method to use charset and collation variables rather than manipulating strings. -Colin
         def fix_mysql_charset_and_collation(dumped_schema)
           if !dumped_schema['options: ']
-            dumped_schema.sub!('",', "\", options: \"DEFAULT CHARSET=#{Generators::DeclareSchema::Migration::Migrator.default_charset} "+
-              "COLLATE=#{Generators::DeclareSchema::Migration::Migrator.default_collation}\",")
+            dumped_schema.sub!('",', "\", options: \"DEFAULT CHARSET=#{::DeclareSchema.default_charset} "+
+              "COLLATE=#{::DeclareSchema.default_collation}\",")
           end
           default_charset   = dumped_schema[/CHARSET=(\w+)/, 1]   or raise "unable to find charset in #{dumped_schema.inspect}"
           default_collation = dumped_schema[/COLLATE=(\w+)/, 1] || default_collation_from_charset(default_charset) or

data/spec/lib/declare_schema/field_spec_spec.rb

@@ -6,7 +6,7 @@ rescue LoadError
 end
 
 RSpec.describe DeclareSchema::Model::FieldSpec do
-  let(:model) { double('model', table_options: {}) }
+  let(:model) { double('model', table_options: {}, _defined_primary_key: 'id') }
   let(:col_spec) { double('col_spec', type: :string) }
 
   before do
@@ -61,6 +61,15 @@ RSpec.describe DeclareSchema::Model::FieldSpec do
           expect(subject.schema_attributes(col_spec)).to eq(type: :string, limit: 100, null: true)
         end
       end
+
+      it 'raises error when default_string_limit option is nil when not explicitly set in field spec' do
+        if defined?(Mysql2)
+          expect(::DeclareSchema).to receive(:default_string_limit) { nil }
+          expect do
+            described_class.new(model, :title, :string, null: true, charset: 'utf8mb4', position: 0)
+          end.to raise_error(/limit: must be provided for :string field/)
+        end
+      end
     end
 
     describe 'text' do
@@ -84,36 +93,66 @@ RSpec.describe DeclareSchema::Model::FieldSpec do
         end
       end
 
-      describe 'decimal' do
-        it 'allows precision: and scale:' do
-          subject = described_class.new(model, :quantity, :decimal, precision: 8, scale: 10, null: true, position: 3)
-          expect(subject.schema_attributes(col_spec)).to eq(type: :decimal, precision: 8, scale: 10, null: true)
+      describe 'limit' do
+        it 'uses default_text_limit option when not explicitly set in field spec' do
+          allow(::DeclareSchema).to receive(:default_text_limit) { 100 }
+          subject = described_class.new(model, :title, :text, null: true, charset: 'utf8mb4', position: 2)
+          if defined?(Mysql2)
+            expect(subject.schema_attributes(col_spec)).to eq(type: :text, limit: 255, null: true, charset: 'utf8mb4', collation: 'utf8mb4_bin')
+          else
+            expect(subject.schema_attributes(col_spec)).to eq(type: :text, null: true)
+          end
         end
 
-        it 'requires precision:' do
-          expect_any_instance_of(described_class).to receive(:warn).with(/precision: required for :decimal type/)
-          described_class.new(model, :quantity, :decimal, scale: 10, null: true, position: 3)
+        it 'raises error when default_text_limit option is nil when not explicitly set in field spec' do
+          if defined?(Mysql2)
+            expect(::DeclareSchema).to receive(:default_text_limit) { nil }
+            expect do
+              described_class.new(model, :title, :text, null: true, charset: 'utf8mb4', position: 2)
+            end.to raise_error(/limit: must be provided for :text field/)
+          end
         end
+      end
+    end
 
-        it 'requires scale:' do
-          expect_any_instance_of(described_class).to receive(:warn).with(/scale: required for :decimal type/)
-          described_class.new(model, :quantity, :decimal, precision: 8, null: true, position: 3)
+    if defined?(Mysql2)
+      describe 'varbinary' do # TODO: :varbinary is an Invoca addition to Rails; make it a configurable option
+        it 'is supported' do
+          subject = described_class.new(model, :binary_dump, :varbinary, limit: 200, null: false, position: 2)
+          expect(subject.schema_attributes(col_spec)).to eq(type: :varbinary, limit: 200, null: false)
         end
       end
+    end
 
-      [:integer, :bigint, :string, :text, :binary, :datetime, :date, :time].each do |t|
-        describe t.to_s do
-          let(:extra) { t == :string ? { limit: 100 } : {} }
+    describe 'decimal' do
+      it 'allows precision: and scale:' do
+        subject = described_class.new(model, :quantity, :decimal, precision: 8, scale: 10, null: true, position: 3)
+        expect(subject.schema_attributes(col_spec)).to eq(type: :decimal, precision: 8, scale: 10, null: true)
+      end
 
-          it 'does not allow precision:' do
-            expect_any_instance_of(described_class).to receive(:warn).with(/precision: only allowed for :decimal type/)
-            described_class.new(model, :quantity, t, { precision: 8, null: true, position: 3 }.merge(extra))
-          end unless t == :datetime
+      it 'requires precision:' do
+        expect_any_instance_of(described_class).to receive(:warn).with(/precision: required for :decimal type/)
+        described_class.new(model, :quantity, :decimal, scale: 10, null: true, position: 3)
+      end
 
-          it 'does not allow scale:' do
-            expect_any_instance_of(described_class).to receive(:warn).with(/scale: only allowed for :decimal type/)
-            described_class.new(model, :quantity, t, { scale: 10, null: true, position: 3 }.merge(extra))
-          end
+      it 'requires scale:' do
+        expect_any_instance_of(described_class).to receive(:warn).with(/scale: required for :decimal type/)
+        described_class.new(model, :quantity, :decimal, precision: 8, null: true, position: 3)
+      end
+    end
+
+    [:integer, :bigint, :string, :text, :binary, :datetime, :date, :time, (:varbinary if defined?(Mysql2))].compact.each do |t|
+      describe t.to_s do
+        let(:extra) { t == :string ? { limit: 100 } : {} }
+
+        it 'does not allow precision:' do
+          expect_any_instance_of(described_class).to receive(:warn).with(/precision: only allowed for :decimal type/)
+          described_class.new(model, :quantity, t, { precision: 8, null: true, position: 3 }.merge(extra))
+        end unless t == :datetime
+
+        it 'does not allow scale:' do
+          expect_any_instance_of(described_class).to receive(:warn).with(/scale: only allowed for :decimal type/)
+          described_class.new(model, :quantity, t, { scale: 10, null: true, position: 3 }.merge(extra))
         end
       end
     end
@@ -175,5 +214,17 @@ RSpec.describe DeclareSchema::Model::FieldSpec do
     it 'excludes non-sql options' do
       expect(subject.sql_options).to eq(limit: 4, null: true, default: 0)
     end
+
+    describe 'null' do
+      subject { described_class.new(model, :price, :integer, limit: 4, default: 0, position: 2, encrypt_using: ->(field) { field }) }
+      it 'uses default_null option when not explicitly set in field spec' do
+        expect(subject.sql_options).to eq(limit: 4, null: false, default: 0)
+      end
+
+      it 'raises error if default_null is set to nil when not explicitly set in field spec' do
+        expect(::DeclareSchema).to receive(:default_null) { nil }
+        expect { subject.sql_options }.to raise_error(/null: must be provided for field/)
+      end
+    end
   end
 end