declare_schema 0.3.0 → 0.5.0.pre.1

data/spec/lib/declare_schema/model/index_definition_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative '../../../../lib/declare_schema/model/index_definition'
+
+# Beware: It looks out that Rails' sqlite3 driver has a bug in retrieving indexes.
+# In sqlite3/schema_statements, it skips over any index that starts with sqlite_:
+#    next if row["name"].starts_with?("sqlite_")
+# but this will skip over any indexes created to support "unique" column constraints.
+# This gem provides an explicit name for all indexes so it shouldn't be affected by the bug...
+# unless you manually create any Sqlite tables with UNIQUE constraints.
+
+RSpec.describe DeclareSchema::Model::IndexDefinition do
+  before do
+    load File.expand_path('../prepare_testapp.rb', __dir__)
+
+    class IndexDefinitionTestModel < ActiveRecord::Base
+      fields do
+        name :string, limit: 127, index: true
+
+        timestamps
+      end
+    end
+
+    class IndexDefinitionCompoundIndexModel < ActiveRecord::Base
+      fields do
+        fk1_id :integer
+        fk2_id :integer
+
+        timestamps
+      end
+    end
+  end
+
+  let(:model_class) { IndexDefinitionTestModel }
+
+  describe 'instance methods' do
+    let(:model) { model_class.new }
+    subject { declared_class.new(model_class) }
+
+    it 'has index_definitions' do
+      expect(model_class.index_definitions).to be_kind_of(Array)
+      expect(model_class.index_definitions.map(&:name)).to eq(['on_name'])
+      expect([:name, :fields, :unique].map { |attr| model_class.index_definitions[0].send(attr)}).to eq(
+        ['on_name', ['name'], false]
+      )
+    end
+
+    it 'has index_definitions_with_primary_key' do
+      expect(model_class.index_definitions_with_primary_key).to be_kind_of(Array)
+      result = model_class.index_definitions_with_primary_key.sort_by(&:name)
+      expect(result.map(&:name)).to eq(['PRIMARY', 'on_name'])
+      expect([:name, :fields, :unique].map { |attr| result[0].send(attr)}).to eq(
+        ['PRIMARY', ['id'], true]
+      )
+      expect([:name, :fields, :unique].map { |attr| result[1].send(attr)}).to eq(
+        ['on_name', ['name'], false]
+      )
+    end
+  end
+
+  describe 'class << self' do
+    context 'with a migrated database' do
+      before do
+        ActiveRecord::Base.connection.execute <<~EOS
+            CREATE TABLE index_definition_test_models (
+              id INTEGER NOT NULL PRIMARY KEY,
+              name TEXT NOT NULL
+            )
+        EOS
+        ActiveRecord::Base.connection.execute <<~EOS
+          CREATE UNIQUE INDEX index_definition_test_models_on_name ON index_definition_test_models(name)
+        EOS
+        ActiveRecord::Base.connection.execute <<~EOS
+            CREATE TABLE index_definition_compound_index_models (
+              fk1_id INTEGER NULL,
+              fk2_id INTEGER NULL,
+              PRIMARY KEY (fk1_id, fk2_id)
+            )
+        EOS
+        ActiveRecord::Base.connection.schema_cache.clear!
+      end
+
+      describe 'for_model' do
+        subject { described_class.for_model(model_class) }
+
+        context 'with single-column PK' do
+          it 'returns the indexes for the model' do
+            expect(subject.size).to eq(2), subject.inspect
+            expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
+              ['index_definition_test_models_on_name', ['name'], true]
+            )
+            expect([:name, :columns, :unique].map { |attr| subject[1].send(attr) }).to eq(
+              ['PRIMARY', ['id'], true]
+            )
+          end
+        end
+
+        context 'with compound-column PK' do
+          let(:model_class) { IndexDefinitionCompoundIndexModel }
+
+          it 'returns the indexes for the model' do
+            # Simulate MySQL for Rails 4 work-around
+            if Rails::VERSION::MAJOR < 5
+              expect(model_class.connection).to receive(:primary_key).with('index_definition_compound_index_models').and_return(nil)
+              connection_stub = instance_double(ActiveRecord::ConnectionAdapters::SQLite3Adapter, "connection")
+              expect(connection_stub).to receive(:indexes).
+                with('index_definition_compound_index_models').
+                and_return([DeclareSchema::Model::IndexDefinition.new(model_class, ['fk1_id', 'fk2_id'], name: 'PRIMARY')])
+
+              expect(model_class.connection).to receive(:dup).and_return(connection_stub)
+            end
+
+            expect(subject.size).to eq(1), subject.inspect
+            expect([:name, :columns, :unique].map { |attr| subject[0].send(attr) }).to eq(
+              ['PRIMARY', ['fk1_id', 'fk2_id'], true]
+            )
+          end
+        end
+      end
+    end
+  end
+  # TODO: fill out remaining tests
+end

