foreign_key_checker 0.2.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b355b8130d2225136101b32202f457ee9615c33621730fa693fcbcb969af3fcf
-  data.tar.gz: ee8b977be65abc39da0914c804f612bb2fb2a33a98a46c922eedde3866147da1
+  metadata.gz: a7420be9666625e34337a8a40eefd53f36acc704b2e222d563bd5811d9b5cc7b
+  data.tar.gz: 5abb9fc0b244a85a61022fe24f7810cb39c497197caa8c526d5099fb043add9e
 SHA512:
-  metadata.gz: 8f34d020417ddcaefc15a6faec34ffb495f6383157104b660f28013f85a57d8a390cee15c47613ffed64a884ffc581c4c0c5557c97a36d9e2fadf0ff54021d7a
-  data.tar.gz: a4b0f8032dc6adc78f4780c7c939acc661bb2e9dde713cddee43a5080f59e2882a1433550964f26abb4120491752a83e596f5cc37821561c6ba118cd52f2ad16
+  metadata.gz: 76a2abcb77030614a6c0a7b9c8951273796ca1ed09ef0c07ee75ec0e222a7bd8ad636d1409ee3e852e9cdfb37c93a7c8f4dee7ce433ade8a6c842a46a55ee95f
+  data.tar.gz: 400ef91dba5578aa3e84b96875a2317066501ec8b49994c9287606e5c77e8e57b02f09d0860d38fab465d3e90c4754e43a39e0d1abda4a86be46f200821bdd65

data/README.md

