make_taggable 1.2.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99cb64f83f0cef74cc21f3fc09a341e62db5a2248b8c88ef5d720de4b9446abb
-  data.tar.gz: c3c08be5a20df6100567523555be2394dc32665770f6c65226e0fe91b3be5652
+  metadata.gz: 1b40ab74ad5312aa300ba26015e4fc7d5da67e5e37c5f4c7efb235aa494e28d0
+  data.tar.gz: 84db5687e59dfb33259222e47bc58fdb7d94dd35882faafc2f1ceede7effc841
 SHA512:
-  metadata.gz: ad8701479ff9565786acebff64af05fe5aaa88eddbcfc660f88778e4ca885a0d26438677754cfa3072dd54e3eef6374ebed4f1e4de6a70fe911824050cb0b19e
-  data.tar.gz: 47804d66800ff4df491f3b7037ba5e82c131fbaf4c9eb8442a650ed6ecbf1772483d2ae2237c5437cb8ffefca831d107744a3ffacb2c517cb65a161063bc6d0e
+  metadata.gz: a71b99737d5b1f09b1fe76ffa1b5710c50f6330d1222d107bdfd685c966f6c4681040a688d29df8427b5cf3e91e1d29c458d00085de110187272afb925393ebb
+  data.tar.gz: 6ce73b0b7e0497f084080f1d4a774c974f2acb0c94ffec9d90bdbe8326f4a1e2f28721f5b4372c7d7b71ddbe0c567490faec4eb22cf884b9723fc39cddc579f0

data/AATO_ISSUE_TRIAGE.md

@@ -0,0 +1,122 @@
+# acts-as-taggable-on open issues — applicability to MakeTaggable
+
+All 66 open issues on `mbleigh/acts-as-taggable-on` (as of 2026-08-23) checked against
+`make_taggable` at 1.1.1. Everything marked **confirmed** was reproduced by running code
+against the gem's own SQLite harness (Ruby 4.0.1 / Active Record 8.1.3); everything marked
+**static** was read out of the source. Adapter-specific reports that need MySQL/PostgreSQL
+are listed separately as unverified.
+
+Verdict counts: 29 apply, 5 apply as feature gaps, 13 do not apply, 8 unverified,
+11 documentation issues already covered.
+
+---
+
+## Applies — confirmed by reproduction
+
+### Query builder
+
+| Upstream | Symptom in MakeTaggable | Evidence |
+|---|---|---|
+| #402, #993 | `tagged_with` returns a record once per matching tagging. A record tagged `"interesting"` in two contexts comes back twice. No `DISTINCT`, no context filter. | `OtherTaggableModel.tagged_with("interesting")` → 2 rows for 1 record |
+| #701 | `:exclude` ignores `:on`. `ExcludeTagsQuery#tags_not_in_list` builds no context predicate at all. | generated SQL contains no `context` clause |
+| #630 | `tagged_with([], exclude: true)` returns nothing. `core.rb` returns `none` on an empty list before the strategy is chosen, so "exclude nothing" excludes everything. | 0 rows, should be all |
+| #1094 | `tagged_with(tags, order_by_matching_tag_count: true)` raises `ActiveRecord::UnknownAttributeReference`. `AllTagsQuery#order_conditions` passes a raw subquery string to `.order`. | raises; the `any: true` path is fine because it wraps in `Arel.sql` |
+| #692, #1109, #530 | `.count` / `.size` on an `any: true` relation emits `COUNT("table".*)`, which is invalid SQL on SQLite, MySQL and PostgreSQL. Chaining two `tagged_with` calls compounds it. | `SQLite3::SQLException: near "*"` |
+| #936 | `AnyTagsQuery#build` calls `select(all_fields)`, so a caller's own `select` is appended rather than honoured. Also what breaks #395 (`merge` overwriting the SELECT). | `SELECT "taggable_models".*, "taggable_models"."id"` |
+| #915 + our own | `ExcludeTagsQuery#tags_not_in_list` hardcodes `taggable_arel_table[:id]` instead of the model's primary key. Any model with a non-`id` primary key raises on `exclude: true`. This is strictly worse than the upstream report. | `NonStandardIdTaggableModel.tagged_with(["k"], exclude: true)` → `StatementInvalid` |
+| #277, #387 | No way to order by `taggings.created_at`. `tagged_with` hides the taggings behind SHA aliases; `all_tags(order: "taggings.created_at desc")` builds a subquery that doesn't project the column. | `no such column: taggings.created_at` |
+| #293 | `tagged_with` still emits one `INNER JOIN` per tag in the default (all-tags) mode. | 12 tags → 12 joins |
+| #1028, #657 | `QueryBase#tag_match_type` wraps the column in `LOWER()` unconditionally. On PostgreSQL the operator is already `ILIKE`, so the `LOWER()` is redundant *and* defeats `index_tags_on_name`. Same cause as the #657 cache-miss report. | static + confirmed in generated SQL |
+| #328 | SQLite's `LOWER()` is ASCII-only, so `Tag.named_any` misses case variants of non-ASCII names. | `Tag.named_any(["ünicode"])` → 0 for a tag named `"Ünicode"` |
+
+### Attribute / dirty tracking
+
+| Upstream | Symptom | Evidence |
+|---|---|---|
+| #1024, #1064, #1029 | `tag_list` is declared as an `attribute`, so it appears in `as_json` (triggering a tag query per record) but reads back `nil` from `attributes`. | 19 queries to serialize 3 records; `attributes["tag_list"] == nil` |
+| #1155 | `tag_ids = []` after `as_json` silently does nothing — the tags stay attached. | tags survive the assignment |
+| #373 | `tag_list.add(...)` / `.remove(...)` mutate the array in place without `attribute_will_change!`, so `tag_list_changed?` stays false. Only whole-list assignment is tracked. | `false` after `.add("sfw")` |
+| #1047 | `TagList#remove` compares raw objects, so `remove(:foo)` is a no-op while `remove("foo")` works. | list unchanged |
+| #1139 | `TagList` carries `@parser`, which holds a *Class*. `Psych.safe_dump` refuses it, so anything serialising a taggable to YAML (audited, ActiveJob args) blows up. | `Psych::DisallowedClass: Tried to dump unspecified class: Class` |
+
+### Saving
+
+| Upstream | Symptom | Evidence |
+|---|---|---|
+| #1176 | `strict_loading` is violated on save. `save_tags` → `tagging_contexts` → `custom_contexts` lazily loads `taggings`. | `StrictLoadingViolationError` on saving a persisted record |
+| #1128 | The same path means every save — even a no-op — issues tagging queries. | 3 queries on a save with no changes |
+| #665 | A tag over 255 characters fails `Tag`'s length validation, `create` returns it unsaved, and the taggable then fails with a misleading `Validation failed: Tag can't be blank`. | raises `RecordInvalid` |
+| #508 | `Tag.find_or_create_all_with_like_by_name` uses non-bang `create`, so validation errors added by a `Tag` subclass are swallowed and surface later as the wrong error. | static |
+| #947 | `save_tags` and `save_owned_tags` create taggings in list order, so two concurrent saves touching the same tags can deadlock on the `taggings_count` counter cache. Sorting `new_tags` by id would fix it. | static |
+| #290 | `preserve_tag_order` is one `class_attribute` for the whole model, so `make_taggable` and `make_ordered_taggable` in the same class clobber each other — the last call wins for every context. | `make_taggable :skills` + `make_ordered_taggable :books` → `preserve_tag_order?` is `true` for `:skills` |
+| #1044 | A context whose name starts with a digit raises a **`SyntaxError`** while the class body loads (we generate `def 1category_taggings`). Upstream only got an invalid-ivar error, so ours fails harder. | `SyntaxError` from `has_many` |
+
+### Ownership and caching
+
+| Upstream | Symptom | Evidence |
+|---|---|---|
+| #233 | `Tagger#tag` does not refresh `cached_<context>_list`. `save_cached_tag_list` only mirrors unowned lists, so a cached column silently drifts from `all_tags_list`. | `cached_tag_list` stayed `nil` while `all_tags_list == ["owned"]` |
+| #571 | `Tagger#tag` always parses `:with` through the default parser. There is no `parse: false`, so a tag legitimately containing a comma is split into two. | `with: ["a, b"]` → `["a", "b"]` |
+
+### Configuration
+
+| Upstream | Symptom | Evidence |
+|---|---|---|
+| #781, #945 | `force_binary_collation=` still issues an `ALTER TABLE` every time it's called. Set in an initializer, that runs on every boot — including every Sidekiq/cron process — and takes a metadata lock on the tags table. | `apply_binary_collation` still calls `ActiveRecord::Migration.execute` |
+| #769 | `force_parameterize` maps tags through `String#parameterize`, which reduces a fully non-ASCII tag to the empty string and `clean!` then drops it. | `["日本語", "ok tag"]` → `["ok-tag"]` |
+
+## Applies — feature gaps rather than bugs
+
+| Upstream | Gap |
+|---|---|
+| #91 | No eager-loading path for tag lists. `includes(:tags)` doesn't stop `tag_list` re-querying (13 queries for 5 records). |
+| #804 | `tagged_with(tags, on: [:skills, :interests])` raises `TypeError: can't quote Array`. Only one context per call. |
+| #783 | The `Tag` class is hardcoded. `find_or_create_tags_from_list_with_context` lets you create subclass rows, but the associations still return `MakeTaggable::Tag`. |
+| #909 | `all_tags` / `all_tag_counts` accept no scope on the taggable's own attributes (`assert_valid_keys` rejects `:scope`). |
+| #698 | The generated migration has no `type:` on the polymorphic references, so a UUID-keyed taggable needs the migration edited by hand. Not documented. |
+
+## Does not apply
+
+| Upstream | Why |
+|---|---|
+| #908, #914 | `Model.create!(tags: [tag])` works — the tagging saves with the default context. |
+| #1151 | Repeated single-context `make_taggable` calls define `<context>_from` correctly; `Ownership.included` re-runs on every call. |
+| #576 | Adding a tag in a second context does not delete the first context's taggings. |
+| #867 | Chaining `tagged_with` with the same tag produces one join — Active Record dedupes the identical alias. |
+| #1033 | `tagged_with(..., exclude: true)` returns the same result on a relation as on the class. |
+| #946 | `remove_unused_tags` behaves as documented; re-tagging after a removal works. |
+| #1023 | Ordered taggable + owner works. Our `order` argument is a bare `taggings.id`, which Active Record accepts. |
+| #1099 | `upsert_all` on a taggable model works. |
+| #395 | The `merge` symptom is #936's `select(all_fields)`, already listed. Not separately actionable. |
+| #300 (part) | `find_related_*.blank?` works; only `.count` is broken (listed as #300/#907). |
+| #455, #603 | Caching is documented — `docs/caching.md`. |
+| #848 | The array form of the strong parameter is documented in `docs/getting-started.md`. |
+| #981 | Docs already use `rails make_taggable_engine:install:migrations`, not `rake`. |
+| #885 | `docs/ownership.md` builds owned lists from `locations_from(user)`, not `all_tags_list`, so the cascade the issue describes can't happen. |
+| #754 | `tagged_with` parsing its argument is documented on the method. |
+
+## Unverified — needs a PostgreSQL or MySQL run
+
+| Upstream | What to check |
+|---|---|
+| #852 | `tag_counts_on` on a relation built with `includes(...).where(other_table: ...)` → "subquery has too many columns". Our `generate_tagging_scope_in_clause` does `except(:select).select(pkey)`, which may already fix it. |
+| #1026 | `find_related_*` groups by every column on PostgreSQL; a `json` column has no equality operator and breaks `GROUP BY`. `Related#group_columns` still does this. |
+| #1069 | Ambiguous column on `.count` with a joined scope. Did not reproduce on SQLite. |
+| #1100 | "no implicit conversion of nil into String" on update — no reproduction in the issue. |
+| #1103 | Ownership with `acts_as_tenant`: owned taggings created through `taggings.create!` and destroyed through a bare `Tagging.where(...)` may bypass the tenant scope. |
+| #810 | Ordering against `acts_as_nested_set` — depends on callback order in the host app. |
+| #657 | The PostgreSQL index-miss half of #1028; needs an `EXPLAIN` on a real table. |
+| #915 | The integer-vs-varchar join half (separate from the primary-key bug above). |
+
+---
+
+## Suggested order of work
+
+1. **#1044** — a `SyntaxError` at class-load time. Cheapest fix (validate the context name, or reject it with a clear error) and the worst failure mode.
+2. **#915/exclude** — `ExcludeTagsQuery` hardcoding `:id`. One-line fix, silently wrong today.
+3. **#701, #630** — `:exclude` ignoring context and the empty-list short circuit. Both are wrong *answers*, not errors.
+4. **#402/#993** — duplicate rows from `tagged_with`. Needs a decision on `DISTINCT` vs. a subquery.
+5. **#692/#1109/#530, #936, #1094** — the `AnyTagsQuery` select and the `AllTagsQuery` order. `.count` not working on a documented query option is a hard edge.
+6. **#1139, #1047, #373** — small, self-contained `TagList` fixes.
+7. **#1176, #1128** — stop `save_tags` loading `taggings` when nothing was assigned.
+8. **#1024/#1064/#1029, #1155** — the `attribute :tag_list` design. The largest change; worth its own discussion.