data/spec/lib/declare_schema/model/table_options_definition_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'active_record/connection_adapters/mysql2_adapter'
+require_relative '../../../../lib/declare_schema/model/table_options_definition'
+
+RSpec.describe DeclareSchema::Model::TableOptionsDefinition do
+  before do
+    load File.expand_path('../prepare_testapp.rb', __dir__)
+
+    class TableOptionsDefinitionTestModel < ActiveRecord::Base
+      fields do
+        name :string, limit: 127, index: true
+      end
+    end
+  end
+
+  let(:model_class) { TableOptionsDefinitionTestModel }
+
+  context 'instance methods' do
+    let(:table_options) { { charset: "utf8", collation: "utf8_general"} }
+    let(:model) { described_class.new('table_options_definition_test_models', table_options) }
+
+    describe '#to_key' do
+      subject { model.to_key }
+      it { should eq(["table_options_definition_test_models", "{:charset=>\"utf8\", :collation=>\"utf8_general\"}"]) }
+    end
+
+    describe '#settings' do
+      subject { model.settings }
+      it { should eq("CHARACTER SET utf8 COLLATE utf8_general") }
+    end
+
+    describe '#hash' do
+      subject { model.hash }
+      it { should eq(["table_options_definition_test_models", "{:charset=>\"utf8\", :collation=>\"utf8_general\"}"].hash) }
+    end
+
+    describe '#to_s' do
+      subject { model.to_s }
+      it { should eq("CHARACTER SET utf8 COLLATE utf8_general") }
+    end
+
+    describe '#alter_table_statement' do
+      subject { model.alter_table_statement }
+      it { should eq('execute "ALTER TABLE \"table_options_definition_test_models\" CHARACTER SET utf8 COLLATE utf8_general;"') }
+    end
+  end
+
+
+  context 'class << self' do
+    describe '#for_model' do
+      context 'when using a SQLite connection' do
+        subject { described_class.for_model(model_class) }
+        it { should eq(described_class.new(model_class.table_name, {})) }
+      end
+      # TODO: Convert these tests to run against a MySQL database so that we can
+      #       perform them without mocking out so much
+      context 'when using a MySQL connection' do
+        before do
+          double(ActiveRecord::ConnectionAdapters::Mysql2Adapter).tap do |stub_connection|
+            expect(stub_connection).to receive(:class).and_return(ActiveRecord::ConnectionAdapters::Mysql2Adapter)
+            expect(stub_connection).to receive(:current_database).and_return('test_database')
+            expect(stub_connection).to receive(:quote_string).with('test_database').and_return('"test_database"')
+            expect(stub_connection).to receive(:quote_string).with(model_class.table_name).and_return("\"#{model_class.table_name}\"")
+            expect(stub_connection).to(
+              receive(:select_one).with(<<~EOS)
+                SELECT CCSA.character_set_name, CCSA.collation_name
+                FROM information_schema.`TABLES` T, information_schema.`COLLATION_CHARACTER_SET_APPLICABILITY` CCSA
+                WHERE CCSA.collation_name = T.table_collation AND
+                      T.table_schema = "test_database" AND
+                      T.table_name = "#{model_class.table_name}";
+              EOS
+              .and_return({ "character_set_name" => "utf8", "collation_name" => "utf8_general" })
+            )
+            allow(model_class).to receive(:connection).and_return(stub_connection)
+          end
+        end
+
+        subject { described_class.for_model(model_class) }
+        it { should eq(described_class.new(model_class.table_name, { charset: "utf8", collation: "utf8_general" })) }
+      end
+    end
+  end
+end