@@ -23,6 +23,12 @@ ForeignKeyChecker.check.each do |key, result|
 end
 ```
 
+Get general information about foreign keys
+```ruby
+ForeignKeyChecker::Utils.get_foreign_keys_hash
+# =>  {"users"=>[#<ForeignKeyChecker::Utils::Result:0x00005645e51756e8 @from_table="user_rating_changes", @from_column="user_id", @to_table="users", @to_column="id">]}
+```
+
 ## Installation
 Add this line to your application's Gemfile:
 

data/lib/foreign_key_checker.rb

@@ -1,6 +1,12 @@
 require "foreign_key_checker/railtie"
+require 'foreign_key_checker/utils'
+module ForeignKeyChecker::Checkers
+end
+require 'foreign_key_checker/checkers/relations'
+require 'foreign_key_checker/checkers/tables'
 
 module ForeignKeyChecker
+  class TypeMismatch < StandardError; end
   class Result
     attr_reader :model, :association
     def initialize(data)
@@ -34,6 +40,11 @@ module ForeignKeyChecker
     def inspect
       "#<#{self.class.name}:#{self.object_id} #{message}>"
     end
+
+    def nullable?
+      model.columns_hash[from_column.to_s].null
+    end
+
   end
 
   class ForeignKeyResult < Result
@@ -73,7 +84,7 @@ module ForeignKeyChecker
       to_t = model.connection.quote_table_name(to_table)
       to_c = model.connection.quote_column_name(to_column)
       #"DELETE #{from_t} FROM #{from_t}.#{from_c} LEFT OUTER JOIN #{to_t} ON #{to_t}.#{to_c} = #{from_t}.#{from_c} WHERE #{to_t}.#{to_c} IS NULL"
-      "DELETE FROM #{from_t} WHERE #{from_c} IS NOT NULL AND #{from_c} NOT IN (SELECT #{to_c} FROM #{to_t})"
+      "DELETE FROM #{from_t} WHERE #{from_c} IS NOT NULL AND #{from_c} NOT IN (SELECT * FROM (SELECT #{to_c} FROM #{to_t}) AS t )"
     end
 
     def set_null_sql
@@ -82,7 +93,7 @@ module ForeignKeyChecker
       to_t = model.connection.quote_table_name(to_table)
       to_c = model.connection.quote_column_name(to_column)
       #"UPDATE #{from_t} SET #{from_t}.#{from_c} = NULL FROM #{from_t} LEFT OUTER JOIN #{to_t} ON #{to_t}.#{to_c} = #{from_t}.#{from_c} WHERE #{to_t}.#{to_c} IS NULL"
-      "UPDATE #{from_t} SET #{from_c} = NULL WHERE #{from_c} IS NOT NULL AND #{from_c} NOT IN (SELECT #{to_c} FROM #{to_t})"
+      "UPDATE #{from_t} SET #{from_c} = NULL WHERE #{from_c} IS NOT NULL AND #{from_c} NOT IN (SELECT * FROM (SELECT #{to_c} FROM #{to_t}) AS t )"
     end
 
     def set_null_migration
@@ -152,15 +163,32 @@ module ForeignKeyChecker
 
     end
 
+    def check_types(model, association)
+      type_from = model.columns_hash[association.foreign_key.to_s].sql_type
+      type_to = association.klass.columns_hash[association.klass.primary_key.to_s].sql_type
+      raise TypeMismatch, "TypeMissMatch for relation #{model}##{association.name} #{type_from} != #{type_to}" if type_from != type_to
+    end
+
     def check_foreign_key_bt_association(model, association)
       return if model.name.starts_with?('HABTM_')
-      related = association.klass
+      begin
+        related = association.klass
+      rescue NameError => error
+        @result[:broken] << BrokenRelationResult.new(
+          model: model,
+          association: association,
+          error: error,
+        )
+        return
+      end
 
       column_name = model.connection.quote_column_name(association.foreign_key)
       scope = model.left_outer_joins(association.name).where(
         "#{related.quoted_table_name}.#{related.quoted_primary_key} IS NULL AND #{model.quoted_table_name}.#{column_name} IS NOT NULL"
       )
 
+      check_types(model, association)
+
       if zombies
         number = scope.count
         if number > 0
@@ -173,7 +201,8 @@ module ForeignKeyChecker
         end
       end
 
-      if foreign_keys && !model.connection.foreign_key_exists?(model.table_name, related.table_name)
+      if foreign_keys && !model.connection.foreign_key_exists?(model.table_name, related.table_name, column: association.foreign_key, primary_key: related.primary_key)
+        scope.first
         @result[:foreign_keys] << ForeignKeyResult.new(
           model: model,
           association: association,
@@ -187,7 +216,7 @@ module ForeignKeyChecker
           association: association,
         )
       end
-    rescue ActiveRecord::InverseOfAssociationNotFoundError, ActiveRecord::StatementInvalid => error
+    rescue ActiveRecord::InverseOfAssociationNotFoundError, ActiveRecord::StatementInvalid, TypeMismatch => error
       @result[:broken] << BrokenRelationResult.new(
         model: model,
         association: association,
@@ -195,6 +224,13 @@ module ForeignKeyChecker
       )
     end
 
+    def already_done_fk?(model, association)
+      @_done ||= {}
+      ret = @_done[[model.table_name, association.foreign_key]]
+      @_done[[model.table_name, association.foreign_key]] = true
+      ret
+    end
+
     def check
       Rails.application.eager_load!
       ActiveRecord::Base.descendants.each do |model|
@@ -202,11 +238,13 @@ module ForeignKeyChecker
         next if excluded_specification?(model)
 
         model.reflect_on_all_associations(:belongs_to).each do |association|
+
           if association.options[:polymorphic] && polymorphic_zombies
             check_polymorphic_bt_association(model, association)
             next
           end
 
+          next if already_done_fk?(model, association)
           check_foreign_key_bt_association(model, association)
         end
       end

data/lib/foreign_key_checker/checkers/relations.rb

@@ -0,0 +1,122 @@
+require 'foreign_key_checker/utils'
+
+module ForeignKeyChecker::Checkers::Relations
+  class Result
+    attr_reader :ok, :model, :association, :fk, :error, :table
+    def initialize(**args)
+      %i[model association ok error fk table].each do |key|
+        instance_variable_set("@#{key}", args[key])
+      end
+    end
+  end
+  class JoinResult < Result
+    def message
+      "expect { #{model.to_s}.joins(:#{association.name}).first }.to_not raise_exception" if !ok
+    end
+  end
+  class ErrorResult < Result
+    def message
+      "`#{model.to_s}##{association.name}` is broken\n#{error.class.to_s}\n#{error.message}\n#{error.backtrace.join("\n")}" if !ok
+    end
+  end
+  class HasOneOrManyResult < Result
+    def message
+      "expected has_many or has_one association for #{fk.inspect}"
+    end
+  end
+  class HasOneOrManyDependentResult < Result
+    def message
+      "expected has_many or has_one association with dependent option for #{fk.inspect}"
+    end
+  end
+  class NoModelResult < Result
+    def message
+      "expected find model for table #{table}"
+    end
+  end
+  def self.check_by_join
+    Rails.application.eager_load!
+    models = ActiveRecord::Base.descendants
+    models.each_with_object([]) do |model, results|
+      next if model.to_s.include?('HABTM')
+      model.reflect_on_all_associations.each do |association|
+        begin
+          next if association.options[:polymorphic]
+          next if association.scope && association.scope.is_a?(Proc) && association.scope.arity > 0
+          next if model.connection_specification_name != association.klass.connection_specification_name
+
+          model.joins(association.name).first
+          result = JoinResult.new(model: model, association: association, ok: true)
+          yield result if block_given?
+          results << result
+        rescue => e
+          result = JoinResult.new(model: model, association: association, ok: false, error: e)
+          yield result if block_given?
+          results << result
+        end
+      end
+    end
+  end
+
+  def self.check_by_fks
+    Rails.application.eager_load!
+    models = ActiveRecord::Base.descendants.group_by(&:table_name)
+    check_relation = proc do |model, fk, association|
+      begin
+        pk = association.options[:primary_key] || model.primary_key
+        association.klass.table_name.to_s == fk.from_table.to_s && association.foreign_key.to_s == fk.from_column.to_s && pk.to_s == fk.to_column.to_s
+      rescue => e
+        if block_given?
+          yield ErrorResult.new(model: model, association: association, fk: fk, ok: false, error: e)
+        else
+          p model
+          p fk
+          p association
+          raise e
+        end
+      end
+    end
+    ForeignKeyChecker::Utils.get_foreign_keys_hash.each do |to_table, fks|
+      fks.each do |fk|
+        unless models.key?(fk.to_table)
+          result = NoModelResult.new(ok: false, table: fk.to_table)
+          if block_given?
+            yield result
+          else
+            raise result.message
+          end
+          next
+        end
+        models[fk.to_table].each do |model|
+          next if model.connection_specification_name != 'primary'
+          ok = false
+          ok ||= !!model.reflect_on_all_associations(:has_many).find do |association|
+            check_relation.call(model, fk, association)
+          end
+          ok ||= !!model.reflect_on_all_associations(:has_one).find do |association|
+            check_relation.call(model, fk, association)
+          end
+          if block_given?
+            yield HasOneOrManyResult.new(model: model, fk: fk, ok: ok)
+          else
+            raise "expected has_many or has_one association for #{fk.inspect}" if !ok
+          end
+          next if !ok
+
+          dep = false
+          dep ||= !!model.reflect_on_all_associations(:has_many).find do |association|
+            check_relation.call(model, fk, association) && association.options[:dependent]
+          end
+          dep ||= !!model.reflect_on_all_associations(:has_one).find do |association|
+            check_relation.call(model, fk, association) && association.options[:dependent]
+          end
+          if block_given?
+            yield HasOneOrManyDependentResult.new(model: model, fk: fk, ok: ok)
+          else
+            raise "expected has_many or has_one association with dependent option for #{fk.inspect}" if !dep
+          end
+        end
+      end
+    end
+  end
+end

