declare_schema 0.8.0.pre.4 → 0.10.0.pre.dc.1

data/lib/declare_schema/model/column.rb

@@ -44,6 +44,8 @@ module DeclareSchema
             if ActiveRecord::Base.connection.class.name.match?(/mysql/i)
               types[:text][:limit]    ||= 0xffff
               types[:binary][:limit]  ||= 0xffff
+
+              types[:varbinary] ||= { name: "varbinary" } # TODO: :varbinary is an Invoca addition to Rails; make it a configurable option
             end
           end
         end

data/lib/declare_schema/model/field_spec.rb

@@ -47,9 +47,9 @@ module DeclareSchema
       end
 
       def initialize(model, name, type, position: 0, **options)
-        defined_primary_key = model.defined_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}"
+        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
@@ -58,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
@@ -78,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)
@@ -96,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/habtm_model_shim.rb

@@ -47,7 +47,7 @@ module DeclareSchema
         false # no single-column primary key in database
       end
 
-      def defined_primary_key
+      def _defined_primary_key
         false # no single-column primary key declared
       end
 

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "0.8.0.pre.4"
+  VERSION = "0.10.0.pre.dc.1"
 end

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

@@ -9,29 +9,14 @@ module Generators
       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
@@ -58,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 = {})
@@ -279,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
 
@@ -299,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
@@ -323,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)
 
@@ -414,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)
@@ -455,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)
@@ -584,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/lib/generators/declare_schema/support/model.rb

@@ -69,11 +69,11 @@ module DeclareSchema
             def declare_model_fields_and_associations
               buffer = ::DeclareSchema::Support::IndentedBuffer.new(indent: 2)
               buffer.newline!
-              buffer << 'fields do'
+              buffer << 'declare_schema do'
               buffer.indent! do
                 field_attributes.each do |attribute|
-                  decl = "%-#{max_attribute_length}s" % attribute.name + ' ' +
-                    attribute.type.to_sym.inspect +
+                  decl = "%-#{max_attribute_length}s" % attribute.type + ' ' +
+                    attribute.name.to_sym.inspect +
                     case attribute.type.to_s
                     when 'string'
                       ', limit: 255'
@@ -113,7 +113,7 @@ module DeclareSchema
             end
 
             def max_attribute_length
-              attributes.map { |attribute| attribute.name.length }.max
+              attributes.map { |attribute| attribute.type.length }.max
             end
 
             def field_attributes

data/spec/lib/declare_schema/api_spec.rb

@@ -20,9 +20,9 @@ RSpec.describe 'DeclareSchema API' do
       expect_model_definition_to_eq('advert', <<~EOS)
         class Advert < #{active_record_base_class}
 
-          fields do
-            title :string, limit: 255
-            body  :text
+          declare_schema do
+            string :title, limit: 255
+            text   :body
           end
 
         end
@@ -91,8 +91,8 @@ RSpec.describe 'DeclareSchema API' do
       class AdvertWithRequiredTitle < ActiveRecord::Base
         self.table_name = 'adverts'
 
-        fields do
-          title :string, :required, limit: 255
+        declare_schema do
+          string :title, :required, limit: 255
         end
       end
 
@@ -110,8 +110,8 @@ RSpec.describe 'DeclareSchema API' do
       class AdvertWithUniqueTitle < ActiveRecord::Base
         self.table_name = 'adverts'
 
-        fields do
-          title :string, :unique, limit: 255
+        declare_schema do
+          string :title, :unique, limit: 255
         end
       end
 

data/spec/lib/declare_schema/field_declaration_dsl_spec.rb

@@ -3,29 +3,55 @@
 require_relative '../../../lib/declare_schema/field_declaration_dsl'
 
 RSpec.describe DeclareSchema::FieldDeclarationDsl do
-  before do
-    load File.expand_path('prepare_testapp.rb', __dir__)
+  let(:model) { TestModel.new }
+  subject { declared_class.new(model) }
 
-    class TestModel < ActiveRecord::Base
-      fields do
-        name :string, limit: 127
+  context 'Using fields' do
+    before do
+      load File.expand_path('prepare_testapp.rb', __dir__)
 
-        timestamps
+      class TestModel < ActiveRecord::Base
+        fields do
+          name :string, limit: 127
+
+          timestamps
+        end
       end
     end
-  end
 
-  let(:model) { TestModel.new }
-  subject { declared_class.new(model) }
+    it 'has fields' do
+      expect(TestModel.field_specs).to be_kind_of(Hash)
+      expect(TestModel.field_specs.keys).to eq(['name', 'created_at', 'updated_at'])
+      expect(TestModel.field_specs.values.map(&:type)).to eq([:string, :datetime, :datetime])
+    end
 
-  it 'has fields' do
-    expect(TestModel.field_specs).to be_kind_of(Hash)
-    expect(TestModel.field_specs.keys).to eq(['name', 'created_at', 'updated_at'])
-    expect(TestModel.field_specs.values.map(&:type)).to eq([:string, :datetime, :datetime])
+    it 'stores limits' do
+      expect(TestModel.field_specs['name'].limit).to eq(127), TestModel.field_specs['name'].inspect
+    end
   end
 
-  it 'stores limits' do
-    expect(TestModel.field_specs['name'].limit).to eq(127), TestModel.field_specs['name'].inspect
+  context 'Using declare_schema' do
+    before do
+      load File.expand_path('prepare_testapp.rb', __dir__)
+
+      class TestModel < ActiveRecord::Base
+        declare_schema do
+          string :name, limit: 127
+
+          timestamps
+        end
+      end
+    end
+
+    it 'has fields' do
+      expect(TestModel.field_specs).to be_kind_of(Hash)
+      expect(TestModel.field_specs.keys).to eq(['name', 'created_at', 'updated_at'])
+      expect(TestModel.field_specs.values.map(&:type)).to eq([:string, :datetime, :datetime])
+    end
+
+    it 'stores limits' do
+      expect(TestModel.field_specs['name'].limit).to eq(127), TestModel.field_specs['name'].inspect
+    end
   end
 
   # TODO: fill out remaining tests

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: {}, defined_primary_key: 'id') }
+  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