database_consistency 2.0.4 → 3.0.5

data/lib/database_consistency/checkers/validator_checkers/validator_checker.rb

@@ -6,6 +6,10 @@ module DatabaseConsistency
     class ValidatorChecker < BaseChecker
       attr_reader :model, :attribute, :validator
 
+      def self.processor
+        Processors::ValidatorsProcessor
+      end
+
       def initialize(model, attribute, validator)
         super()
         @model = model

data/lib/database_consistency/checkers/validators_fraction_checkers/validators_fraction_checker.rb

@@ -6,6 +6,10 @@ module DatabaseConsistency
     class ValidatorsFractionChecker < BaseChecker
       attr_reader :model, :attribute, :validators
 
+      def self.processor
+        Processors::ValidatorsFractionsProcessor
+      end
+
       def initialize(model, attribute, validators)
         super()
         @model = model

data/lib/database_consistency/configuration.rb

@@ -8,15 +8,16 @@ module DatabaseConsistency
     DEFAULT_PATH = '.database_consistency.yml'
 
     def initialize(file_paths = DEFAULT_PATH)
-      @configuration = existing_configurations(file_paths).then do |existing_paths|
-        if existing_paths.any?
-          puts "Loaded configurations: #{existing_paths.join(', ')}"
-        else
-          puts 'No configurations were provided'
-        end
-        extract_configurations(existing_paths)
+      existing_paths = existing_configurations(file_paths)
+
+      if existing_paths.any?
+        puts "Loaded configurations: #{existing_paths.join(', ')}"
+      else
+        puts 'No configuration files were provided'
       end
 
+      @configuration = extract_configurations(existing_paths)
+
       load_custom_checkers
     end
 

data/lib/database_consistency/debug_context.rb

@@ -30,7 +30,6 @@ module DatabaseConsistency
       store.each do |key, value|
         destination.puts("#{key}: #{value}")
       end
-      clear!
     end
 
     private

data/lib/database_consistency/files_helper.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  # The module contains file system helper methods for locating project source files.
+  module FilesHelper
+    module_function
+
+    # Returns all unique project source file paths (non-gem Ruby files from loaded constants).
+    # Memoized so the file system walk happens once per database_consistency run.
+    def project_source_files
+      @project_source_files ||=
+        if Module.respond_to?(:const_source_location)
+          collect_source_files
+        else
+          []
+        end
+    end
+
+    def collect_source_files
+      files = []
+      ObjectSpace.each_object(Module) { |mod| files << source_file_path(mod) }
+      files.compact.uniq
+    end
+
+    def source_file_path(mod)
+      name = mod.name
+      return unless name
+
+      file, = Module.const_source_location(name)
+      return unless file && File.exist?(file)
+      return if excluded_source_file?(file)
+
+      file
+    rescue StandardError, ScriptError
+      nil
+    end
+
+    def excluded_source_file?(file)
+      return true if defined?(Bundler) && file.include?(Bundler.bundle_path.to_s)
+      return true if defined?(Gem) && file.include?(Gem::RUBYGEMS_DIR)
+
+      excluded_by_ruby_stdlib?(file)
+    end
+
+    def excluded_by_ruby_stdlib?(file)
+      return false unless defined?(RbConfig)
+
+      file.include?(RbConfig::CONFIG['rubylibdir']) ||
+        file.include?(RbConfig::CONFIG['bindir']) ||
+        file.include?(RbConfig::CONFIG['sbindir'])
+    end
+  end
+end

data/lib/database_consistency/helper.rb

@@ -2,7 +2,7 @@
 
 module DatabaseConsistency
   # The module contains helper methods
-  module Helper
+  module Helper # rubocop:disable Metrics/ModuleLength
     module_function
 
     def adapter
@@ -49,7 +49,7 @@ module DatabaseConsistency
     def connected?(klass)
       klass.connection
     rescue ActiveRecord::ConnectionNotEstablished
-      puts "#{klass} doesn't have active connection: ignoring"
+      puts "#{klass} does not have an active connection, skipping"
       false
     end
 
@@ -112,10 +112,223 @@ module DatabaseConsistency
       end
     end
 
+    def inclusion_validator_values(validator)
+      value = validator.options[:in]
+
+      if value.is_a?(Proc) && value.arity.zero?
+        value.call
+      else
+        Array.wrap(value)
+      end
+    end
+
+    def btree_index?(index)
+      (index.type.nil? || index.type.to_s == 'btree') &&
+        (index.using.nil? || index.using.to_s == 'btree')
+    end
+
+    def extract_columns(str)
+      case str
+      when Array
+        str.map(&:to_s)
+      when String
+        str.scan(/(\w+)/).flatten
+      when Symbol
+        [str.to_s]
+      else
+        raise "Unexpected type for columns: #{str.class} with value: #{str}"
+      end
+    end
+
     def foreign_key_or_attribute(model, attribute)
       model._reflect_on_association(attribute)&.foreign_key || attribute
     end
 
