declare_schema 0.14.1 → 1.0.0

data/lib/declare_schema/model/foreign_key_definition.rb

@@ -10,7 +10,7 @@ module DeclareSchema
       attr_reader :constraint_name, :model, :foreign_key, :foreign_key_name, :parent_table_name, :child_table_name, :options, :on_delete_cascade
 
 
-      def initialize(model, foreign_key, options = {})
+      def initialize(model, foreign_key, **options)
         @model = model
         @foreign_key = foreign_key.to_s.presence
         @options = options
@@ -38,7 +38,7 @@ module DeclareSchema
             }
             options[:dependent] = :delete if fkc['ON DELETE CASCADE']
 
-            new(model, foreign_key, options)
+            new(model, foreign_key, **options)
           end
         end
       end

data/lib/declare_schema/model/index_definition.rb

@@ -14,7 +14,7 @@ module DeclareSchema
       PRIMARY_KEY_NAME = "PRIMARY"
       MYSQL_INDEX_NAME_MAX_LENGTH = 64
 
-      def initialize(model, fields, options = {})
+      def initialize(model, fields, **options)
         @model = model
         @table = options.delete(:table_name) || model.table_name
         @fields = Array.wrap(fields).map(&:to_s)

data/lib/declare_schema/model/table_options_definition.rb

@@ -19,7 +19,7 @@ module DeclareSchema
                             {}
                           end
 
-          new(table_name, table_options)
+          new(table_name, **table_options)
         end
 
         private
@@ -48,7 +48,7 @@ module DeclareSchema
 
       attr_reader :table_name, :table_options
 
-      def initialize(table_name, table_options = {})
+      def initialize(table_name, **table_options)
         @table_name    = table_name
         @table_options = table_options
       end

data/lib/declare_schema/model.rb

@@ -49,11 +49,11 @@ module DeclareSchema
     end
 
     module ClassMethods
-      def index(fields, options = {})
+      def index(fields, **options)
         # make index idempotent
         index_fields_s = Array.wrap(fields).map(&:to_s)
         unless index_definitions.any? { |index_spec| index_spec.fields == index_fields_s }
-          index_definitions << ::DeclareSchema::Model::IndexDefinition.new(self, fields, options)
+          index_definitions << ::DeclareSchema::Model::IndexDefinition.new(self, fields, **options)
         end
       end
 
@@ -61,10 +61,10 @@ module DeclareSchema
         index(fields.flatten, unique: true, name: ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME)
       end
 
-      def constraint(fkey, options = {})
+      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::ForeignKeyDefinition.new(self, fkey, options)
+          constraint_specs << DeclareSchema::Model::ForeignKeyDefinition.new(self, fkey, **options)
         end
       end
 
@@ -157,10 +157,10 @@ module DeclareSchema
         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
+          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
+          index(fkey, **index_options) if index_options[:name] != false
+          constraint(fkey, **fk_options) if fk_options[:constraint_name] != false
         end
       end
 
@@ -258,7 +258,7 @@ module DeclareSchema
                   ActiveRecord::Coders::JSON
                 elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
                   class_name_or_coder
-                else 
+                else
                   ActiveRecord::Coders::YAMLColumn.new(attr_name, class_name_or_coder)
                 end
 
@@ -287,7 +287,7 @@ module DeclareSchema
             }
           # support index: true declaration
           index_opts[:name] = to_name unless to_name == true
-          index(name, index_opts)
+          index(name, **index_opts)
         end
       end
 

data/lib/declare_schema/version.rb

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

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

@@ -24,7 +24,7 @@ module Generators
             @active_record_class
           end
 
-          def run(renames = {})
+          def run(**renames)
             Migrator.new(renames: renames).generate
           end
 
@@ -235,7 +235,7 @@ module Generators
               [f.type, f.name, f.sql_options]
             end
 
