foreign_key_checker 0.1.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 932660f1dc1e1054ce608b324b8eb2b9dda2f3200b9339106677d7ebf1297b87
-  data.tar.gz: bf7e22d072393fafe2b3bd65639150448886efd3c5cdd95a3a4617cd4a99023f
+  metadata.gz: cf9685280dd2c9ad8232c3b4fe7d4f72dcc56ccdbbaf0b55d826792196185f05
+  data.tar.gz: de9a1d21793299c0df12e92b09fd2661b160d9794d6bb01a7080478fecc3db96
 SHA512:
-  metadata.gz: 2280e4cff60369551661dc1999d11cdfa8c87b994f68360b6c09c05c2acb7619282f4435d0272ef6b2205b56553d14cc401410dd13d05eb1fdb2f224aff07ff5
-  data.tar.gz: 1fbe7b6fd37d6f97f75c485085c81121213e4a9b450fc8aba300deaabb09f43cdea41899cf6292d4365360be0cd61f327e5415554bf1e5775d28915cba43571d
+  metadata.gz: 7f3b6138b99b780ed15ab03c43c0745bfc9511089e4fe0b4bb29cc962d232f7d942d3e314dc56bc8422e193631872d7415a5a28251281fad1bca704fb3c2ab6b
+  data.tar.gz: d7c3c677d063a6e2210d3627caac91431024e940b44e4e2b33c912f48c532a662c81678a1f5aa32f8cccffe19c3bdf0fbd7e10c13796f129de2dc9c60044705d

data/README.md

@@ -5,6 +5,13 @@ This gem checks `belongs_to` ActiveRecord relations. It finds
 3. broken relations: if you try to join such relation (example: `City.joins(:country)`), there is an exception.
 
 ## Usage
+Generate migration to fix foreign key problems
+```bash
+bundle exec rails generate foreign_key_checker:migration
+```
+
+
+Print information about foreign key problems
 ```bash
 bundle exec rake foreign_key_check
 ```
@@ -16,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/Rakefile

@@ -4,16 +4,6 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'ForeignKeyChecker'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.md')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
 require 'bundler/gem_tasks'
 
 require 'rake/testtask'

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,12 +40,30 @@ 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
+    attr_reader :scope
     def message
       "There is no foreign_key for relation #{human_relation}\n"
     end
+
+    def migration
+      "add_foreign_key :#{from_table}, :#{to_table}#{
+        ", column: :#{from_column}" if from_column.to_s != "#{to_table.singularize}_id"
+      }#{
+        ", primary_key: :#{to_column}" if to_column.to_s != 'id'
+      }"
+    end
+
+    def to_zombie
+      ZombieResult.new(scope: scope, model: model, association: association)
+    end
   end
 
   class IndexResult < Result
@@ -59,7 +83,26 @@ module ForeignKeyChecker
       from_c = model.connection.quote_column_name(from_column)
       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_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})"
+    end
+
+    def set_null_sql
+      from_t = model.connection.quote_table_name(from_table)
+      from_c = model.connection.quote_column_name(from_column)
+      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})"
+    end
+
+    def set_null_migration
+      "execute('#{set_null_sql}')"
+    end
+
+    def migration(set_null: false)
+      return set_null_migration if set_null
+      "execute('#{delete_sql}')"
     end
 
     def message
@@ -120,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
@@ -141,10 +201,12 @@ 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
+          association: association,
+          scope: scope,
         )
       end
 
@@ -154,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,
@@ -162,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|
@@ -169,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/railtie.rb

@@ -3,5 +3,8 @@ module ForeignKeyChecker
     rake_tasks do
       load 'tasks/foreign_key_checker_tasks.rake'
     end
+    generators do
+      require 'generators/foreign_key_checker/migration/migration_generator.rb'
+    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.1.1'
+  VERSION = '0.4.0'
 end

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

@@ -0,0 +1,29 @@
+require 'rails/generators/active_record'
+
+module ForeignKeyChecker
+  module Generators
+    class MigrationGenerator < ActiveRecord::Generators::Base
+      desc "generates the necessary migrations to fix foreign_key problems"
+      argument :name, type: :string, default: 'FixForeignKeys'
+
+      source_root File.expand_path('templates', __dir__)
+
+      def create_migrations
+        @class_name = name.camelcase.tr(':', '')
+        file_name = name.underscore.tr('/', '_')
+        @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) unless @behavior == :revoke
+        if @behavior == :revoke
+          @file_suffix = "_v#{@done}" if @done > 1
+          @class_suffix = "V#{@done}" if @done > 1
+        else
+          @file_suffix = "_v#{@done + 1}" if @done > 0
+          @class_suffix = "V#{@done + 1}" if @done > 0
+        end
+        migration_template 'migrations/fix_foreign_keys.rb.erb', "db/migrate/#{file_name}#{@file_suffix}.rb"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+class <%= @class_name %><%= @class_suffix %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version.to_s %>]
+  def change
+<% @checks[:foreign_keys].each do |fk| %>
+    reversible do |dir|
+      dir.up do
+<% 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 %>
+<% end %>
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreign_key_checker
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.4.0
 platform: ruby
 authors:
 - AnatolyShirykalov
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-10-22 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,15 +147,20 @@ 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
 - lib/tasks/foreign_key_checker_tasks.rake
 homepage: https://gitlab.com/pipocavsobake/foreign_key_checker
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -72,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: []