data/lib/foreign_key_checker/checkers/tables.rb

@@ -0,0 +1,88 @@
+require 'foreign_key_checker/utils'
+
+# Стоит использовать в тех случаях, когда подключается rails к уже существующей базе
+# Можно проверить, для каких таблиц всё ещё нет ActiveRecord-моделей
+module ForeignKeyChecker::Checkers::Tables
+  SPECIAL_TABLES = ['schema_migrations', 'ar_internal_metadata'].freeze
+  # Список таблиц, не описанных моделями (в том числе HABTM-моделями, сгенерированными автоматически rails)
+  def self.without_models(specification_name = 'primary')
+    Rails.application.eager_load!
+
+    actual_tables = ForeignKeyChecker::Utils.get_tables
+    actual_tables - modelised_tables(specification_name) - SPECIAL_TABLES
+  end
+
+  def self.without_foreign_keys(specification_name = 'primary')
+    all_fks = ForeignKeyChecker::Utils.get_foreign_keys
+    results = []
+    models(specification_name).each do |model|
+      model.column_names.each do |column_name|
+        next unless column_name.ends_with?('_id')
+        next if all_fks.find { |fk| fk.from_table = model.table_name && fk.from_column == column_name }
+
+        table_name = column_name.delete_suffix('_id')
+        results << ["#{table_name}.#{column_name}"]
+      end
+    end
+  end
+
+  def self.modelised_tables(specification_name = 'primary')
+    models(specification_name).map(&:table_name)
+  end
+
+  def self.models(specification_name = 'primary')
+    ActiveRecord::Base.descendants.select do |model|
+      model.connection_specification_name == specification_name
+    end
+  end
+
+
+  def self.common_tables
+    ForeignKeyChecker::Utils.get_tables - SPECIAL_TABLES
+  end
+
+  class Result
+    attr_reader :table_name, :foreign_keys, :internal_references
+    def initialize(**args)
+      %i[table_name foreign_keys internal_references].each do |key|
+        instance_variable_set("@#{key}", args[key] || args[key].to_s)
+      end
+    end
+
+    def ok?
+      foreign_keys.blank?
+    end
+
+    def referenced?
+      foreign_keys.present?
+    end
+
+    def ext_ref?
+      !internal_references
+    end
+
+  end
+
+  def self.check
+    tables = without_models
+    fks = ForeignKeyChecker::Utils.get_foreign_keys_hash
+    fks.default = []
+    tables.map do |table|
+      Result.new(
+        table_name: table,
+        foreign_keys: fks[table] || [],
+        internal_references: (fks[table].map(&:from_table) - tables).empty?,
+      )
+    end
+  end
+
+  # TODO вспомнить, что я тут задумал
+  def self.ordered(results = check)
+    return results if results.size == 0
+    oks = results.select(&:ok?)
+    if oks.size == 0
+      raise "no ok"
+    end
+  end
+
+end