data/spec/lib/generators/declare_schema/migration/migrator_spec.rb

@@ -43,6 +43,34 @@ module Generators
           end
         end
 
+        describe '#default_charset' do
+          subject { described_class.default_charset }
+
+          context 'when not explicitly set' do
+            it { should eq(:utf8mb4) }
+          end
+
+          context 'when explicitly set' do
+            before { described_class.default_charset = :utf8 }
+            after  { described_class.default_charset = described_class::DEFAULT_CHARSET }
+            it     { should eq(:utf8) }
+          end
+        end
+
+        describe '#default_collation' do
+          subject { described_class.default_collation }
+
+          context 'when not explicitly set' do
+            it { should eq(:utf8mb4_general) }
+          end
+
+          context 'when explicitly set' do
+            before { described_class.default_collation = :utf8mb4_general_ci }
+            after  { described_class.default_collation = described_class::DEFAULT_COLLATION }
+            it     { should eq(:utf8mb4_general_ci) }
+          end
+        end
+
         describe 'load_rails_models' do
           before do
             expect(Rails.application).to receive(:eager_load!)

data/spec/spec_helper.rb

@@ -4,7 +4,11 @@ require "bundler/setup"
 require "declare_schema"
 require "climate_control"
 
+require_relative "./support/acceptance_spec_helpers"
+
 RSpec.configure do |config|
+  config.include AcceptanceSpecHelpers
+
   # Enable flags like --only-failures and --next-failure
   config.example_status_persistence_file_path = ".rspec_status"
 

data/spec/support/acceptance_spec_helpers.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module AcceptanceSpecHelpers
+  def generate_model(model_name, *fields)
+    Rails::Generators.invoke('declare_schema:model', [model_name, *fields])
+  end
+
+  def generate_migrations(*flags)
+    Rails::Generators.invoke('declare_schema:migration', flags)
+  end
+
+  def expect_model_definition_to_eq(model, expectation)
+    expect_file_to_eq("#{TESTAPP_PATH}/app/models/#{model}.rb", expectation)
+  end
+
+  def expect_test_definition_to_eq(model, expectation)
+    expect_file_to_eq("#{TESTAPP_PATH}/test/models/#{model}_test.rb", expectation)
+  end
+
+  def expect_test_fixture_to_eq(model, expectation)
+    expect_file_to_eq("#{TESTAPP_PATH}/test/fixtures/#{model}.yml", expectation)
+  end
+
+  def expect_file_to_eq(file_path, expectation)
+    expect(File.exist?(file_path)).to be_truthy
+    expect(File.read(file_path)).to eq(expectation)
+  end
+
+  def clean_up_model(model)
+    system("rm -rf #{TESTAPP_PATH}/app/models/#{model}.rb #{TESTAPP_PATH}/test/models/#{model}.rb #{TESTAPP_PATH}/test/fixtures/#{model}.rb")
+  end
+
+  def load_models
+    Rails.application.config.autoload_paths += ["#{TESTAPP_PATH}/app/models"]
+    $LOAD_PATH << "#{TESTAPP_PATH}/app/models"
+  end
+
+  def migrate_up(expected_value)
+    MigrationUpEquals.new(expected_value)
+  end
+
+  def migrate_down(expected_value)
+    MigrationDownEquals.new(expected_value)
+  end
+
+  class MigrationUpEquals < RSpec::Matchers::BuiltIn::Eq
+    def matches?(subject)
+      super(subject[0])
+    end
+  end
+
+  class MigrationDownEquals < RSpec::Matchers::BuiltIn::Eq
+    def matches?(subject)
+      super(subject[1])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: declare_schema
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0.pre.1
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-02 00:00:00.000000000 Z
+date: 2020-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -32,7 +32,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".dependabot/config.yml"
+- ".github/dependabot.yml"
 - ".github/workflows/gem_release.yml"
 - ".gitignore"
 - ".rspec"
