concerns_on_rails 1.28.8 → 1.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ae4fb29ea12389fc8aaff341a565a482bf3c8ef99fdcfc7791c64c7302d1ca5
-  data.tar.gz: 02ea08bceb25e2a479e27ef00342c69cfeac2ffc8129b689269f423819c0c0ae
+  metadata.gz: f00644495f4a20c3265cfa9289708136b4bb086aebeeb16026ebd2c9e12f7991
+  data.tar.gz: 01162f76ade27fb2b42aa93c3317819fb4db96c761717fdc20cafeedd213046f
 SHA512:
-  metadata.gz: 4ac2edd1717ef0e4c157b851e75554ba057321e1ae9f283bcdb015e9e6d49d63f1f4bf9bc9ee4419e0b28a111487147516957a03b17ae3915c7ac23f8a721109
-  data.tar.gz: 826dd0234e22faa23b089fbedd7900c8bc847f8f7af5670c6a6b0dafc22ec838b29e0cf196b0269b8dde798302d43c677eb4c93d60396db207d6e733d0f16ff2
+  metadata.gz: fad1b9c385054e869d5dcd4012f1e06182b3597c63a500d6513521fbefd758480ffcaf85922c0d805a2d1b07430f03a3d0a3fb1184f510450adfabd311155630
+  data.tar.gz: e7a299357dc9f389a4e9e99241af15c783806a96dc4b9037fe5283d1737038b63f53224a3c6e77e5f5b0a926e3d341df435c8c7b0d319a73258b33a489a15614

data/CHANGELOG.md

@@ -1,5 +1,106 @@
 <!-- CHANGELOG.md -->
 