data/lib/foreign_key_checker/utils.rb

@@ -0,0 +1,126 @@
+module ForeignKeyChecker
+  module Utils
+    class Result
+      attr_reader :from_table, :to_table, :from_column, :to_column
+      def initialize(args)
+        args.each { |k, v| instance_variable_set("@#{k}", v) }
+      end
+    end
+    class UnsupportedConnectionAdapter < StandardError; end
+    def self.get_foreign_keys(model = ActiveRecord::Base)
+      adapter = model.connection_config[:adapter]
+      raise(UnsupportedConnectionAdapter, adapter) unless %w[postgresql mysql2 sqlserver sqlite3].include?(adapter)
+
+      connection = model.connection
+      send("get_#{adapter}_foreign_keys", connection)
+    end
+
+    def self.get_foreign_keys_hash(model = ActiveRecord::Base)
+      get_foreign_keys(model).to_a.each_with_object({}) do |datum, obj|
+        obj[datum.to_table] ||= []
+        obj[datum.to_table].push(datum)
+      end
+    end
+
+    def self.get_sqlite3_foreign_keys(connection)
+      res = connection.select_all <<-SQL
+        SELECT
+          m.name as from_table,
+          p."from" as from_column,
+          p."table" as to_table,
+          p."to" as to_column
+        FROM
+          sqlite_master m
+          JOIN pragma_foreign_key_list(m.name) p ON 1
+        WHERE m.type = 'table'
+        ORDER BY m.name ;
+      SQL
+      res.to_a.map{|i| Result.new(i) }
+    end
+
+    def self.get_mysql2_foreign_keys(connection)
+      res = connection.select_all <<-SQL
+        SELECT
+          fks.TABLE_NAME AS from_table,
+          fks.COLUMN_NAME AS from_column,
+          fks.REFERENCED_TABLE_NAME AS to_table,
+          fks.REFERENCED_COLUMN_NAME AS to_column
+        FROM information_schema.KEY_COLUMN_USAGE AS fks
+        INNER JOIN information_schema.REFERENTIAL_CONSTRAINTS rules ON rules.CONSTRAINT_NAME = fks.CONSTRAINT_NAME
+        WHERE
+          fks.CONSTRAINT_SCHEMA = DATABASE()
+          AND rules.CONSTRAINT_SCHEMA = DATABASE();
+      SQL
+      res.to_a.map{|i| Result.new(i) }
+    end
+
+    def self.get_postgresql_foreign_keys(connection)
+      res = connection.select_all <<-SQL
+        SELECT
+          tc.table_name AS from_table,
+          kcu.column_name AS from_column,
+          ccu.table_name AS to_table,
+          ccu.column_name AS to_column
+        FROM
+          information_schema.table_constraints AS tc
+          JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage AS ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+        WHERE tc.constraint_type = 'FOREIGN KEY';
+      SQL
+      res.to_a.map{ |i| Result.new(i) }
+    end
+
+    def self.get_sqlserver_foreign_keys(connection)
+      res = connection.select_all <<-SQL
+        SELECT  obj.name AS FK_NAME,
+            sch.name AS [schema_name],
+            tab1.name AS [from_table],
+            col1.name AS [from_column],
+            tab2.name AS [to_table],
+            col2.name AS [to_column]
+        FROM sys.foreign_key_columns fkc
+        INNER JOIN sys.objects obj
+            ON obj.object_id = fkc.constraint_object_id
+        INNER JOIN sys.tables tab1
+            ON tab1.object_id = fkc.parent_object_id
+        INNER JOIN sys.schemas sch
+            ON tab1.schema_id = sch.schema_id
+        INNER JOIN sys.columns col1
+            ON col1.column_id = parent_column_id AND col1.object_id = tab1.object_id
+        INNER JOIN sys.tables tab2
+            ON tab2.object_id = fkc.referenced_object_id
+        INNER JOIN sys.columns col2
+            ON col2.column_id = referenced_column_id AND col2.object_id = tab2.object_id
+      SQL
+      res.to_a.map { |i| Result.new(i) }
+    end
+
+    def self.get_tables(model = ActiveRecord::Base)
+      adapter = model.connection_config[:adapter]
+      raise(UnsupportedConnectionAdapter, adapter) unless %w[postgresql mysql2 sqlite3 sqlserver].include?(adapter)
+
+      connection = model.connection
+      send("get_#{adapter}_tables", connection)
+    end
+
+    def self.get_mysql2_tables(connection)
+      connection.select_all("SELECT table_name FROM information_schema.tables WHERE TABLE_SCHEMA = '#{connection.current_database}'").to_a.pluck('table_name')
+    end
+
+    def self.get_postgresql_tables(connection)
+      connection.select_all("SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname != 'pg_catalog' AND schemaname != 'information_schema'").to_a.pluck('tablename')
+    end
+
+    def self.get_sqlite3_tables(connection)
+      connection.select_all("SELECT name FROM sqlite_master WHERE type='table'").to_a.pluck('name') - ['sqlite_sequence']
+    end
+
+    def self.get_sqlserver_tables(connection)
+      connection.tables
+    end
+  end
+end