data/AATO_UPSTREAM_COMMIT_REVIEW.md

@@ -0,0 +1,74 @@
+# Upstream commits since the fork point — what's worth pulling
+
+## Fork point
+
+`make_taggable`'s history starts at a squashed "Initial commit" (7698fe0, 2020-11-16) with no
+shared ancestry, so the base had to be recovered by matching blobs. The fork's initial tree is
+**upstream v6.5.0** (`6b38c652`, 2019-10-29) — 62 of 75 Ruby/Markdown files match that tree
+exactly, and the bundled `CHANGELOG.md` stops at the v6.5.0 release notes.
+
+Since then upstream has 93 commits (v7.0.0 → v13.0.0), of which **39 touch `lib/` or `db/`**.
+Everything below is that 39, reviewed one by one.
+
+## The important negative result
+
+**Upstream has not fixed any of the 29 confirmed bugs from the issue triage.** I checked HEAD
+(`4d58c53`) directly:
+
+- `ExcludeTagsQuery#tags_not_in_list` still hardcodes `taggable_arel_table[:id]`
+- `AnyTagsQuery#build` still calls `select(all_fields)`
+- `AllTagsQuery#order_conditions` still passes a raw string to `.order` without `Arel.sql`
+
+So there is no shortcut: that backlog is ours to fix either way. What upstream *does* have that we
+don't is a handful of small correctness fixes and three features.
+
+---
+
+## Worth pulling — correctness
+
+| Upstream | What it fixes | Status here |
+|---|---|---|
+| **12f08be** (#1081, v10) | `find_or_create_all_with_like_by_name` issues a raw `ActiveRecord::Base.connection.execute "ROLLBACK"` when it hits `RecordNotUnique`. That breaks any enclosing transaction and ignores multiple-database setups. Upstream replaced it with `transaction(requires_new: true) { create(...) }`. | **We still have the raw ROLLBACK.** Highest-value pull on this list — it corrupts caller transactions, and our own spec suite runs inside a transaction. |
+| **426d960 + a0cadfb** | `remove_unused_tags` handling when the counter cache is off, and avoiding a needless `tag.reload`. | **Ours is worse than upstream's pre-fix state.** `MakeTaggable.remove_unused_tags` is gated on `&& MakeTaggable.tags_counter`, so with `tags_counter = false` the setting silently does nothing. Verified: orphan tag survives. This is upstream issue #946 arriving by a different route. |
+| **2a8acc1** (#1065) | `using_postgresql?` matches only `"PostgreSQL"`, so the PostGIS adapter falls through to the MySQL/generic path — `LIKE` instead of `ILIKE`, and the wrong `GROUP BY` strategy. | Absent. One-line fix: `%w[PostgreSQL PostGIS].include?(adapter_name)`. |
+| **38fb4d2 / b915ca8** | `Utils.connection` uses the model-level `.connection`, soft-deprecated in Rails 7.2 in favour of `lease_connection`. | Absent. Worth taking since our floor is already AR 7.2 — go straight to `lease_connection`, no fallback branch needed. Note: I did **not** observe an actual deprecation warning on AR 8.1.3, so this is hygiene, not breakage. |
+| **1df5ac3** | Upstream dropped four single-column indexes on `taggings` as redundant against the composite ones. | **Applies, and ours is worse.** Our migrations produce **12 indexes** on `taggings`. At least five are dead weight: `tag_id` (prefix of `taggings_idx`), `taggable_id` (prefix of `taggings_taggable_context_idx`), `taggable_type`, `tagger_id` (prefix of the tagger pair), and we create the tagger pair **in both column orders** (`index_taggings_on_tagger_id_and_tagger_type` *and* `index_taggings_on_tagger_type_and_tagger_id`, the latter from `t.references`). Every tagging insert pays for all of them. |
+
+## Worth pulling — features
+
+| Upstream | Feature | Note |
+|---|---|---|
+| **2014fcc** (#1082, v10) | `wild: :prefix` / `wild: :suffix` in addition to `wild: true`. | Small and self-contained, and it partly answers issue #1028: a suffix match (`foo%`) can use a plain btree index, where `%foo%` never can. |
+| **52d7dae** (#1053, v9) | `all_tag_counts(id: [...])` accepts an array of taggable ids, not just one. | Lets a caller compute tag counts for a page of records in one query instead of N. Cheap to take. |
+| **b4eed9b + 8ba7fee** (v9/v10) | A `base_class` config so `Tag` and `Tagging` inherit from the host's `ApplicationRecord` instead of `::ActiveRecord::Base` — needed for horizontally sharded / multi-database apps. 8ba7fee then changed it to a **String** because Zeitwerk won't let you reference a model constant at initializer time. | If we take this, take both commits: the String form is the correct one. Also relevant to issue #1103 (ownership + tenancy). |
+| **7e696e3 + 4a7948e + e2d211b + 5d86cce** (v8) | A `tenant` column on `taggings`, `acts_as_taggable_tenant`, `Tag.for_tenant`, `Tagging.by_tenant`. | The largest item here — a migration plus API surface. Directly addresses issue #1103. I'd treat this as a "do we want it?" product decision rather than a pull; it overlaps with what `acts_as_tenant` already does in the host app. |
+
+## Not worth pulling
+
+| Upstream | Why not |
+|---|---|
+| **47da503** (case-sensitivity third arg to `matches`) | **Already present.** Our `query_base.rb` passes `MakeTaggable.strict_case_match`. |
+| **b54771d** (`force_encoding('BINARY')` removal) | **Already present** — we fixed this independently in 1.0.0 and the CHANGELOG records it. |
+| **f18679a** (drop `mb_chars` / `unicode_downcase`) | **Already present** — our `Tag` uses `name.to_s.downcase`. |
+| **31f29c9** (caching always on) | This deletes the lazy `columns` interception that upstream themselves added in PR #911 to avoid clobbering a host's own `columns` override. Our `Cache::Columns` is the better design and we have a spec for it (`ColumnsOverrideModel`). Taking this would be a regression. |
+| **93fd6d2, a54cc54, bdb86da** (v11 `ActiveSupport::Concern` / Zeitwerk refactors) | Pure restructuring of code we have already restructured differently in 1.0.0. No behaviour change. |
+| **380c0bc** (combine migrations into one) | Upstream folded migrations 1–7 into a single idempotent `SetupActsAsTaggableOn`. Tempting, but our six-migration chain is already published and 1.1.0 just added migration 6 — collapsing them now would break `install:migrations` for existing installs for no functional gain. Take the *index trimming* from 1df5ac3 without the consolidation. |
+| **89a4d7f, 37bfebc, 4c49575, cfd6e06, 866c38f, 46c4e2d, f7bfad9, 69e6bff, b1d7651, 6fa6b55, 8548529, e0f859e, 6fbd9d1, b7122b9, 25266d6, 954e7ce** | Release commits, CI/docker chores, formatting, Ruby 2.7 / Rails 6.1 / Rails 8 compatibility we already exceed, and migration-syntax cleanups against migration files we don't share. |
+
+---
+
+## Recommendation
+
+Four small commits are worth taking more or less as-is, and they're cheap:
+
+1. **12f08be** — the raw `ROLLBACK` (correctness, affects callers' transactions)
+2. **remove_unused_tags with `tags_counter = false`** (our own regression, upstream-adjacent)
+3. **2a8acc1** — PostGIS adapter detection
+4. **1df5ac3-style index trim** — but sized to our 12-index reality, as a *new* migration 7 that drops the redundant ones rather than by editing migration 5
+
+Then **2014fcc** (`wild: :prefix`/`:suffix`) and **52d7dae** (array `:id`) as easy feature wins.
+
+`base_class` and the tenant feature are both real decisions rather than pulls — worth discussing
+before either lands.
+
+None of this changes the issue triage: the 29 confirmed bugs have no upstream fix to inherit.

data/CHANGELOG.md

@@ -5,6 +5,100 @@ All notable changes to this project are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.0] - 2026-08-23
+
+### Fixed
+
+- `find_related_*` raised on `.count`. The relation selects the taggable's columns plus an aliased
+  count, and Active Record folded that select list into the `COUNT()` it built. It now counts the
+  grouped query as a subquery, so `.count` and `.size` return the number of related records.
+
+- `find_related_*` raised on PostgreSQL for any taggable model with a `json` column -- the query
+  grouped by every column on the table, and `json` has no equality operator so it cannot appear in
+  a `GROUP BY`. It now groups by the primary key on every adapter, which is what the other adapters
+  already did. `jsonb` was never affected, so the column type an application picked decided whether
+  the feature worked at all.
+
+- `TagList` could not be serialised to YAML. Every list carried its parser in an instance variable,
+  and that variable holds a Class, which Psych refuses to dump. Anything serialising a model's
+  attributes hit it -- change-history gems, Active Job arguments, `serialize` columns. The parser is
+  no longer stored; the reader falls back to the configured `MakeTaggable.default_parser`. One
+  consequence: a list now follows the configured parser rather than the one in force when it was
+  built.
+
+- `TagList#remove` ignored a symbol. `remove(:foo)` silently did nothing where `remove("foo")`
+  worked.
+
+- A tag that failed validation was reported as `Tag can't be blank`, naming the wrong attribute for
+  the wrong reason -- reachable with no customisation, since the shipped `Tag` validates name length
+  at 255 characters. The error now carries the tag itself, so it says what was actually wrong and
+  `error.record` is the tag. `save!` raises; `save` still returns `false` and writes nothing.
+
+- Saving a taggable read every tagging on the record, on every save, before establishing whether
+  any tag list had been assigned. That cost a query per save and made the gem unusable under
+  `strict_loading` -- a record whose tags were never touched still raised
+  `StrictLoadingViolationError`. Saves now consider only the contexts held in memory.
+
+### Changed
+
+- **Tag lists are no longer declared as Active Model attributes.** The declaration is what gave them
+  dirty tracking, and it also made Active Record treat them as columns where they are not. The dirty
+  API is unchanged -- `tag_list_changed?`, `_was`, `_change`, `will_save_change_to_*`,
+  `saved_change_to_*`, and the tag lists still appear in `changes` -- but it now runs on the gem's
+  own bookkeeping.
+
+  Three visible consequences, each of them the point:
+
+  - `as_json` no longer includes tag lists, so serialising a collection no longer queries once per
+    record. Serialising three records went from 16 queries to 1. Ask for a list explicitly with
+    `as_json(methods: :tag_list)`.
+  - `attributes` no longer carries a `tag_list` key. It previously held `nil` while `tag_list`
+    returned the tags.
+  - `upsert_all` still refuses a tag list -- it writes columns, and a tag list means writing
+    taggings -- but `as_json` output can now be round-tripped through it, which it could not before.
+
+  `MakeTaggable::Taggable::TagListType` is removed. It backed the attribute and has no other caller.
+
+### Fixed
+
+- `tag_ids = []` silently did nothing once `as_json` had been called on the record.
+
+- Mutating a list in place -- `record.tag_list.add("x")` -- did not mark the record as changed, so
+  `tag_list_changed?` stayed false and anything conditioned on it never ran. The list still saved;
+  what was wrong was everything that asks the record what changed.
+
+## [1.3.0] - 2026-08-23
+
+### Changed
+
+- **`tagged_with` no longer joins the taggings table.** It tests for each tag with an `EXISTS`
+  subquery instead, which is what stops a record being returned once per matching tagging. A tag
+  applied in two contexts, or a `:wild` pattern matching two of a record's tags, returned that
+  record twice; `.count` disagreed with the number of records, and pagination pages ran short.
+
+  The consequence for callers is that a `taggings` column is no longer in scope on the relation, so
+  `tagged_with("x").order("taggings.created_at")` or a `group` on a taggings column now needs an
+  explicit `.joins(:taggings)`. See [docs/querying.md](docs/querying.md).
+
+  Matching a dozen tags now produces a dozen correlated subqueries rather than a dozen joins.
+  `:match_all` is unchanged and keeps its join.
+
+### Fixed
+
+- `tagged_with(..., any: true)` forced `SELECT taggable_models.*` onto the relation. That made
+  `.count` emit `COUNT("table".*)`, which no adapter accepts, and left a caller's own `select`
+  appended after the star rather than replacing it -- so every column came back regardless, and the
+  relation could not be used inside a `merge`. The strategy filters with an `EXISTS` subquery and
+  joins nothing, so Active Record's default select list was already right.
+
+- `:order_by_matching_tag_count` raised on the default all-tags path, and the expression behind it
+  was invalid SQL that would have ordered nothing even where it parsed. Both strategies now share
+  the correlated count the `:any` path has always used, so the option orders correctly on either.
+  It still has no effect alongside `:match_all`.
+
+- `tagged_with(..., exclude: true)` ignored `:start_at` and `:end_at`, excluding records on the
+  strength of taggings from outside the window entirely.
+
 ## [1.2.1] - 2026-08-23
 
 ### Fixed

data/docs/contexts.md

@@ -30,16 +30,40 @@ with Active Support's inflector, so `:skills` gives `skill_list` and `skills`.
 | `find_related_skills_for(klass)` | instance | The same, against another model |
 | `caching_skill_list?` | class | Whether this context is cached in a column |
 
-`skill_list` takes part in dirty tracking like any other attribute:
+`skill_list` takes part in dirty tracking:
 
 ```ruby
 user.skill_list = "diving"
-user.skill_list_changed?          # => true
-user.skill_list_was               # => ["jogging"]
-user.skill_list_change            # => [["jogging"], ["diving"]]
-user.will_save_change_to_skill_list?
+user.skill_list_changed?             # => true
+user.skill_list_was                  # => ["jogging"]
+user.skill_list_change               # => [["jogging"], ["diving"]]
+user.will_save_change_to_skill_list?  # => true
+user.changes                          # => {"skill_list" => [["jogging"], ["diving"]]}
+user.save
+user.saved_change_to_skill_list?      # => true
+```
+
+Mutating the list in place counts too, not just assigning a new one:
+
+```ruby
+user.skill_list.add("diving")
+user.skill_list_changed?   # => true
 ```
 
+Order counts only where the model asked for it with `make_ordered_taggable`. Reordering the same
+tags is not a change otherwise.
+
+A tag list is **not** an Active Record attribute, though, and the difference shows in three places:
+
+```ruby
+user.attributes["skill_list"]   # => nil, and the key is absent -- use user.skill_list
+user.as_json                    # no "skill_list" key; ask for it with as_json(methods: :skill_list)
+User.upsert_all([{skill_list: "diving"}])   # raises -- upsert_all writes columns, and this is not one
+```
+
+Leaving tag lists out of `as_json` is deliberate: a list is loaded from the taggings table, so
+including it meant serialising a collection queried once per record.
+
 ### Naming a context
 
 Because the context becomes part of every name in the table above, it has to be usable as a Ruby

data/docs/database.md

@@ -156,3 +156,20 @@ or set `MakeTaggable.strict_case_match = true` so the behaviour is at least cons
 
 `name` is validated at 255 characters, and the column is a `string`. Tags longer than that fail
 validation rather than being truncated.
+
+A tag that cannot be saved fails the save of the record being tagged. `save!` raises
+`ActiveRecord::RecordInvalid` carrying the **tag**, so the error says what was wrong with it and
+`error.record` is the tag itself; `save` returns `false` and writes nothing.
+
+The same applies to a `Tag` subclass with validations of its own:
+
+```ruby
+class PickyTag < MakeTaggable::Tag
+  validate { errors.add(:name, "must not be rude") if name.to_s.include?("rude") }
+end
+
+article.save!
+# => ActiveRecord::RecordInvalid: Validation failed: Name must not be rude
+```
+
+See [contexts.md](contexts.md) for wiring a `Tag` subclass to a context.

data/docs/querying.md

@@ -30,9 +30,9 @@ empty relation rather than every record — worth knowing when the tags come fro
 | `:wild` | Match tags *containing* the given text, i.e. `%sci%` |
 | `:on` | Restrict to one context. Honoured by every option, `:exclude` included |
 | `:owned_by` | Restrict to tags applied by one tagger |
-| `:order_by_matching_tag_count` | With `:any`, order by how many tags matched, most first |
-| `:start_at` | Only tags applied after this time |
-| `:end_at` | Only tags applied before this time |
+| `:order_by_matching_tag_count` | Order by how many matching taggings a record has, most first. No effect with `:match_all` |
+| `:start_at` | Only tags applied after this time. Honoured by every option, `:exclude` included |
+| `:end_at` | Only tags applied before this time. Honoured by every option, `:exclude` included |
 
 An empty tag list means "nothing matches" for the matching options and "nothing is ruled out" for
 `:exclude`, so the two always partition the scope between them:
@@ -162,10 +162,27 @@ MakeTaggable::Tag.for_context(:skills) # used in this context, on any model
 query time. If you set `MakeTaggable.tags_counter = false` that counter is not maintained and both
 scopes will be wrong.
 
+## Grouping and ordering by tagging columns
+
+`tagged_with` does not join the taggings table, so a `taggings` column is not in scope on the
+relation it returns. Join it yourself when you need one:
+
+```ruby
+Book.tagged_with("sci-fi").joins(:taggings).group("taggings.context").count
+Book.tagged_with("sci-fi").joins(:taggings).order("taggings.created_at desc")
+```
+
+Note that joining reintroduces one row per tagging, which is exactly what `tagged_with` avoids on
+its own — add `.distinct` if you want records back rather than matches.
+
 ## Performance notes
 
-- `tagged_with` with several tags and no `:any` adds one join per tag. Matching a dozen tags in a
-  single call generates a dozen joins; prefer `any: true` where the semantics allow it.
+- `tagged_with` tests for each tag with an `EXISTS` subquery, one per tag, and joins nothing. That
+  is what stops a record being returned once per matching tagging. Matching a dozen tags produces a
+  dozen correlated subqueries rather than a dozen joins, which most planners handle better, but it
+  is still worth reaching for `any: true` where the semantics allow it.
+- Saving a taggable reads nothing from the taggings table unless a tag list was actually assigned,
+  so a save that touches no tags costs no extra query and works under `strict_loading`.
 - `:order_by_matching_tag_count` adds a correlated subquery to the `ORDER BY`. It is fine for a
   page of results and expensive across a whole table.
 - `all_tag_counts` joins the taggables to count them. Reach for `all_tags` when the counts are not

data/lib/make_taggable/tag_list.rb

@@ -24,7 +24,7 @@ module MakeTaggable
   #
   class TagList < Array
     attr_accessor :owner
-    attr_accessor :parser
+    attr_writer :parser
 
     ##
     # Builds a tag list from the given names.
@@ -34,10 +34,26 @@ module MakeTaggable
     # @return [MakeTaggable::TagList]
     #
     def initialize(*args)
-      @parser = MakeTaggable.default_parser
       add(*args)
     end
 
+    ##
+    # The parser this list uses when asked to parse.
+    #
+    # Falls back to the configured {MakeTaggable.default_parser}, and deliberately does not store
+    # it. A stored parser is a Class held in an instance variable, and Psych validates instance
+    # variables when dumping, so carrying one made every tag list unserialisable -- `audited`,
+    # Active Job arguments and `serialize` columns all refuse it.
+    #
+    # A parser assigned explicitly is still stored, and a list carrying one is subject to the same
+    # limitation.
+    #
+    # @return [Class]
+    #
+    def parser
+      @parser || MakeTaggable.default_parser
+    end
+
     ##
     # Adds tags to the list, ignoring duplicates and blanks.
     #
@@ -101,6 +117,13 @@ module MakeTaggable
     #
     def remove(*names)
       extract_and_apply_options!(names)
+
+      # The list holds strings, so compare strings. Everything else that takes
+      # tag names normalises them -- add runs them through clean!, tagged_with
+      # parses them -- and a symbol silently matching nothing here was the odd
+      # one out.
+      names = names.map(&:to_s)
+
       delete_if { |name| names.include?(name) }
       self
     end
@@ -145,9 +168,9 @@ module MakeTaggable
       options = args.last.is_a?(Hash) ? args.pop : {}
       options.assert_valid_keys :parse, :parser
 
-      parser = options[:parser] || @parser
+      chosen_parser = options[:parser] || parser
 
-      args.map! { |a| parser.new(a).parse } if options[:parse] || options[:parser]
+      args.map! { |a| chosen_parser.new(a).parse } if options[:parse] || options[:parser]
 
       args.flatten!
     end

data/lib/make_taggable/taggable/core.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "tagged_with_query"
-require_relative "tag_list_type"
 
 module MakeTaggable::Taggable
   ##
@@ -58,8 +57,6 @@ module MakeTaggable::Taggable
               class_name: "MakeTaggable::Tag",
               through: context_taggings,
               source: :tag
-
-            attribute :"#{tags_type.singularize}_list", MakeTaggable::Taggable::TagListType.new
           end
 
           taggable_mixin.class_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -68,15 +65,6 @@ module MakeTaggable::Taggable
             end
 
             def #{tag_type}_list=(new_tags)
-              parsed_new_list = MakeTaggable.default_parser.new(new_tags).parse
-
-              if self.class.preserve_tag_order? || (parsed_new_list.sort != #{tag_type}_list.sort)
-                unless #{tag_type}_list_changed?
-                  @attributes["#{tag_type}_list"] = ActiveModel::Attribute.from_user("#{tag_type}_list", #{tag_type}_list, MakeTaggable::Taggable::TagListType.new)
-                end
-                write_attribute("#{tag_type}_list", parsed_new_list)
-              end
-
               set_tag_list_on('#{tags_type}', new_tags)
             end
 
@@ -84,9 +72,33 @@ module MakeTaggable::Taggable
               all_tags_list_on('#{tags_type}')
             end
 
+            def #{tag_type}_list_changed?
+              tag_list_changed_on?('#{tags_type}')
+            end
+
+            def #{tag_type}_list_was
+              tag_list_was_on('#{tags_type}')
+            end
+
+            def #{tag_type}_list_change
+              tag_list_change_on('#{tags_type}')
+            end
+
+            def will_save_change_to_#{tag_type}_list?
+              tag_list_changed_on?('#{tags_type}')
+            end
+
+            def saved_change_to_#{tag_type}_list
+              saved_tag_list_changes['#{tag_type}_list']
+            end
+
+            def saved_change_to_#{tag_type}_list?
+              saved_tag_list_changes.key?('#{tag_type}_list')
+            end
+
             private
             def dirtify_tag_list(tagging)
-              attribute_will_change! tagging.context.singularize+"_list"
+              tag_list_changed_by_association(tagging.context)
             end
           RUBY
         end
@@ -123,8 +135,8 @@ module MakeTaggable::Taggable
       # @option options [TrueClass, FalseClass] :exclude match records carrying none of the tags
       # @option options [TrueClass, FalseClass] :match_all match records carrying only these tags
       # @option options [TrueClass, FalseClass] :wild match tags containing the given text
-      # @option options [TrueClass, FalseClass] :order_by_matching_tag_count with `:any`, order by
-      #   how many tags matched, most first
+      # @option options [TrueClass, FalseClass] :order_by_matching_tag_count order by how many
+      #   matching taggings a record has, most first. No effect alongside `:match_all`
       # @option options [ActiveRecord::Base] :owned_by only tags applied by this tagger
       # @option options [Symbol, String] :on only tags applied in this context
       # @option options [Time, Date] :start_at only tags applied after this time
@@ -192,7 +204,13 @@ module MakeTaggable::Taggable
     # @return [Array<String>, NilClass]
     #
     def add_custom_context(value)
-      custom_contexts << value.to_s unless custom_contexts.include?(value.to_s) || self.class.tag_types.map(&:to_s).include?(value.to_s)
+      # The declared contexts are checked first deliberately. Ruby evaluates the
+      # left operand of `||` first, so testing custom_contexts up front loaded
+      # every tagging on the record just to assign a list on an ordinary
+      # declared context.
+      return if self.class.tag_types.map(&:to_s).include?(value.to_s)
+
+      custom_contexts << value.to_s unless custom_contexts.include?(value.to_s)
     end
 
     ##
@@ -216,6 +234,151 @@ module MakeTaggable::Taggable
       instance_variable_defined?(variable_name) && instance_variable_get(variable_name)
     end
 
+    ##
+    # The tag lists as they stood when the record was loaded or last saved, keyed by context.
+    #
+    # @return [Hash{String => Array<String>}]
+    #
+    # @api private
+    #
+    def original_tag_lists
+      @original_tag_lists ||= {}
+    end
+
+    ##
+    # Records what a context's list looked like before anything touched it, if that has not been
+    # noted already. Called before every change, so the first note wins and later ones are ignored.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [void]
+    #
+    # @api private
+    #
+    def note_tag_list_original(context)
+      key = context.to_s
+      return if original_tag_lists.key?(key)
+
+      original_tag_lists[key] = tag_list_cache_on(key).to_a.dup
+    end
+
+    ##
+    # Notes the original list and drops the cached one, after a tagging was added or removed
+    # through the association rather than through a list.
+    #
+    # The cached list is what `tag_list_on` answers from, and pushing onto `record.tags` does not
+    # go near it -- so without dropping it the list before and after compare equal and nothing
+    # looks changed.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [void]
+    #
+    # @api private
+    #
+    def tag_list_changed_by_association(context)
+      note_tag_list_original(context)
+
+      singular = context.to_s.singularize
+      instance_variable_set("@#{singular}_list", nil)
+      instance_variable_set("@all_#{singular}_list", nil)
+    end
+
+    ##
+    # Whether a context's list differs from the one loaded or last saved.
+    #
+    # Order counts only where the model asked for it with `make_ordered_taggable`.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [TrueClass, FalseClass]
+    #
+    def tag_list_changed_on?(context)
+      key = context.to_s
+      return false unless original_tag_lists.key?(key)
+
+      comparable_tag_list(original_tag_lists[key]) != comparable_tag_list(tag_list_on(key))
+    end
+
+    ##
+    # A context's list as it stood when the record was loaded or last saved.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [Array<String>]
+    #
+    def tag_list_was_on(context)
+      key = context.to_s
+
+      original_tag_lists.key?(key) ? original_tag_lists[key] : tag_list_on(key).to_a
+    end
+
+    ##
+    # A context's list before and after, or `nil` when it has not changed.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [Array<Array<String>>, NilClass]
+    #
+    def tag_list_change_on(context)
+      return unless tag_list_changed_on?(context)
+
+      [tag_list_was_on(context), tag_list_on(context).to_a]
+    end
+
+    ##
+    # The tag list changes this record is carrying, keyed the way Active Model keys `changes`.
+    #
+    # @return [Hash{String => Array<Array<String>>}]
+    #
+    # @api private
+    #
+    def tag_list_changes
+      # assigned_tagging_contexts, not tagging_contexts: the latter reads the
+      # taggings table to find contexts used previously, and a record only has
+      # pending changes in contexts it holds a list for.
+      assigned_tagging_contexts.each_with_object({}) do |context, changes|
+        change = tag_list_change_on(context)
+        changes["#{context.to_s.singularize}_list"] = change if change
+      end
+    end
+
+    ##
+    # The tag list changes written by the most recent save.
+    #
+    # @return [Hash{String => Array<Array<String>>}]
+    #
+    # @api private
+    #
+    def saved_tag_list_changes
+      @saved_tag_list_changes ||= {}
+    end
+
+    ##
+    # Active Model's changes, plus the tag lists.
+    #
+    # @return [ActiveSupport::HashWithIndifferentAccess]
+    #
+    def changes
+      super.merge(tag_list_changes)
+    end
+
+    ##
+    # @return [Hash] the previous values of everything changed, tag lists included
+    #
+    def changed_attributes
+      super.merge(tag_list_changes.transform_values(&:first))
+    end
+
+    ##
+    # @return [TrueClass, FalseClass] whether anything changed, tag lists included
+    #
+    def changed?
+      super || tag_list_changes.any?
+    end
+
+    ##
+    # @return [Hash] the changes the last save wrote, tag lists included
+    #
+    def saved_changes
+      super.merge(saved_tag_list_changes)
+    end
+
     ##
     # A context's tag list, loading it from the caching column or the database as needed.
     #
@@ -224,13 +387,22 @@ module MakeTaggable::Taggable
     #
     def tag_list_cache_on(context)
       variable_name = "@#{context.to_s.singularize}_list"
-      if instance_variable_get(variable_name)
-        instance_variable_get(variable_name)
-      elsif cached_tag_list_on(context) && ensure_included_cache_methods! && self.class.caching_tag_list_on?(context)
-        instance_variable_set(variable_name, MakeTaggable.default_parser.new(cached_tag_list_on(context)).parse)
-      else
-        instance_variable_set(variable_name, MakeTaggable::TagList.new(tags_on(context).map(&:name)))
-      end
+      return instance_variable_get(variable_name) if instance_variable_get(variable_name)
+
+      list =
+        if cached_tag_list_on(context) && ensure_included_cache_methods! && self.class.caching_tag_list_on?(context)
+          MakeTaggable.default_parser.new(cached_tag_list_on(context)).parse
+        else
+          MakeTaggable::TagList.new(tags_on(context).map(&:name))
+        end
+
+      # Note what was there the first time the list is built, before anything
+      # can have touched it. A caller holding this list can mutate it in place
+      # -- tag_list.add("x") -- which never goes through the writer, so this is
+      # the only chance to see the original.
+      original_tag_lists[context.to_s] ||= list.to_a.dup
+
+      instance_variable_set(variable_name, list)
     end
 
     ##
@@ -303,6 +475,10 @@ module MakeTaggable::Taggable
     def set_tag_list_on(context, new_list)
       add_custom_context(context)
 
+      # Before the list is replaced, so the note captures what was there rather
+      # than what is being put there.
+      note_tag_list_original(context)
+
       variable_name = "@#{context.to_s.singularize}_list"
 
       parsed_new_list = MakeTaggable.default_parser.new(new_list).parse
@@ -319,6 +495,23 @@ module MakeTaggable::Taggable
       self.class.tag_types.map(&:to_s) + custom_contexts
     end
 
+    ##
+    # The contexts a save has to consider: the declared ones, plus any context this record has
+    # been handed a list for in memory.
+    #
+    # Deliberately not {#tagging_contexts}, which reads the taggings table to find contexts used
+    # previously. A save only writes lists held in memory, so the ones already loaded are the only
+    # ones that can have anything to write -- and reading the table on every save cost a query
+    # whether or not any tag changed, and broke `strict_loading` outright.
+    #
+    # @return [Array<String>]
+    #
+    # @api private
+    #
+    def assigned_tagging_contexts
+      self.class.tag_types.map(&:to_s) + (@custom_contexts || [])
+    end
+
     ##
     # Reloads the record, discarding the tag lists held in memory.
     #
@@ -346,7 +539,7 @@ module MakeTaggable::Taggable
     # @return [TrueClass]
     #
     def save_tags
-      tagging_contexts.each do |context|
+      assigned_tagging_contexts.each do |context|
         next unless tag_list_cache_set_on(context)
 
         # List of currently assigned tag names
@@ -355,6 +548,13 @@ module MakeTaggable::Taggable
         # Find existing tags or create non-existing tags:
         tags = find_or_create_tags_from_list_with_context(tag_list, context)
 
+        # A tag that failed its own validation comes back unsaved, with a nil
+        # id. Left alone it reaches taggings.create! as `tag_id: nil`, and the
+        # caller is told "Tag can't be blank" -- the wrong attribute, and no
+        # sign of what was actually wrong. Report the tag itself instead.
+        unsaved = tags.reject(&:persisted?)
+        raise ActiveRecord::RecordInvalid.new(unsaved.first) if unsaved.any?
+
         # Tag objects for currently assigned tags
         current_tags = tags_on(context)
 
@@ -393,25 +593,27 @@ module MakeTaggable::Taggable
         end
       end
 
+      settle_tag_list_changes
+
       true
     end
 
-    private
-
-    def ensure_included_cache_methods!
-      self.class.columns
+    # Moves the pending tag list changes into the saved ones, so that after a
+    # save the record reports what the save wrote rather than what it was about
+    # to write. Mirrors what Active Model does for real attributes.
+    def settle_tag_list_changes
+      @saved_tag_list_changes = tag_list_changes
+      original_tag_lists.clear
     end
 
-    # Filters the tag lists from the attribute names.
-    def attributes_for_update(attribute_names)
-      tag_lists = tag_types.map { |tags_type| "#{tags_type.to_s.singularize}_list" }
-      super.delete_if { |attr| tag_lists.include? attr }
+    private
+
+    def comparable_tag_list(list)
+      self.class.preserve_tag_order? ? list.to_a : list.to_a.sort
     end
 
-    # Filters the tag lists from the attribute names.
-    def attributes_for_create(attribute_names)
-      tag_lists = tag_types.map { |tags_type| "#{tags_type.to_s.singularize}_list" }
-      super.delete_if { |attr| tag_lists.include? attr }
+    def ensure_included_cache_methods!
+      self.class.columns
     end
 
     ##

data/lib/make_taggable/taggable/ownership.rb

@@ -164,7 +164,7 @@ module MakeTaggable::Taggable
     # @return [TrueClass]
     #
     def save_owned_tags
-      tagging_contexts.each do |context|
+      assigned_tagging_contexts.each do |context|
         cached_owned_tag_list_on(context).each do |owner, tag_list|
           # Find existing tags or create non-existing tags:
           tags = find_or_create_tags_from_list_with_context(tag_list.uniq, context)

data/lib/make_taggable/taggable/related.rb

@@ -115,12 +115,15 @@ module MakeTaggable::Taggable
       "#{klass.arel_table[klass.primary_key].not_eq(id).to_sql} AND" if [self.class.base_class, self.class].include? klass
     end
 
+    # Grouping by the primary key alone is enough on every adapter we support.
+    #
+    # PostgreSQL used to need every selected non-aggregated column listed here,
+    # which is why this branched. Since 9.1 it works the functional dependency
+    # out from the primary key on its own, and listing every column actively
+    # breaks a model with a `json` column -- json has no equality operator, so
+    # it cannot appear in a GROUP BY at all.
     def group_columns(klass)
-      if MakeTaggable::Utils.using_postgresql?
-        grouped_column_names_for(klass)
-      else
-        "#{klass.table_name}.#{klass.primary_key}"
-      end
+      "#{klass.table_name}.#{klass.primary_key}"
     end
 
     def related_where(klass, conditions)
@@ -129,6 +132,42 @@ module MakeTaggable::Taggable
         .group(group_columns(klass))
         .order("count DESC")
         .where(conditions)
+        .extending(CalculationMethods)
+    end
+
+    # These relations select the taggable's columns plus an aliased count, and
+    # order by that alias. Active Record folds the select list into the COUNT()
+    # it builds, which produced SQL no adapter accepts:
+    #
+    #   SELECT COUNT(taggable_models.*, COUNT(tags.id) AS count) ...
+    #
+    # Counting rows instead is not enough on its own either: the relation groups
+    # by primary key over a cross join, so dropping the grouping counts taggings
+    # rather than records, and the ORDER BY still names an alias that a bare
+    # COUNT(*) no longer selects.
+    #
+    # So count the grouped query as a subquery. `klass.unscoped` is the shell
+    # for it because it carries no extension of its own -- counting a relation
+    # derived from this one would re-enter this method.
+    module CalculationMethods
+      ##
+      # The number of related records.
+      #
+      # @param column_name [Symbol, String] accepted for signature compatibility; ignored
+      # @return [Integer]
+      #
+      def count(column_name = :all)
+        ids = except(:select, :order).select(Arel.sql("#{klass.table_name}.#{klass.primary_key}"))
+
+        klass.unscoped.from(Arel.sql("(#{ids.to_sql}) AS #{klass.table_name}_related")).count(:all)
+      end
+
+      ##
+      # @return [Integer] the number of related records
+      #
+      def size
+        loaded? ? to_a.size : count
+      end
     end
   end
 end

data/lib/make_taggable/taggable/tagged_with_query/all_tags_query.rb

@@ -11,63 +11,72 @@ module MakeTaggable::Taggable::TaggedWithQuery
     # @return [ActiveRecord::Relation]
     #
     def build
-      taggable_model.joins(each_tag_in_list)
+      taggable_model.joins(match_all_join)
+        .where(carries_every_tag)
         .group(by_taggable)
         .having(tags_that_matches_count)
-        .order(order_conditions)
+        .order(Arel.sql(order_conditions))
         .readonly(false)
     end
 
     private
 
-    def each_tag_in_list
-      arel_join = taggable_arel_table
-
-      tag_list.each do |tag|
-        tagging_alias = tagging_arel_table.alias(tagging_alias(tag))
-        arel_join = arel_join
-          .join(tagging_alias)
-          .on(on_conditions(tag, tagging_alias))
-      end
-
-      if options[:match_all].present?
-        arel_join = arel_join
-          .join(tagging_arel_table, Arel::Nodes::OuterJoin)
-          .on(
-            match_all_on_conditions
-          )
-      end
+    # One EXISTS test per tag, rather than one join per tag.
+    #
+    # A join multiplies the result: a record is returned once for every tagging
+    # that satisfies it, so a tag applied in two contexts, or a wild pattern
+    # matching two of a record's tags, returned that record twice. EXISTS asks
+    # the question the query is actually asking -- does this record carry the
+    # tag -- and answers it once.
+    def carries_every_tag
+      tag_list.map { |tag| taggings_for(tag).exists }.inject(:and)
+    end
 
-      arel_join.join_sources
+    def taggings_for(tag)
+      tagging_arel_table
+        .project(Arel.star)
+        .where(tag_conditions(tag))
     end
 
-    def on_conditions(tag, tagging_alias)
-      on_condition = tagging_alias[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
-        .and(tagging_alias[:taggable_type].eq(taggable_model.base_class.name))
+    def tag_conditions(tag)
+      condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+        .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
         .and(
-          tagging_alias[:tag_id].in(
+          tagging_arel_table[:tag_id].in(
             tag_arel_table.project(tag_arel_table[:id]).where(tag_match_type(tag))
           )
         )
 
       if options[:start_at].present?
-        on_condition = on_condition.and(tagging_alias[:created_at].gteq(options[:start_at]))
+        condition = condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
       end
 
       if options[:end_at].present?
-        on_condition = on_condition.and(tagging_alias[:created_at].lteq(options[:end_at]))
+        condition = condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
       end
 
       if options[:on].present?
-        on_condition = on_condition.and(tagging_alias[:context].eq(options[:on]))
+        condition = condition.and(tagging_arel_table[:context].eq(options[:on]))
       end
 
       if (owner = options[:owned_by]).present?
-        on_condition = on_condition.and(tagging_alias[:tagger_id].eq(owner.id))
-          .and(tagging_alias[:tagger_type].eq(owner.class.base_class.to_s))
+        condition = condition.and(tagging_arel_table[:tagger_id].eq(owner.id))
+          .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
       end
 
-      on_condition
+      condition
+    end
+
+    # :match_all keeps its outer join. It counts a record's taggings and compares
+    # that to the number of tags matched, so it needs them joined -- and the
+    # GROUP BY it already carries collapses the duplicates a join would cause.
+    def match_all_join
+      return [] unless options[:match_all].present?
+
+      taggable_arel_table
+        .join(tagging_arel_table, Arel::Nodes::OuterJoin)
+        .on(match_all_on_conditions)
+        .join_sources
     end
 
     def match_all_on_conditions
@@ -107,15 +116,17 @@ module MakeTaggable::Taggable::TaggedWithQuery
 
     def order_conditions
       order_by = []
-      order_by << tagging_arel_table.project(tagging_arel_table[Arel.star].count.as("taggings_count")).order("taggings_count DESC").to_sql if options[:order_by_matching_tag_count].present? && options[:match_all].blank?
+
+      # The old expression here counted every tagging in the table, correlated
+      # to nothing, and asked for COUNT(taggings.*) while doing it -- invalid
+      # SQL that ordered nothing even where it parsed. The shared correlated
+      # count is what the :any strategy has always used.
+      if options[:order_by_matching_tag_count].present? && options[:match_all].blank?
+        order_by << matching_tag_count_order
+      end
 
       order_by << options[:order] if options[:order].present?
       order_by.join(", ")
     end
-
-    def tagging_alias(tag)
-      alias_base_name = taggable_model.base_class.name.downcase
-      adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{MakeTaggable::Utils.sha_prefix(tag)}")
-    end
   end
 end

data/lib/make_taggable/taggable/tagged_with_query/any_tags_query.rb

@@ -11,55 +11,26 @@ module MakeTaggable::Taggable::TaggedWithQuery
     # @return [ActiveRecord::Relation]
     #
     def build
-      taggable_model.select(all_fields)
-        .where(model_has_at_least_one_tag)
+      # No select of our own. This strategy filters with an EXISTS subquery and
+      # joins nothing, so Active Record's default select list is already right.
+      # Forcing `taggable_models.*` made COUNT() invalid and left a caller's own
+      # select appended after the star rather than replacing it.
+      taggable_model
+        .where(model_has_matching_taggings)
         .order(Arel.sql(order_conditions))
         .readonly(false)
     end
 
     private
 
-    def all_fields
-      taggable_arel_table[Arel.star]
-    end
-
-    def model_has_at_least_one_tag
-      tagging_arel_table.project(Arel.star).where(at_least_one_tag).exists
-    end
-
-    def at_least_one_tag
-      exists_contition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
-        .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
-        .and(
-          tagging_arel_table[:tag_id].in(
-            tag_arel_table.project(tag_arel_table[:id]).where(tags_match_type)
-          )
-        )
-
-      if options[:start_at].present?
-        exists_contition = exists_contition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
-      end
-
-      if options[:end_at].present?
-        exists_contition = exists_contition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
-      end
-
-      if options[:on].present?
-        exists_contition = exists_contition.and(tagging_arel_table[:context].eq(options[:on]))
-      end
-
-      if (owner = options[:owned_by]).present?
-        exists_contition = exists_contition.and(tagging_arel_table[:tagger_id].eq(owner.id))
-          .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
-      end
-
-      exists_contition
+    def model_has_matching_taggings
+      tagging_arel_table.project(Arel.star).where(matching_taggings).exists
     end
 
     def order_conditions
       order_by = []
       if options[:order_by_matching_tag_count].present?
-        order_by << "(SELECT count(*) FROM #{tagging_model.table_name} WHERE #{at_least_one_tag.to_sql}) desc"
+        order_by << matching_tag_count_order
       end
 
       order_by << options[:order] if options[:order].present?

data/lib/make_taggable/taggable/tagged_with_query/exclude_tags_query.rb

@@ -24,20 +24,27 @@ module MakeTaggable::Taggable::TaggedWithQuery
         .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
         .and(tags_match_type)
 
-      # Without this the subquery gathers taggings from every context, so a
-      # record tagged in one context is excluded from a query about another.
+      # Every option below narrows which taggings count as "carrying the tag".
+      # Left off, the subquery gathers taggings from other contexts and other
+      # times, and excludes records on the strength of them.
       if options[:on].present?
         on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on]))
       end
 
+      if options[:start_at].present?
+        on_condition = on_condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+      end
+
+      if options[:end_at].present?
+        on_condition = on_condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+      end
+
       taggable_arel_table[taggable_model.primary_key].not_in(
         tagging_arel_table
           .project(tagging_arel_table[:taggable_id])
           .join(tag_arel_table)
           .on(on_condition)
       )
-
-      # FIXME: missing time scope, this is also missing in the original implementation
     end
 
     def owning_to_tagger

data/lib/make_taggable/taggable/tagged_with_query/query_base.rb

@@ -61,6 +61,46 @@ module MakeTaggable::Taggable::TaggedWithQuery
       end
     end
 
+    # A condition selecting the taggings that tie a row of the taggable table to
+    # one of the tags being matched, narrowed by whichever of :on, :owned_by,
+    # :start_at and :end_at were given.
+    #
+    # It correlates to the taggable table, so it only means anything inside a
+    # subquery -- an EXISTS test, or a COUNT used for ordering.
+    def matching_taggings
+      condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+        .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+        .and(
+          tagging_arel_table[:tag_id].in(
+            tag_arel_table.project(tag_arel_table[:id]).where(tags_match_type)
+          )
+        )
+
+      if options[:start_at].present?
+        condition = condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+      end
+
+      if options[:end_at].present?
+        condition = condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+      end
+
+      if options[:on].present?
+        condition = condition.and(tagging_arel_table[:context].eq(options[:on]))
+      end
+
+      if (owner = options[:owned_by]).present?
+        condition = condition.and(tagging_arel_table[:tagger_id].eq(owner.id))
+          .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
+      end
+
+      condition
+    end
+
+    # Orders by how many of the matched taggings a row has, most first.
+    def matching_tag_count_order
+      "(SELECT count(*) FROM #{tagging_model.table_name} WHERE #{matching_taggings.to_sql}) desc"
+    end
+
     def escaped_tag(tag)
       tag = tag.downcase unless MakeTaggable.strict_case_match
       MakeTaggable::Utils.escape_like(tag)

data/lib/make_taggable/version.rb

@@ -6,5 +6,5 @@ module MakeTaggable
   #
   # @return [String]
   #
-  VERSION = "1.2.1"
+  VERSION = "1.4.0"
 end

data/lib/make_taggable.rb

@@ -47,7 +47,6 @@ module MakeTaggable
     autoload :Core
     autoload :Ownership
     autoload :Related
-    autoload :TagListType
   end
 
   autoload :Utils

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: make_taggable
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Matthew Kennedy
@@ -33,6 +33,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- AATO_ISSUE_TRIAGE.md
+- AATO_UPSTREAM_COMMIT_REVIEW.md
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - CONTRIBUTING.md
@@ -70,7 +72,6 @@ files:
 - lib/make_taggable/taggable/core.rb
 - lib/make_taggable/taggable/ownership.rb
 - lib/make_taggable/taggable/related.rb
-- lib/make_taggable/taggable/tag_list_type.rb
 - lib/make_taggable/taggable/tagged_with_query.rb
 - lib/make_taggable/taggable/tagged_with_query/all_tags_query.rb
 - lib/make_taggable/taggable/tagged_with_query/any_tags_query.rb

data/lib/make_taggable/taggable/tag_list_type.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module MakeTaggable::Taggable
-  ##
-  # The Active Model type backing each generated `*_list` attribute, so tag lists take part in
-  # dirty tracking alongside ordinary columns.
-  #
-  # @api private
-  #
-  class TagListType < ActiveModel::Type::Value
-  end
-end