-            table_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.new(model.table_name, table_options_for_model(model))
+            table_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.new(model.table_name, **table_options_for_model(model))
             table_options = create_table_options(model, disable_auto_increment)
 
             table_add = ::DeclareSchema::SchemaChange::TableAdd.new(t,
@@ -374,12 +374,12 @@ module Generators
               else
                 [:integer, {}]
               end
-            ::DeclareSchema::SchemaChange::ColumnAdd.new(new_table_name, c, type, options)
+            ::DeclareSchema::SchemaChange::ColumnAdd.new(new_table_name, c, type, **options)
           end
 
           removes = to_remove.map do |c|
             old_type, old_options = add_column_back(model, current_table_name, c)
-            ::DeclareSchema::SchemaChange::ColumnRemove.new(new_table_name, c, old_type, old_options)
+            ::DeclareSchema::SchemaChange::ColumnRemove.new(new_table_name, c, old_type, **old_options)
           end
 
           old_names = to_rename.invert
@@ -502,7 +502,7 @@ module Generators
 
         def change_table_options(model, current_table_name)
           old_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.for_model(model, current_table_name)
-          new_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.new(model.table_name, table_options_for_model(model))
+          new_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.new(model.table_name, **table_options_for_model(model))
 
           if old_options_definition.equivalent?(new_options_definition)
             []
@@ -552,7 +552,7 @@ module Generators
         end
 
         SchemaDumper = ActiveRecord::ConnectionAdapters::SchemaDumper
-                      
+
 
         def add_table_back(table)
           dumped_schema_stream = StringIO.new

data/spec/lib/declare_schema/field_declaration_dsl_spec.rb

@@ -6,30 +6,6 @@ RSpec.describe DeclareSchema::FieldDeclarationDsl do
   let(:model) { TestModel.new }
   subject { declared_class.new(model) }
 
-  context 'Using fields' do
-    before do
-      load File.expand_path('prepare_testapp.rb', __dir__)
-
-      class TestModel < ActiveRecord::Base
-        fields do
-          name :string, 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
-
   context 'Using declare_schema' do
     before do
       load File.expand_path('prepare_testapp.rb', __dir__)

data/spec/lib/declare_schema/field_spec_spec.rb

@@ -185,12 +185,12 @@ RSpec.describe DeclareSchema::Model::FieldSpec do
 
         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))
+          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))
+          described_class.new(model, :quantity, t, **{ scale: 10, null: true, position: 3 }.merge(extra))
         end
       end
     end

data/spec/lib/declare_schema/interactive_primary_key_spec.rb

@@ -10,73 +10,6 @@ RSpec.describe 'DeclareSchema Migration Generator interactive primary key' do
     load File.expand_path('prepare_testapp.rb', __dir__)
   end
 
-  context 'Using fields' do
-    it "allows alternate primary keys" do
-      class Foo < ActiveRecord::Base
-        fields do
-        end
-        self.primary_key = "foo_id"
-      end
-
-      generate_migrations '-n', '-m'
-      expect(Foo._declared_primary_key).to eq('foo_id')
-
-      ### migrate from
-      # rename from custom primary_key
-      class Foo < ActiveRecord::Base
-        fields do
-        end
-        self.primary_key = "id"
-      end
-
-      allow_any_instance_of(DeclareSchema::Support::ThorShell).to receive(:ask).with(/one of the rename choices or press enter to keep/) { 'id' }
-      generate_migrations '-n', '-m'
-      expect(Foo._declared_primary_key).to eq('id')
-
-      nuke_model_class(Foo)
-
-      # The ActiveRecord sqlite3 driver has a bug where rename_column recreates the entire table, but forgets to set the primary key:
-      #
-      # [7] pry(#<RSpec::ExampleGroups::DeclareSchemaMigrationGeneratorInteractivePrimaryKey>)> u = 'rename_column :foos, :foo_id, :id'
-      # => "rename_column :foos, :foo_id, :id"
-      # [8] pry(#<RSpec::ExampleGroups::DeclareSchemaMigrationGeneratorInteractivePrimaryKey>)> ActiveRecord::Migration.class_eval(u)
-      # (0.0ms)  begin transaction
-      #  (pry):17
-      # (0.2ms)  CREATE TEMPORARY TABLE "afoos" ("id" integer NOT NULL)
-      #  (pry):17
-      # (0.1ms)  INSERT INTO "afoos" ("id")
-      #
-      #  (pry):17
-      # (0.4ms)  DROP TABLE "foos"
-      #  (pry):17
-      # (0.1ms)  CREATE TABLE "foos" ("id" integer NOT NULL)
-      #  (pry):17
-      # (0.1ms)  INSERT INTO "foos" ("id")
-      #
-      #  (pry):17
-      # (0.1ms)  DROP TABLE "afoos"
-      #  (pry):17
-      # (0.9ms)  commit transaction
-      if defined?(SQLite3)
-        ActiveRecord::Base.connection.execute("drop table foos")
-        ActiveRecord::Base.connection.execute("CREATE TABLE foos (id integer PRIMARY KEY AUTOINCREMENT NOT NULL)")
-      end
-
-      if !defined?(Mysql2) # TODO TECH-4814 Put this test back for Mysql2
-        # replace custom primary_key
-        class Foo < ActiveRecord::Base
-          fields do
-          end
-          self.primary_key = "foo_id"
-        end
-
-        allow_any_instance_of(DeclareSchema::Support::ThorShell).to receive(:ask).with(/one of the rename choices or press enter to keep/) { 'drop id' }
-        generate_migrations '-n', '-m'
-        expect(Foo._declared_primary_key).to eq('foo_id')
-      end
-    end
-  end
-
   context 'Using declare_schema' do
     it "allows alternate primary keys" do
       class Foo < ActiveRecord::Base