+    # Returns the normalized WHERE SQL produced by a conditions proc, or nil if
+    # it cannot be determined (complex proc, unsupported AR version, etc.).
+    def conditions_where_sql(model, conditions)
+      sql = model.unscoped.instance_exec(&conditions).to_sql
+      where_part = sql.split(/\bWHERE\b/i, 2).last
+      return nil unless where_part
+
+      normalize_condition_sql(where_part.gsub("#{model.quoted_table_name}.", '').gsub('"', ''))
+    rescue StandardError
+      nil
+    end
+
+    # Builds the effective uniqueness constraint enforced by a validator by
+    # combining its explicit `conditions` proc with implicit guards such as
+    # `allow_nil` / `allow_blank`.
+    def uniqueness_validator_where_sql(model, attribute, validator)
+      conditions_sql = conditions_where_sql(model, validator.options[:conditions])
+      guard_sql = uniqueness_validator_guard_sql(model, attribute, validator)
+
+      sql_parts = [conditions_sql, guard_sql].reject { |part| part.nil? || part == '' }
+      return nil if sql_parts.empty?
+
+      normalize_condition_sql(sql_parts.join(' AND '))
+    end
+
+    # Returns true when validator conditions and index WHERE clause are a valid
+    # pairing: both absent means a match; exactly one present means no match;
+    # when both present the normalized SQL is compared.
+    def conditions_match_index?(model, attribute, validator, index_where)
+      validator_where = uniqueness_validator_where_sql(model, attribute, validator)
+      return true if validator_where.nil? && index_where.blank?
+      return true if index_where.blank? && validator_guard_only?(model, attribute, validator)
+      return false if validator_where.nil? || index_where.blank?
+
+      normalized_where = normalize_condition_sql(index_where)
+      validator_where.casecmp?(normalized_where)
+    end
+
+    # Normalizes SQL predicates into a canonical form so semantically equivalent
+    # Rails validators and database partial indexes can be compared safely.
+    def normalize_condition_sql(sql)
+      sql
+        .to_s
+        .then { |value| strip_outer_parentheses(value) }
+        .then { |value| normalize_sql(value) }
+        .then { |value| normalize_boolean_predicates(value) }
+        .then { |value| normalize_array_any_predicates(value) }
+        .then { |value| normalize_negated_blank_or_nil_predicates(value) }
+        .then { |value| sort_and_clauses(value) }
+    end
+
+    # Applies lightweight SQL normalization without changing the logical meaning.
+    def normalize_sql(sql)
+      # `/::\w+/` removes PostgreSQL casts like `column::text`.
+      normalized_sql = sql.gsub(/::\w+/, '')
+      # `/\(([a-z_][\w.]*)\)/i` unwraps a bare identifier surrounded by
+      # parentheses, e.g. `(internal_name)` -> `internal_name`.
+      normalized_sql = normalized_sql.gsub(/\(([a-z_][\w.]*)\)/i, '\1')
+      # `/\bTRUE\b/i` and `/\bFALSE\b/i` normalize boolean literals to `1` / `0`
+      # so they match SQL generated by Active Record on some adapters.
+      normalized_sql = normalized_sql.gsub(/\bTRUE\b/i, '1').gsub(/\bFALSE\b/i, '0')
+      # `/\s*<>\s*/` rewrites the SQL inequality operator `<>` to `!=`.
+      normalized_sql = normalized_sql.gsub(/\s*<>\s*/, ' != ')
+      # `/\bIS\s+NOT\s+NULL\b/i` normalizes `IS NOT NULL` spacing and casing.
+      normalized_sql = normalized_sql.gsub(/\bIS\s+NOT\s+NULL\b/i, ' IS NOT NULL')
+      # `/\bIS\s+NULL\b/i` normalizes `IS NULL` spacing and casing.
+      normalized_sql = normalized_sql.gsub(/\bIS\s+NULL\b/i, ' IS NULL')
+      # `/ = 't'/` and `/ = 'f'/` normalize PostgreSQL boolean literals stored
+      # as `'t'` / `'f'` inside comparisons.
+      normalized_sql = normalized_sql.gsub(/ = 't'/, ' = 1').gsub(/ = 'f'/, ' = 0')
+      # `/\s+/` collapses any run of whitespace to a single space.
+      normalized_sql = normalized_sql.gsub(/\s+/, ' ')
+      normalized_sql.strip
+    end
+
+    # Repeatedly removes one wrapping layer of parentheses when the whole SQL
+    # fragment is enclosed, e.g. `((foo))` -> `foo`.
+    def strip_outer_parentheses(sql)
+      stripped_sql = sql.strip
+
+      stripped_sql = stripped_sql[1..-2].strip while wrapped_with_parentheses?(stripped_sql)
+
+      stripped_sql
+    end
+
+    # Returns true only when the string is entirely wrapped by one outer pair of
+    # parentheses, not when parentheses close earlier inside the expression.
+    def wrapped_with_parentheses?(sql)
+      return false unless sql.start_with?('(') && sql.end_with?(')')
+
+      depth = 0
+
+      sql[1..-2].each_char do |char|
+        depth = parenthesis_depth(depth, char)
+        return false if depth.negative?
+      end
+
+      depth.zero?
+    end
+
+    # Tracks parenthesis nesting depth character by character.
+    def parenthesis_depth(depth, char)
+      case char
+      when '('
+        depth + 1
+      when ')'
+        depth - 1
+      else
+        depth
+      end
+    end
+
+    # Rewrites shorthand boolean predicates into explicit comparisons so
+    # `flag` and `NOT flag` line up with `flag = true/false`.
+    def normalize_boolean_predicates(sql)
+      normalized_sql = sql.dup
+
+      # Matches a bare negated boolean predicate such as `NOT archived`
+      # appearing at the start of an expression, after `AND` / `OR`, or after
+      # an opening parenthesis, and rewrites it to `archived = 0`.
+      normalized_sql.gsub!(
+        /(^|(?:\bAND\b|\bOR\b|\())\s*NOT\s+([a-z_][\w.]*)\s*(?=$|(?:\bAND\b|\bOR\b|\)))/i
+      ) { "#{Regexp.last_match(1)} #{Regexp.last_match(2)} = 0" }
+
+      # Matches a bare boolean predicate such as `most_recent` appearing in the
+      # same structural positions, and rewrites it to `most_recent = 1`.
+      normalized_sql.gsub!(
+        /(^|(?:\bAND\b|\bOR\b|\())\s*([a-z_][\w.]*)\s*(?=$|(?:\bAND\b|\bOR\b|\)))/i
+      ) { "#{Regexp.last_match(1)} #{Regexp.last_match(2)} = 1" }
+
+      normalized_sql.gsub(/\s+/, ' ').strip
+    end
+
+    # Rewrites PostgreSQL's `= ANY (ARRAY[...])` form into an `IN (...)` form
+    # so it matches the SQL Active Record typically generates for arrays.
+    def normalize_array_any_predicates(sql)
+      sql.gsub(
+        # Matches `column = ANY (ARRAY[...])`, capturing the column name and the
+        # full array payload so it can be converted to `column IN (...)`.
+        /([a-z_][\w.]*)\s*=\s*ANY\s*\(ARRAY\[(.*?)\]\)/i
+      ) { "#{Regexp.last_match(1)} IN (#{Regexp.last_match(2).gsub(/\s+/, ' ').strip})" }
+    end
+
+    # Rewrites negated "blank or nil" predicates into the same shape used by
+    # `allow_blank`-derived guards: `IS NOT NULL AND != ''`.
+    def normalize_negated_blank_or_nil_predicates(sql)
+      sql.gsub(
+        # Matches SQL like `NOT (column = '' OR column IS NULL)` while enforcing
+        # the same column name on both sides via backreference `\1`.
+        /NOT\s+\(\s*\(?([a-z_][\w.]*)\s*=\s*''\s+OR\s+\1\s+IS\s+NULL\)?\s*\)/i
+      ) { "#{Regexp.last_match(1)} IS NOT NULL AND #{Regexp.last_match(1)} != ''" }
+    end
+
+    # Sorts simple `AND` clauses so `a AND b` and `b AND a` normalize to the
+    # same string before comparison.
+    def sort_and_clauses(sql)
+      # Matches `AND` with surrounding whitespace and splits the expression into
+      # comparable clause fragments.
+      clauses = sql.split(/\s+AND\s+/i)
+      return sql if clauses.length == 1
+
+      clauses.map! { |clause| strip_outer_parentheses(clause) }
+      clauses.sort.join(' AND ')
+    end
+
+    # Builds the implicit SQL guard introduced by validator options that skip
+    # nil or blank values instead of validating them.
+    def uniqueness_validator_guard_sql(model, attribute, validator)
+      attribute_name = foreign_key_or_attribute(model, attribute).to_s
+
+      if validator.options[:allow_blank]
+        "#{attribute_name} IS NOT NULL AND #{attribute_name} != ''"
+      elsif validator.options[:allow_nil]
+        "#{attribute_name} IS NOT NULL"
+      end
+    end
+
+    # A validator with only `allow_nil` / `allow_blank` and no explicit
+    # conditions is still satisfied by a full unique index, because the database
+    # constraint is stricter than the validator.
+    def validator_guard_only?(model, attribute, validator)
+      uniqueness_validator_guard_sql(model, attribute, validator).present? &&
+        validator.options[:conditions].nil?
+    end
+
     # @return [String]
     def wrapped_attribute_name(attribute, validator, model)
       attribute = foreign_key_or_attribute(model, attribute)

