database_consistency 3.0.2 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f837e1b5dec95bfd802c388c77ad279277c50862d9b8d5ea230c655f2ddad0a
-  data.tar.gz: 86524123737c51e76311d330149f7a4985cb1fbf177e528c289177f749dbf334
+  metadata.gz: 3778602ed94cd95bc312d659eb256f62b264812105dd7c680c773976b921659a
+  data.tar.gz: b94531ee4ada7bed7d18b1bda935cb1c316b171ad68eee0280318476344239cf
 SHA512:
-  metadata.gz: ef3ee3c55c9fbd3ae445b0b5aef247f1ca25ebc683d1e8d2bd8ffcdb2fb09d1cf9ccb89d5611bd414f53d1f7f3102f92c9732559381a0d8a0166661cad4b7349
-  data.tar.gz: 0155cdcc840cacd1292656249c1ea4942a01aee93b5490dad2e092d4d76edae37abd09ae704350ade681264d6b9a3e6d8cebf0db333c9de8651f5d11600c499f
+  metadata.gz: e10aec4c79837cf87cad9e696699e8bf2e351c75cc606570d3dd322a579373be519fc3ae71e2f77279e21e9b9fbc8859f24fdfb8ef596742e58e7719d3abcf71
+  data.tar.gz: c5a31c8a838aab2226454ffe2d3aa82941b4f759f884f2cc7b2a113575eef4259a55c0c343e09d88e015f3e175ac30984d8ea645f5c3851f219d26148984e3a9

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.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_consistency
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.0.3
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-21 00:00:00.000000000 Z
+date: 2026-04-19 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:
   - - ">="