+## 1.29.0 (2026-09-21)
+
+CI now runs **every Rails line the gemspec admits** — 6.0, 6.1, 7.0, 7.1, 7.2, 8.0 and 8.1 —
+where it previously ran 7.0 through 8.0. Extending the matrix downwards found 201 failures
+on the two new old lines and 0 on the new top line; all of them are fixed, and all seven
+legs are green and blocking.
+
+### Changed
+- **Rails 5.x is no longer declared.** The `actionpack` / `activerecord` / `activesupport`
+  floor moves from `>= 5.0` to `>= 6.0`. This drops nothing that ever worked: with
+  `required_ruby_version = ">= 3.2.0"`, the `>= 5.0` half was unreachable by construction —
+  Ruby 3's keyword-argument separation breaks Active Record 5.2's own `create_table`
+  (`schema_statements.rb:290`), so no bundle could satisfy both. Verified rather than
+  assumed: on Ruby 3.2 the suite fails 1,302 examples on Rails 5.2, every one of them
+  inside the framework.
+
+### Fixed
+- **Controllers::Includable**: `?fields[table]=...` raised `LocalJumpError` ("no block
+  given") on Rails 6.0. `requested_fields` called the block-less `params[:fields].each_pair`
+  and chained `with_object`, but `ActionController::Parameters#each_pair` only began
+  returning an Enumerator in 6.1. It now iterates with a block, which behaves the same on
+  every line.
+- **Models::Searchable**: the generated `search` scope raised
+  `ArgumentError: wrong number of arguments (given 2, expected 1)` for every call on Rails
+  6.0. Rails 6.0 forwards a scope's arguments through `define_method(name) { |*args| }`
+  with no `ruby2_keywords`, so under Ruby 3 the `ranked:` keyword reaches the body as a
+  trailing positional Hash. The scope now takes its options positionally and splats them
+  back out — same call signature, and an unknown key still raises.
+
+### Documented
+- Two features need a line newer than the 6.0 floor, and both now say so in the README's
+  compatibility table and in their own docs: `Controllers::Sortable`'s `nulls:` ordering
+  (Rails 6.1+, already raised at macro time) and `Models::Aliasable`'s **query side**
+  (Rails 6.1+ — resolving a `where`-hash key to an association, which is what makes Rails
+  alias the join, landed in 6.1; Aliasable's read/write side works on 6.0).
+
+### Internal
+- `gemfiles/rails_6.0.gemfile`, `rails_6.1.gemfile` and `rails_8.1.gemfile`; every gemfile
+  below 7.1 now pins `concurrent-ruby < 1.3.5`, which dropped its own `require "logger"`
+  that Active Support only started doing for itself in 7.1.
+- The spec harness clears Active Record's schema cache and (on <= 6.1)
+  `ActiveSupport::Dependencies::Reference` between examples, gives anonymous spec models a
+  `model_name`, and gains a `min_rails:` metadata tag for examples whose feature is version
+  gated. Without the first two, specs that reuse table and model names across files saw the
+  PREVIOUS file's columns and classes on 6.0/6.1.
+
+## 1.28.9 (2026-09-19)
+
+CI now runs the matrix the gemspec actually claims: Rails 7.0–8.0 across Ruby 3.2/3.3/3.4,
+plus **PostgreSQL and MySQL** alongside SQLite. The suite had only ever run on SQLite, which
+is the most permissive of the three, and the first green-on-SQLite run of the new matrix
+failed 29 examples on MySQL and 7 on PostgreSQL.
+
+Almost all of those were specs asserting SQLite's own SQL rather than the gem misbehaving —
+but one was a real bug, and it is the reason this is a release and not just a CI change.
+
+### Fixed
+- **Models::Taggable**: `tagged_with` was broken on MySQL and inconsistent on PostgreSQL.
+  - On **MySQL** every `tagged_with` query was a **syntax error**. The clause inlined
+    `ESCAPE '\'` into hand-written SQL, and MySQL treats backslash as an escape character
+    inside string literals, so the escape consumed its own closing quote. SQLite and
+    PostgreSQL (with `standard_conforming_strings`) read it as a literal backslash, which is
+    why this was invisible for so long. The clause is now built with Arel `matches`, so the
+    adapter quotes the escape character itself — one code path, no per-adapter branching.
+  - On **PostgreSQL** `tagged_with` was case-SENSITIVE, while on SQLite and MySQL it folded
+    case: the same query returned different rows depending on the database. It is now
+    case-insensitive on all three (`ILIKE` on PostgreSQL).
+
+  ⚠️ **PostgreSQL users: this widens `tagged_with`.** A lookup that was case-sensitive before
+  now also matches differently-cased tags. That is the documented intent of the concern and
+  it makes the three adapters agree, but it is a behaviour change on upgrade. If you relied
+  on case-sensitive matching, declare `taggable_by :tags, downcase: true` and fold on write.
+  SQLite and MySQL users see no change. Note the Ruby-side helpers (`tagged_with?`,
+  `all_tags`, `tag_counts`) still compare exactly — `downcase: true` is what makes the scope
+  and the helpers agree.
+
+### Internal
+- **CI**: `.github/workflows/ci.yml` gains a Rails-version axis (7.0, 7.1, 7.2, 8.0 × Ruby
+  3.2/3.3/3.4, via `gemfiles/*.gemfile`) and an adapter axis (PostgreSQL and MySQL service
+  containers). `DB=postgresql` / `DB=mysql2` selects the adapter locally; SQLite stays the
+  default so a plain checkout still needs no services. (#102)
+- **Specs**: examples that asserted SQL now build the expected fragment from the
+  connection's own quoting, via new `TestDatabase.quoted_table` / `quoted_column` /
+  `qualified` helpers and `sqlite?` / `postgresql?` / `mysql?` predicates — so an assertion
+  means the same thing on every adapter instead of encoding SQLite's. Several examples got
+  *stronger* in the process: the Sortable NULL-ordering pair now asserts the PostgreSQL
+  native-`NULLS` branch and the portable-`CASE` branch separately, each also asserting the
+  other is absent.
+- Three examples depended on SQLite-only tolerance rather than on the gem: a grouped
+  relation selecting `*` (rejected by PostgreSQL, and by MySQL under `only_full_group_by`),
+  a non-finite Float written to a float column (SQLite's adapter overrides `quote` for
+  those; MySQL emits a bare `NaN`), and a NULL page-boundary fixture that assumed SQLite's
+  NULLs-first ordering (PostgreSQL sorts NULLs last ascending).
+
+### Known gap
+- `Models::Storable` guards its JSON extraction with `json_valid` on SQLite only. MySQL has
+  `JSON_VALID()` (5.7.8+) and could have the same guard; it was left alone deliberately
+  rather than shipped unverified, since a wrong guess there would break every
+  `where_<key>` query on that adapter. PostgreSQL has no equivalent before PG 16's
+  `IS JSON`. Now that the MySQL leg runs, this is a small follow-up.
+
 ## 1.28.8 (2026-09-19)
 
 The last six open feature PRs, released as a patch by request. These had never been

data/README.md

@@ -11,7 +11,7 @@ One `include`, one declarative macro — done.
 [![CI](https://github.com/VSN2015/concerns_on_rails/actions/workflows/ci.yml/badge.svg)](https://github.com/VSN2015/concerns_on_rails/actions/workflows/ci.yml)
 [![Docs](https://img.shields.io/badge/docs-vsn2015.github.io-6f42c1?logo=readthedocs&logoColor=white)](https://vsn2015.github.io/concerns_on_rails)
 [![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.2-CC342D?logo=ruby&logoColor=white)](https://www.ruby-lang.org)
-[![Rails](https://img.shields.io/badge/rails-5.0--8.x-CC0000?logo=rubyonrails&logoColor=white)](https://rubyonrails.org)
+[![Rails](https://img.shields.io/badge/rails-6.0--8.1-CC0000?logo=rubyonrails&logoColor=white)](https://rubyonrails.org)
 [![License: MIT](https://img.shields.io/badge/license-MIT-3fb950.svg)](#-license)
 
 ### [📖 **Documentation**](https://vsn2015.github.io/concerns_on_rails)  ·  [💎 **RubyGems**](https://rubygems.org/gems/concerns_on_rails)  ·  [📝 **Changelog**](CHANGELOG.md)  ·  [🐛 **Issues**](https://github.com/VSN2015/concerns_on_rails/issues)
@@ -148,7 +148,7 @@ across all 43 concerns — press <kbd>/</kbd> and type.
 - **Lean dependencies** — only `acts_as_list` (Sortable) and `friendly_id` (Sluggable), and both load **lazily**: an app that never includes those concerns never loads them. Depends on `activerecord`/`actionpack`/`activesupport`, not the full `rails` meta-gem; controller concerns have zero extra deps
 - **Schema-validated configuration** — every macro checks that the configured columns exist and raises `ArgumentError` early — listing *every* missing column at once, with one ready-to-paste `rails generate migration` command that adds them all
 - **Composable** — concerns are independent; mix and match per model
-- **Tested like an app, not a snippet** — **1,828 RSpec examples** run against a real database on every CI build
+- **Tested like an app, not a snippet** — **1,830 RSpec examples** run against a real database on every CI build
 - **Documented twice** — everything in this README also lives as a per-concern page on the [docs site](https://vsn2015.github.io/concerns_on_rails), searchable and deep-linkable
 
 ---
@@ -158,7 +158,7 @@ across all 43 concerns — press <kbd>/</kbd> and type.
 Add to your application's `Gemfile`:
 
 ```ruby
-gem "concerns_on_rails", "~> 1.28"
+gem "concerns_on_rails", "~> 1.29"
 ```
 
 Or pull the latest from GitHub:
@@ -200,7 +200,25 @@ still wins over the gem-wide fallback.
 ## 🧪 Compatibility
 
 - **Ruby**: 3.2+
-- **Rails**: declared 5.0 through 8.x — in practice the Ruby 3.2 requirement means Rails 7.0.4+ is what can actually install the gem; the test suite runs against Rails 7.1
+- **Rails**: 6.0 through 8.1
+
+Every one of those lines runs the full suite on every push — Rails 6.0, 6.1, 7.0, 7.1, 7.2,
+8.0 and 8.1 on SQLite, plus PostgreSQL and MySQL, and Ruby 3.3/3.4 against the current
+lines. See [`.github/workflows/ci.yml`](.github/workflows/ci.yml).
+
+**Rails 5.x is not supported**, despite what older versions of this gem declared. Rails 5
+cannot run on any Ruby this gem supports: Ruby 3 separated keyword arguments, which breaks
+Active Record 5.2's own `create_table`, and `required_ruby_version` here is `>= 3.2.0`. The
+old `>= 5.0` dependency was therefore unreachable — no bundle could ever have satisfied
+both halves of it.
+
+Two things need a Rails line newer than the 6.0 floor. Both raise or are documented where
+they apply, and nothing else in the gem is affected:
+
+| Feature | Needs | Below that |
+|---|---|---|
+| `Controllers::Sortable` — `nulls:` ordering | Rails 6.1 | Raises `ArgumentError` at macro time (Arel gained the ordering nodes in 6.1) |
+| `Models::Aliasable` — query side (`joins`/`where`/`eager_load` through an alias) | Rails 6.1 | Rails resolves a `where`-hash key to a table name, not an association, so the alias is not applied to the join. Readers, writers and `build_`/`create_` work on 6.0 |
 
 ---
 
@@ -765,7 +783,7 @@ User.find_by(email: User.normalize(:email, params[:email]))
 - `with:` takes a preset, a Proc, or an Array of them (applied in order); every entry is validated at class load.
 - `nil` values are skipped — no `nil → ""` coercion (use `:nullify_blank` for the opposite direction).
 - Preset normalizers pass non-string values through unchanged.
-- Works on Rails 5+ (no dependency on Rails 7.1's built-in `normalizes`).
+- Works on Rails 6.0+ (no dependency on Rails 7.1's built-in `normalizes`).
 
 ---
 
@@ -1200,6 +1218,7 @@ Article.published.tag_counts(limit: 20)        # => { "ruby" => 12, "rails" => 7
 
 **Notes**
 - Matching is **boundary-safe** — searching `rail` does not match `rails`. An explicit SQL `ESCAPE` clause makes tags containing `_` / `%` match literally on every adapter.
+- `tagged_with` matches **case-insensitively on every adapter** — `LIKE` on SQLite and MySQL, `ILIKE` on PostgreSQL — so one call means one thing everywhere (how non-ASCII characters fold is still the database collation's business). The Ruby-side helpers (`tagged_with?`, `all_tags`, `tag_counts`) compare exactly, so `downcase: true` — which folds on write — is what makes the scope and the helpers agree.
 - Tags are normalized in `before_validation`, so a direct `record.tags = "a, b"` assignment is cleaned too. An empty list stores `NULL`.
 - `tag_counts` runs one `GROUP BY` on the raw column — identical tag strings ship once with their row count and are split in Ruby — so it scales with distinct tag strings, not rows; ordered by count desc then name, `limit:` keeps the top N.
 - Reach for [`acts-as-taggable-on`](https://github.com/mbleigh/acts-as-taggable-on) when you need tag contexts, ownership, or polymorphic tags shared across models.
@@ -1428,6 +1447,10 @@ unlike Publishable/Expirable/Activatable, this one has no validators gate.
 
 ## 🪞 Aliasable
 
+> **Rails 6.1+ for the query side.** `joins` / `where` / `eager_load` through an alias
+> needs Rails to resolve a `where`-hash key to an association, which landed in 6.1. The
+> read/write side (readers, writers, `build_`/`create_`, the ids pair) works on 6.0.
+
 Alias an existing association under a second name with **full** semantics — read, write/assign, build/create, and the query side (`joins` / `includes` / `where`-hash) — not just a delegated reader. (`alias_attribute` covers columns only; Rails has no built-in association aliasing.)
 
 ```ruby
@@ -2208,7 +2231,7 @@ When several rules apply to one request the `X-RateLimit-*` headers describe the
 - The store MUST support **atomic increment-with-expiry** (`Rails.cache` with `#increment`, or Redis) — a non-atomic store under-counts under concurrency.
 - There is **no in-process default store** on purpose: the first throttled request raises `ArgumentError` until you set `throttleable_store` (or the gem-wide fallback `ConcernsOnRails.setup { |c| c.cache_store = -> { Rails.cache } }`), so you never silently rate-limit per-process.
 - When `Respondable` is included, the 429 body delegates to `render_error` (`code: "rate_limited"`).
-- Backports the essentials of Rails 7.2's `rate_limit` (with standardized headers) to Rails 5.0+. For richer rules (fail2ban, allow/deny lists, exponential backoff) reach for [`rack-attack`](https://github.com/rack/rack-attack).
+- Backports the essentials of Rails 7.2's `rate_limit` (with standardized headers) to Rails 6.0+. For richer rules (fail2ban, allow/deny lists, exponential backoff) reach for [`rack-attack`](https://github.com/rack/rack-attack).
 
 ---
 
@@ -2502,9 +2525,9 @@ Point your agent at `llms.txt` for an overview, or paste a single concern's `.md
 
 ```sh
 bundle install                                  # install dev dependencies
-bundle exec rspec                               # run the test suite (1,828 examples)
+bundle exec rspec                               # run the test suite (1,830 examples)
 gem build concerns_on_rails.gemspec             # build the gem
-gem install ./concerns_on_rails-1.28.8.gem      # install locally
+gem install ./concerns_on_rails-1.29.0.gem      # install locally
 
 # Preview the docs site locally (GitHub Pages serves docs/ as-is):
 cd docs && python3 -m http.server 8000          # → http://localhost:8000

data/lib/concerns_on_rails/controllers/includable.rb

@@ -130,17 +130,22 @@ module ConcernsOnRails
         return {} unless raw.respond_to?(:each_pair)
 
         allowed = self.class.includable_fields
-        # Iterate via each_pair: in a real controller `raw` is an
+        # Iterate via each_pair WITH A BLOCK: in a real controller `raw` is an
         # ActionController::Parameters, which has each_pair but no Enumerable —
         # calling each_with_object directly on it was a guaranteed
-        # NoMethodError 500 for every ?fields[...]= request.
-        raw.each_pair.with_object({}) do |(table, cols), memo|
+        # NoMethodError 500 for every ?fields[...]= request. Its block-less
+        # form is no good either: Parameters#each_pair only started returning
+        # an Enumerator in Rails 6.1, so `raw.each_pair.with_object` raised
+        # LocalJumpError ("no block given") on 6.0.
+        memo = {}
+        raw.each_pair do |table, cols|
           key = table.to_sym
           next unless allowed.key?(key)
 
           permitted = split_field_list(cols) & allowed[key]
           memo[key] = permitted unless permitted.empty?
         end
+        memo
       end
 
       private

data/lib/concerns_on_rails/models/aliasable.rb

@@ -46,6 +46,13 @@ module ConcernsOnRails
     #     must match the name you joined under (same rule as stock Rails):
     #     joins(:sections).where(sections: {...}) works,
     #     joins(:chapters).where(sections: {...}) does not.
+    #   * THE QUERY SIDE NEEDS RAILS 6.1+. Resolving a where-hash key to an
+    #     ASSOCIATION rather than to a literal table name landed in 6.1, and
+    #     that resolution is what makes Rails alias the join to the
+    #     reflection name. On 6.0 the same call emits
+    #     INNER JOIN "chapters" ... WHERE "sections"... — a reference to an
+    #     alias that was never created, which the database rejects. Readers,
+    #     writers, build_/create_ and the ids pair all work on 6.0.
     #   * The belongs_to foreign-key attribute is NOT aliased — pair with
     #     Rails' alias_attribute (e.g. :writer_id, :author_id) if needed.
     #   * has_and_belongs_to_many cannot be aliased — use has_many :through.

data/lib/concerns_on_rails/models/searchable.rb

@@ -74,7 +74,14 @@ module ConcernsOnRails
           self.searchable_case_sensitive = case_sensitive
           self.searchable_ranked = ranked
 
-          scope :search, ->(query, ranked: nil) { search_relation(query, ranked: ranked) }
+          # Options are taken POSITIONALLY, not as keywords. Rails 6.0 forwards a
+          # scope's arguments through `define_method(name) { |*args| ... }` with no
+          # `ruby2_keywords`, so under Ruby 3 a `ranked:` keyword reaches the body as
+          # a trailing positional Hash and a kwarg-taking lambda dies with
+          # `wrong number of arguments (given 2, expected 1)`. Splatting an options
+          # hash back out here behaves identically on 6.0 through 8.1 — and still
+          # raises on an unknown key, because `search_relation` names its keywords.
+          scope :search, ->(query, opts = {}) { search_relation(query, **opts) }
         end
 
         # `ranked:` nil defers to the macro's setting; true/false override it.

data/lib/concerns_on_rails/models/taggable.rb

@@ -28,6 +28,12 @@ module ConcernsOnRails
     #
     # Notes:
     #   * Matching is boundary-safe ("rail" does not match "rails").
+    #   * `tagged_with` matches case-INsensitively on every adapter — LIKE on
+    #     SQLite and MySQL, ILIKE on PostgreSQL — so one call means one thing
+    #     everywhere (how non-ASCII characters fold is still the database
+    #     collation's business). The Ruby-side helpers (`tagged_with?`,
+    #     `all_tags`, `tag_counts`) compare exactly, so `downcase: true`, which
+    #     folds on write, is what makes the scope and the helpers agree.
     #   * A tag cannot contain the delimiter (default ",") — input containing
     #     it is split into multiple tags on the spot (`add_tags("a,b")` adds
     #     "a" and "b"), everywhere, so what you read back always matches what
@@ -40,6 +46,10 @@ module ConcernsOnRails
       LABEL = "ConcernsOnRails::Models::Taggable".freeze
       DEFAULT_FIELD = :tags
       DEFAULT_DELIMITER = ",".freeze
+      # Same LIKE-escaping contract as Models::Searchable: the adapter quotes
+      # the escape character for us, so a backslash is portable here.
+      LIKE_ESCAPE = "\\".freeze
+      LIKE_SPECIAL = /[\\%_]/
 
       included do
         class_attribute :taggable_field, instance_accessor: false, default: DEFAULT_FIELD
@@ -68,9 +78,10 @@ module ConcernsOnRails
           tags = taggable_clean_all(names)
           return all if tags.empty?
 
-          clauses = tags.map { |t| taggable_clause(t) }
-          sql = clauses.map(&:first).join(any ? " OR " : " AND ")
-          where(sql, *clauses.flat_map(&:last))
+          predicates = tags.map { |tag| taggable_predicate(tag) }
+          return where(predicates.reduce { |memo, node| memo.or(node) }) if any
+
+          predicates.reduce(all) { |memo, node| memo.where(node) }
         end
 
         # All distinct tags currently stored across the table, sorted.
@@ -150,26 +161,36 @@ module ConcernsOnRails
                .reject(&:blank?).uniq
         end
 
-        # Boundary-safe match for one tag against the delimiter-joined column.
-        # Returns [sql_fragment, [bind_params...]]. An explicit ESCAPE clause makes
-        # the backslash escaping below work on every adapter (SQLite has no default
-        # LIKE escape), so a tag containing `_` or `%` matches literally.
-        def taggable_clause(tag)
-          column = "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(taggable_field)}"
-          # Escape the delimiter too (not just the tag): a delimiter that is a LIKE
-          # wildcard (% or _) must match literally. Use LIKE for the whole-column
-          # branch as well, so casing is uniform across all four branches — the
-          # previous `= ?` was case-sensitive while LIKE is not.
+        # Boundary-safe match for one tag against the delimiter-joined column:
+        # the tag alone, first, last, or somewhere in the middle. Built from
+        # Arel's `matches` rather than a hand-written LIKE string for two
+        # reasons.
+        #
+        # 1. The ESCAPE character is then quoted by the adapter. An inlined
+        #    `ESCAPE '\'` is a syntax error on MySQL, where a backslash escapes
+        #    its own closing quote inside a string literal, even though the very
+        #    same text is fine on SQLite and on PostgreSQL.
+        # 2. `case_sensitive: false` emits ILIKE on PostgreSQL, whose LIKE —
+        #    unlike SQLite's, and unlike MySQL's under a default _ci collation —
+        #    is case-sensitive, so `tagged_with` used to mean something
+        #    different there.
+        #
+        # An explicit ESCAPE is still what makes a tag containing `_` or `%`
+        # match literally (SQLite has no default LIKE escape).
+        def taggable_predicate(tag)
+          column = arel_table[taggable_field]
+          # Escape the delimiter too (not just the tag): a delimiter that is a
+          # LIKE wildcard (% or _) must match literally.
           delim = taggable_escape_like(taggable_delimiter)
           escaped = taggable_escape_like(tag)
-          esc = " ESCAPE '\\'"
-          ["(#{column} LIKE ?#{esc} OR #{column} LIKE ?#{esc} OR #{column} LIKE ?#{esc} OR #{column} LIKE ?#{esc})",
-           [escaped, "#{escaped}#{delim}%", "%#{delim}#{escaped}", "%#{delim}#{escaped}#{delim}%"]]
+          [escaped, "#{escaped}#{delim}%", "%#{delim}#{escaped}", "%#{delim}#{escaped}#{delim}%"]
+            .map { |pattern| column.matches(pattern, LIKE_ESCAPE, false) }
+            .reduce { |memo, node| memo.or(node) }
         end
 
         # Treat the user's tag as a LIKE literal: %, _ and \ are not wildcards.
         def taggable_escape_like(str)
-          str.gsub(/[\\%_]/) { |char| "\\#{char}" }
+          str.gsub(LIKE_SPECIAL) { |char| "#{LIKE_ESCAPE}#{char}" }
         end
       end
 

data/lib/concerns_on_rails/version.rb

@@ -1,3 +1,3 @@
 module ConcernsOnRails
-  VERSION = "1.28.8".freeze
+  VERSION = "1.29.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concerns_on_rails
 version: !ruby/object:Gem::Version
-  version: 1.28.8
+  version: 1.29.0
 platform: ruby
 authors:
 - Ethan Nguyen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-19 00:00:00.000000000 Z
+date: 2026-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9'
@@ -36,7 +36,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9'
@@ -46,7 +46,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9'
@@ -56,7 +56,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9'
@@ -66,7 +66,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9'