data/lib/database_consistency/prism_helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  # The module contains Prism AST helper methods for scanning project source files.
+  module PrismHelper
+    module_function
+
+    # Returns a memoized index: {model_name => {column_name => "file:line"}}.
+    # Built once per run by scanning all project source files with Prism (Ruby 3.3+).
+    # Bare find_by calls are resolved to their lexical class/module scope.
+    def find_by_calls_index
+      return {} unless defined?(Prism)
+
+      @find_by_calls_index ||= build_find_by_calls_index
+    end
+
+    def build_find_by_calls_index
+      FilesHelper.project_source_files.each_with_object({}) do |file, index|
+        collector = Checkers::MissingIndexFindByChecker::FindByCollector.new(file)
+        collector.visit(Prism.parse_file(file).value)
+        merge_collector_results(collector.results, index)
+      rescue StandardError
+        nil
+      end
+    end
+
+    def merge_collector_results(results, index)
+      results.each do |(model_key, col), locations|
+        index[model_key] ||= {}
+        if (entry = index[model_key][col])
+          entry[:total_findings_count] += locations.size
+        else
+          index[model_key][col] = { first_location: locations.first, total_findings_count: locations.size }
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/rescue_error.rb

@@ -16,9 +16,9 @@ module DatabaseConsistency
     end
 
     def initialize
-      puts 'Hey, some checks fail with an error, please open an issue on github at https://github.com/djezzzl/database_consistency.'
-      puts "Attach the created file: #{filename}"
-      puts 'Thank you, for your contribution!'
+      puts 'Some checks failed with an error. Please open an issue on GitHub at https://github.com/djezzzl/database_consistency.'
+      puts "Attach the generated file: #{filename}"
+      puts 'Thank you for your contribution!'
       puts '(c) Evgeniy Demin <lawliet.djez@gmail.com>'
     end
 

data/lib/database_consistency/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DatabaseConsistency
-  VERSION = '2.0.4'
+  VERSION = '3.0.5'
 end

data/lib/database_consistency/writers/autofix/migration_base.rb

@@ -10,7 +10,7 @@ module DatabaseConsistency
           file_path = migration_path(migration_name)
 
           if Dir[migration_path_pattern(migration_name)].any?
-            p "Skipping migration #{migration_name} because it already exists"
+            puts "Skipping migration #{migration_name} because it already exists"
           else
             File.write(file_path, migration)
           end

data/lib/database_consistency/writers/autofix_writer.rb

@@ -5,6 +5,8 @@ module DatabaseConsistency
   module Writers
     # The simplest formatter
     class AutofixWriter < BaseWriter
+      UnknownCheckerError = Class.new(StandardError)
+
       SLUG_TO_GENERATOR = {
         association_missing_index: Autofix::AssociationMissingIndex,
         association_missing_null_constraint: Autofix::NullConstraintMissing,
@@ -20,6 +22,29 @@ module DatabaseConsistency
         three_state_boolean: Autofix::NullConstraintMissing
       }.freeze
 
+      class << self
+        def validate_scope!(scope)
+          return if scope.nil?
+
+          known = concrete_checker_names
+          unknown = scope - known
+          return if unknown.empty?
+
+          raise UnknownCheckerError,
+                "unknown checker(s): #{unknown.join(', ')}. Known: #{known.join(', ')}"
+        end
+
+        private
+
+        def concrete_checker_names
+          Checkers::BaseChecker.descendants
+                               .reject { |checker| checker.superclass == Checkers::BaseChecker }
+                               .map(&:checker_name)
+                               .uniq
+                               .sort
+        end
+      end
+
       def write
         unique_generators.each(&:fix!)
       end
@@ -35,7 +60,13 @@ module DatabaseConsistency
       end
 
       def fix?(report)
-        report.status == :fail
+        report.status == :fail && scoped?(report)
+      end
+
+      def scoped?(report)
+        return true if opts.nil?
+
+        opts.include?(report.checker_name)
       end
 
       def generator(report)

