database_consistency 3.0.11 → 3.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af9d610b968b1e10caed92c35cd94d724a93e75af2bfa3b14ac3d9f5af4592d7
-  data.tar.gz: a7d5e9c0fd7e1ca330da9104dc61a11f39d09b433b0296b2d63c16e0d72d9a56
+  metadata.gz: cf61dd8acf18a8e18b559df07d481e8503576cd228ec74190aa54b2a5b11e200
+  data.tar.gz: 4c2ffed1815099f0c2102043b976a85236017b6c4d92287741a48459824a047c
 SHA512:
-  metadata.gz: 14fdf20cb9ec117660bf497981b548df0b16259f0206d89a62d088f63c87eca9f361dfc3ff3dde02b00af34ae2bc12bc6687f425a2f423b0b2d919e3a13f9796
-  data.tar.gz: e23ea79b4d0883e5bc6117e7ebc02236f1ec47a6175725390b1c596c7b6fb509755d2285819faec994ccf5434fe2b5eaf8c31f74f0f89886e51f613fd8486225
+  metadata.gz: b04e984adeec1807d37f83b6826d0e4499e95c1bc8b3042b9a078e348de499d1df1d1b2437972eb2899a6716da8f4e498d946629570e761ec3ef59969254ffac
+  data.tar.gz: c100ad7001fe64ce78b1fed323b0e1c389b4bacfb899a26a215731ca4327f6b026828063ea48ac3a494958c8b59916a94b88577c16d342c6205b69d843b11769

data/lib/database_consistency/helper.rb

@@ -151,7 +151,7 @@ module DatabaseConsistency
       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('"', ''))
+      normalize_condition_sql(where_part.gsub("#{model.quoted_table_name}.", ''))
     rescue StandardError
       nil
     end
@@ -188,31 +188,68 @@ module DatabaseConsistency
       validator_where.casecmp?(normalized_where)
     end
 
+    # Prefix used to mask string literals while regex normalization runs, so
+    # patterns that strip casts or unwrap parentheses never see the inside of a
+    # literal value. Angle brackets are used so the placeholder cannot be mistaken
+    # for a column name by the boolean-predicate normalizer.
+    LITERAL_PLACEHOLDER = '__DATABASE_CONSISTENCY_LITERAL<%<index>d>__'
+
     # 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) }
+      masked_sql, literals = sql.to_s
+                                .then { |value| strip_outer_parentheses(value) }
+                                .then { |value| normalize_sql_pre_mask(value) }
+                                .then { |value| mask_condition_literals(value) }
+
+      normalize_masked_condition_sql(masked_sql, literals)
+    end
+
+    # Finishes normalization after string literals have been masked: runs the
+    # regex-based transforms that must not see inside literals, restores the
+    # literals, then applies the final clean-ups.
+    def normalize_masked_condition_sql(masked_sql, literals)
+      masked_sql
+        .then { |value| normalize_sql_post_mask(value) }
         .then { |value| normalize_boolean_predicates(value) }
         .then { |value| normalize_array_any_predicates(value) }
+        .then { |value| unmask_condition_literals(value, literals) }
         .then { |value| normalize_negated_blank_or_nil_predicates(value) }
         .then { |value| sort_and_clauses(value) }
+        .then { |value| value.gsub(/\s+/, ' ').strip }
+    end
+
+    # Masks non-empty string literals so later regexes cannot rewrite their
+    # contents. Empty literals are left untouched because negated-blank
+    # normalization relies on them.
+    def mask_condition_literals(sql)
+      literals = []
+      masked_sql = sql.gsub(/'(?:[^']|'')*'/) do |match|
+        if match == "''"
+          match
+        else
+          literals << match
+          format(LITERAL_PLACEHOLDER, index: literals.length - 1)
+        end
+      end
+      [masked_sql, literals]
     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')
+    # Restores literals in the order they were masked. Uses a block replacement
+    # so backslashes inside the literal are not interpreted as regexp backrefs.
+    def unmask_condition_literals(sql, literals)
+      literals.each_with_index do |literal, index|
+        sql = sql.sub(format(LITERAL_PLACEHOLDER, index: index)) { literal }
+      end
+      sql
+    end
+
+    # Normalizations that must run before string literals are masked.
+    def normalize_sql_pre_mask(sql)
+      normalized_sql = sql.dup
       # `/\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.
@@ -220,9 +257,22 @@ module DatabaseConsistency
       # `/ = '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
+      normalized_sql.gsub(/\s+/, ' ').strip
+    end
+
+    # Normalizations that run while string literals are masked.
+    def normalize_sql_post_mask(sql)
+      # Strips quoted identifiers (double quotes on PostgreSQL/SQLite,
+      # backticks on MySQL) so the same column normalizes across adapters.
+      normalized_sql = sql.gsub(/["`]/, '')
+      # `/::\w+/` removes PostgreSQL casts like `column::text`.
+      normalized_sql = normalized_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')
+      # `/\s*<>\s*/` rewrites the SQL inequality operator `<>` to `!=`.
+      normalized_sql = normalized_sql.gsub(/\s*<>\s*/, ' != ')
+      normalized_sql.gsub(/\s+/, ' ').strip
     end
 
     # Repeatedly removes one wrapping layer of parentheses when the whole SQL

data/lib/database_consistency/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_consistency
 version: !ruby/object:Gem::Version
-  version: 3.0.11
+  version: 3.0.12
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-24 00:00:00.000000000 Z
+date: 2026-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord