database_consistency 3.0.2 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f837e1b5dec95bfd802c388c77ad279277c50862d9b8d5ea230c655f2ddad0a
-  data.tar.gz: 86524123737c51e76311d330149f7a4985cb1fbf177e528c289177f749dbf334
+  metadata.gz: 4830aa2e788dbbee5e54ce2748509ef5b8bfab2c76e4355edcefff9ce04775de
+  data.tar.gz: 26e284719ae0b7289164b34a6b0e9ccfaca84bbbd473451ec9114cd0fe57457b
 SHA512:
-  metadata.gz: ef3ee3c55c9fbd3ae445b0b5aef247f1ca25ebc683d1e8d2bd8ffcdb2fb09d1cf9ccb89d5611bd414f53d1f7f3102f92c9732559381a0d8a0166661cad4b7349
-  data.tar.gz: 0155cdcc840cacd1292656249c1ea4942a01aee93b5490dad2e092d4d76edae37abd09ae704350ade681264d6b9a3e6d8cebf0db333c9de8651f5d11600c499f
+  metadata.gz: 8a6668676b8aca9c6e4dd55768c5c1c94b37c9de320ae38a535d8a69b49b164940a3ed7f5c2e12de24ccb208d7100863fa54cf715b879c99ca07850bb4565a46
+  data.tar.gz: be80eee01a075040572372ddcba789ac392003f0dc269a491a810b7acbe05bfafd05c60702f0d2f7aed7785547c97fe1f27dbff25d4679aaeaa0af0cc1a44141

data/bin/database_consistency

@@ -39,10 +39,17 @@ opt_parser = OptionParser.new do |opts|
     options[:todo] = true
   end
 
-  opts.on('-f', '--autofix', 'Automatically fixes issues by adjusting the code or generating missing migrations.') do
+  opts.on('-f', '--autofix',
+          'Automatically fixes issues by adjusting the code or generating missing migrations.') do
     options[:autofix] = true
   end
 
+  opts.on('--only-checkers=LIST', Array,
+          'When used with --autofix, restricts the fix to offenses produced by the listed checker ' \
+          'class names (comma-separated, e.g. ColumnPresenceChecker,NullConstraintChecker).') do |checkers|
+    options[:only_checkers] = checkers
+  end
+
   opts.on('-h', '--help', 'Prints this help.') do
     puts opts
     exit
@@ -51,6 +58,11 @@ end
 
 opt_parser.parse!
 
+if options[:only_checkers] && !options[:autofix]
+  warn '--only-checkers requires --autofix'
+  exit 1
+end
+
 base_dir = File.join(Dir.pwd, ARGV.first.to_s)
 unless File.realpath(base_dir).start_with?(Dir.pwd)
   puts "\nWarning! You are going out of current directory, ruby version may be wrong and some gems may be missing.\n"
@@ -75,5 +87,10 @@ $LOAD_PATH.unshift(File.expand_path('lib', __dir__))
 require 'database_consistency'
 
 # Process checks
-code = DatabaseConsistency.run(config, **options)
+begin
+  code = DatabaseConsistency.run(config, **options)
+rescue DatabaseConsistency::Writers::AutofixWriter::UnknownCheckerError => e
+  warn e.message
+  exit 1
+end
 exit code

data/lib/database_consistency/checkers/index_checkers/unique_index_checker.rb

@@ -35,7 +35,7 @@ module DatabaseConsistency
       def validator_matches?(validator)
         validator.attributes.any? do |attribute|
           sorted_index_columns == Helper.sorted_uniqueness_validator_columns(attribute, validator, model) &&
-            Helper.conditions_match_index?(model, validator.options[:conditions], index.where)
+            Helper.conditions_match_index?(model, attribute, validator, index.where)
         end
       end
 

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

@@ -53,7 +53,7 @@ module DatabaseConsistency
       def index_matches?(index)
         index.unique &&
           Helper.extract_index_columns(index.columns).sort == sorted_uniqueness_validator_columns &&
-          Helper.conditions_match_index?(model, validator.options[:conditions], index.where)
+          Helper.conditions_match_index?(model, attribute, validator, index.where)
       end
 
       def primary_key_covers_validation?

data/lib/database_consistency/helper.rb

@@ -151,29 +151,182 @@ module DatabaseConsistency
       where_part = sql.split(/\bWHERE\b/i, 2).last
       return nil unless where_part
 
-      normalize_sql(where_part.gsub("#{model.quoted_table_name}.", '').gsub('"', ''))
+      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, conditions, index_where)
-      return true if conditions.nil? && index_where.blank?
-      return false if conditions.nil? || index_where.blank?
+    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
 
-      conditions_sql = conditions_where_sql(model, conditions)
-      # Strip one level of outer parentheses that some databases (e.g. PostgreSQL)
-      # add when storing/returning the index WHERE clause.
-      normalized_where = normalize_sql(index_where.sub(/\A\s*\((.+)\)\s*\z/m, '\1'))
-      conditions_sql&.casecmp?(normalized_where)
+    # 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)
-      sql.gsub(/\bTRUE\b/i, '1').gsub(/\bFALSE\b/i, '0')
-         .gsub(/ = 't'/, ' = 1').gsub(/ = 'f'/, ' = 0')
-         .strip
+      # `/::\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]

data/lib/database_consistency/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DatabaseConsistency
-  VERSION = '3.0.2'
+  VERSION = '3.0.4'
 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.rb

@@ -116,12 +116,15 @@ require 'database_consistency/checkers/index_checkers/redundant_unique_index_che
 # The root module
 module DatabaseConsistency
   class << self
-    def run(*args, **opts) # rubocop:disable Metrics/MethodLength
+    def run(*args, **opts) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       configuration = Configuration.new(*args)
+
+      Writers::AutofixWriter.validate_scope!(opts[:only_checkers]) if opts[:autofix]
+
       reports = Processors.reports(configuration)
 
       if opts[:autofix]
-        Writers::AutofixWriter.write(reports, config: configuration)
+        Writers::AutofixWriter.write(reports, config: configuration, opts: opts[:only_checkers])
 
         0
       elsif opts[:todo]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_consistency
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.0.4
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-21 00:00:00.000000000 Z
+date: 2026-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -275,7 +275,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="