data/lib/database_consistency/writers/base_writer.rb

@@ -4,15 +4,16 @@ module DatabaseConsistency
   module Writers
     # The base class for writers
     class BaseWriter
-      attr_reader :results, :config
+      attr_reader :results, :config, :opts
 
-      def initialize(results, config: Configuration.new)
+      def initialize(results, config: Configuration.new, opts: nil)
         @results = results
         @config = config
+        @opts = opts
       end
 
-      def self.write(results, config: Configuration.new)
-        new(results, config: config).write
+      def self.write(results, config: Configuration.new, opts: nil)
+        new(results, config: config, opts: opts).write
       end
     end
   end

data/lib/database_consistency/writers/simple/association_foreign_type_missing_null_constraint.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'association foreign type column should be required in the database'
+          'association foreign type column should be NOT NULL'
         end
 
         def unique_attributes

data/lib/database_consistency/writers/simple/association_missing_index.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'associated model should have proper index in the database'
+          'associated model should have an index in the database'
         end
 
         def unique_attributes

data/lib/database_consistency/writers/simple/association_missing_null_constraint.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'association foreign key column should be required in the database'
+          'association foreign key column should be NOT NULL'
         end
 
         def unique_attributes

data/lib/database_consistency/writers/simple/enum_values_inconsistent_with_ar_enum.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'enum has [%<enum_values>s] values but ActiveRecord enum has [%<declared_values>s] values'
+          'database enum has values [%<enum_values>s] but ActiveRecord enum has values [%<declared_values>s]'
         end
 
         def attributes

data/lib/database_consistency/writers/simple/enum_values_inconsistent_with_inclusion.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'enum has [%<enum_values>s] values but ActiveRecord inclusion validation has [%<declared_values>s] values'
+          'database enum has values [%<enum_values>s] but inclusion validation has values [%<declared_values>s]'
         end
 
         def attributes

data/lib/database_consistency/writers/simple/has_one_missing_unique_index.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'associated model should have proper unique index in the database'
+          'associated model should have a unique index in the database'
         end
 
         def unique_attributes

data/lib/database_consistency/writers/simple/implicit_order_column_missing.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'implicit_order_column is recommended when using uuid column type for primary key'
+          'setting implicit_order_column is recommended when using UUID as the primary key type'
         end
 
         def unique_attributes

data/lib/database_consistency/writers/simple/inconsistent_enum_type.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'enum has %<values_types>s types but column has %<column_type>s type'
+          'enum values have %<values_types>s types but the column has %<column_type>s type'
         end
 
         def attributes

data/lib/database_consistency/writers/simple/inconsistent_types.rb

@@ -7,8 +7,8 @@ module DatabaseConsistency
         private
 
         def template
-          "foreign key (%<fk_name>s) with type (%<fk_type>s) doesn't "\
-          'cover primary key (%<pk_name>s) with type (%<pk_type>s)'
+          'foreign key (%<fk_name>s) with type (%<fk_type>s) does not match '\
+          'primary key (%<pk_name>s) with type (%<pk_type>s)'
         end
 
         def attributes

data/lib/database_consistency/writers/simple/length_validator_greater_limit.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'column has greater limit in the database than in length validator'
+          'column character limit is greater than the length validator allows'
         end
 
         def unique_attributes

data/lib/database_consistency/writers/simple/length_validator_lower_limit.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'column has lower limit in the database than in length validator'
+          'column character limit is less than the length validator allows'
         end
 
         def unique_attributes

data/lib/database_consistency/writers/simple/length_validator_missing.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'column has limit in the database but do not have length validator'
+          'column has a character length limit but does not have a length validator'
         end
 
         def unique_attributes

data/lib/database_consistency/writers/simple/missing_association_class.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'refers to undefined model %<class_name>s'
+          'refers to a non-existent model %<class_name>s'
         end
 
         def unique_attributes

data/lib/database_consistency/writers/simple/missing_dependent_destroy.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class MissingDependentDestroy < Base # :nodoc:
+        private
+
+        def template
+          'should have a corresponding has_one/has_many association with dependent option (destroy, delete, delete_all, nullify) or a foreign key with on_delete (cascade, nullify)' # rubocop:disable Layout/LineLength
+        end
+
+        def unique_attributes
+          {
+            model_name: report.model_name,
+            attribute_name: report.attribute_name
+          }
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/simple/missing_foreign_key.rb

@@ -7,7 +7,7 @@ module DatabaseConsistency
         private
 
         def template
-          'should have foreign key in the database'
+          'should have a foreign key in the database'
         end
 
         def unique_attributes