declare_schema 0.3.0.pre.1 → 0.4.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/generators/declare_schema/migration/migrator_spec.rb

@@ -36,6 +36,36 @@ module Generators
             end
           end
         end
+
+        describe '#before_generating_migration' do
+          it 'requires a block be passed' do
+            expect { described_class.before_generating_migration }.to raise_error(ArgumentError, 'A block is required when setting the before_generating_migration callback')
+          end
+        end
+
+        describe 'load_rails_models' do
+          before do
+            expect(Rails.application).to receive(:eager_load!)
+            expect(Rails::Engine).to receive(:subclasses).and_return([])
+          end
+
+          subject { described_class.new.load_rails_models }
+
+          context 'when a before_generating_migration callback is configured' do
+            let(:dummy_proc) { -> {} }
+
+            before do
+              described_class.before_generating_migration(&dummy_proc)
+              expect(dummy_proc).to receive(:call).and_return(true)
+            end
+
+            it { should be_truthy }
+          end
+
+          context 'when no before_generating_migration callback is configured' do
+            it { should be_nil }
+          end
+        end
       end
     end
   end

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.pre.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Invoca Development adapted from hobo_fields by Tom Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-30 00:00:00.000000000 Z
+date: 2020-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -59,7 +59,8 @@ 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/railtie.rb
 - lib/declare_schema/version.rb
 - lib/generators/declare_schema/migration/USAGE
@@ -76,9 +77,11 @@ 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/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: []

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