@@ -59,7 +59,9 @@ files:
 - lib/declare_schema/field_declaration_dsl.rb
 - lib/declare_schema/model.rb
 - lib/declare_schema/model/field_spec.rb
-- lib/declare_schema/model/index_spec.rb
+- lib/declare_schema/model/foreign_key_definition.rb
+- lib/declare_schema/model/index_definition.rb
+- lib/declare_schema/model/table_options_definition.rb
 - lib/declare_schema/railtie.rb
 - lib/declare_schema/version.rb
 - lib/generators/declare_schema/migration/USAGE
@@ -76,15 +78,18 @@ files:
 - spec/lib/declare_schema/generator_spec.rb
 - spec/lib/declare_schema/interactive_primary_key_spec.rb
 - spec/lib/declare_schema/migration_generator_spec.rb
+- spec/lib/declare_schema/model/index_definition_spec.rb
+- spec/lib/declare_schema/model/table_options_definition_spec.rb
 - spec/lib/declare_schema/prepare_testapp.rb
 - spec/lib/generators/declare_schema/migration/migrator_spec.rb
 - spec/spec_helper.rb
+- spec/support/acceptance_spec_helpers.rb
 - test_responses.txt
 homepage: https://github.com/Invoca/declare_schema
 licenses: []
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -100,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Database migration generator for Rails
 test_files: []

data/.dependabot/config.yml

@@ -1,10 +0,0 @@
----
-version: 1
-update_configs:
-- package_manager: "ruby:bundler"
-  directory: "/"
-  update_schedule: "weekly"
-  version_requirement_updates: "off"
-  commit_message:
-    prefix: "No-Jira"
-    include_scope: true

data/lib/declare_schema/model/index_spec.rb

@@ -1,175 +0,0 @@
-# frozen_string_literal: true
-
-module DeclareSchema
-  module Model
-    class IndexSpec
-      include Comparable
-
-      attr_reader :table, :fields, :explicit_name, :name, :unique, :where
-
-      class IndexNameTooLongError < RuntimeError; end
-
-      PRIMARY_KEY_NAME = "PRIMARY_KEY"
-      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
-        def for_model(model, old_table_name = nil)
-          t = old_table_name || model.table_name
-          connection = model.connection.dup
-          # TODO: Change below to use prepend
-          class << connection              # defeat Rails code that skips the primary keys by changing their name to PRIMARY_KEY_NAME
-            def each_hash(result)
-              super do |hash|
-                if hash[:Key_name] == "PRIMARY"
-                  hash[:Key_name] = PRIMARY_KEY_NAME
-                end
-                yield hash
-              end
-            end
-          end
-          connection.indexes(t).map do |i|
-            new(model, i.columns, name: i.name, unique: i.unique, where: i.where, table_name: old_table_name) unless model.ignore_indexes.include?(i.name)
-          end.compact
-        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
-          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
-
-    class ForeignKeySpec
-      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 ||=
-          options[:class_name]&.is_a?(Class) &&
-          options[:class_name].respond_to?(:table_name) &&
-          options[:class_name]&.table_name
-        @parent_table_name ||=
-          options[:class_name]&.constantize &&
-          options[:class_name].constantize.respond_to?(:table_name) &&
-          options[:class_name].constantize.table_name ||
-          foreign_key.gsub(/_id/, '').camelize.constantize.table_name
-      end
-
-      attr_writer :parent_table_name
-
-      def to_add_statement(_ = true)
-        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 to_key
-        @key ||= [@child_table, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
-      end
-
-      def hash
-        to_key.hash
-      end
-
-      def <=>(rhs)
-        to_key <=> rhs.to_key
-      end
-
-      alias eql? ==
-    end
-  end
-end