data/lib/foreign_key_checker/version.rb

@@ -1,3 +1,3 @@
 module ForeignKeyChecker
-  VERSION = '0.2.0'
+  VERSION = '0.4.1'
 end

data/lib/generators/foreign_key_checker/migration/migration_generator.rb

@@ -14,7 +14,7 @@ module ForeignKeyChecker
         @done = Dir.glob(Rails.root.join('db', 'migrate', '*.rb')).map do |path|
           File.open(path).readlines.find { |line| line.include?('ActiveRecord::Migration') && line.include?(@class_name) }
         end.compact.size
-        @checks = ForeignKeyChecker.check(zombies: false, indexes: false) unless @behavior == :revoke
+        @checks = ForeignKeyChecker.check(zombies: false) unless @behavior == :revoke
         if @behavior == :revoke
           @file_suffix = "_v#{@done}" if @done > 1
           @class_suffix = "V#{@done}" if @done > 1

data/lib/generators/foreign_key_checker/migration/templates/migrations/fix_foreign_keys.rb.erb

@@ -3,8 +3,13 @@ class <%= @class_name %><%= @class_suffix %> < ActiveRecord::Migration[<%= Activ
 <% @checks[:foreign_keys].each do |fk| %>
     reversible do |dir|
       dir.up do
-        # <%= fk.to_zombie.migration(set_null: true) %>
+<% if fk.nullable? %>
+        # <%= fk.to_zombie.migration %>
+        <%= fk.to_zombie.migration(set_null: true) %>
+<% else %>
+        # column <%= fk.from_column %> can't be set to null
         <%= fk.to_zombie.migration %>
+<% end %>
       end
     end
     <%= fk.migration %>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreign_key_checker
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.1
 platform: ruby
 authors:
 - AnatolyShirykalov
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-24 00:00:00.000000000 Z
+date: 2020-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -38,6 +38,104 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tiny_tds
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-sqlserver-adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: e2mmap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: annotate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Run task to obtain problems with your database
 email:
 - pipocavsobake@gmail.com
@@ -49,7 +147,10 @@ files:
 - README.md
 - Rakefile
 - lib/foreign_key_checker.rb
+- lib/foreign_key_checker/checkers/relations.rb
+- lib/foreign_key_checker/checkers/tables.rb
 - lib/foreign_key_checker/railtie.rb
+- lib/foreign_key_checker/utils.rb
 - lib/foreign_key_checker/version.rb
 - lib/generators/foreign_key_checker/migration/migration_generator.rb
 - lib/generators/foreign_key_checker/migration/templates/migrations/fix_foreign_keys.rb.erb
@@ -59,7 +160,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -74,8 +175,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.1.3
+signing_key:
 specification_version: 4
 summary: Find problems with relations in active_record models
 test_files: []