make_taggable 1.1.1 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d3a7c89a48d79f6d985b8290d88007368ecdf983789a7e4881662724a1060a9
-  data.tar.gz: dda60e219b50e10b8948b6b9b260e703d8815f43bd200b1c434875144ae68071
+  metadata.gz: 99cb64f83f0cef74cc21f3fc09a341e62db5a2248b8c88ef5d720de4b9446abb
+  data.tar.gz: c3c08be5a20df6100567523555be2394dc32665770f6c65226e0fe91b3be5652
 SHA512:
-  metadata.gz: 7aa7e8b6c7190cbc8fbdcaf54fd5f49bf8f877c3161c7466e7df98eefd8f14eaa208391b47fa5a328db563d489d5e9a6f82b3bfd4b0ce770cdedbf3423f958bc
-  data.tar.gz: 0e868727368e57e72fe627cbbc4b7a4dc2077e459d6ac9131732788fec26a88037bd7ed12cb86a35f3b8308b3df7fa238319c24628f39e698c073e7d0dd8fa68
+  metadata.gz: ad8701479ff9565786acebff64af05fe5aaa88eddbcfc660f88778e4ca885a0d26438677754cfa3072dd54e3eef6374ebed4f1e4de6a70fe911824050cb0b19e
+  data.tar.gz: 47804d66800ff4df491f3b7037ba5e82c131fbaf4c9eb8442a650ed6ecbf1772483d2ae2237c5437cb8ffefca831d107744a3ffacb2c517cb65a161063bc6d0e

data/CHANGELOG.md

@@ -5,6 +5,62 @@ 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.2.1] - 2026-08-23
+
+### Fixed
+
+- `tagged_with(..., exclude: true)` raised on any model whose primary key is not `id`. The exclude
+  strategy built its `NOT IN` predicate against a hardcoded `id` column, where the other two
+  strategies already used the model's primary key.
+
+- `tagged_with(..., on: <context>, exclude: true)` ignored the context entirely, gathering taggings
+  from every context, so a record tagged in one context was excluded from a query about another.
+
+- `tagged_with([], exclude: true)` returned nothing rather than everything. Excluding no tags rules
+  nothing out, so the whole scope now stands. This restores the property that `tagged_with(list)`
+  and `tagged_with(list, exclude: true)` partition the scope between them for any list.
+
+- A tag context whose name cannot become a Ruby method name -- one starting with a digit, say --
+  raised `SyntaxError` while the model was loading, from inside Active Record's association
+  builder. Since `SyntaxError` is not a `StandardError` it slipped past application rescues.
+  Contexts are now checked as they are declared and rejected with an `ArgumentError` naming the
+  context. Non-ASCII context names keep working.
+
+### Internal
+
+- The suite's schema teardown no longer depends on the order `connection.tables` returns. MySQL
+  ignores `DROP TABLE ... CASCADE` for foreign keys, so it only worked because `taggings` happens
+  to sort before `tags`.
+
+## [1.2.0] - 2026-08-23
+
+### Fixed
+
+- `Tag.find_or_create_all_with_like_by_name` recovered from a lost race for a tag name by issuing a
+  raw `ROLLBACK`. That statement is not scoped to the failed insert -- it discarded whatever
+  transaction was open on the connection, which is nearly always one the caller opened, and on a
+  multi-database application it targeted whichever connection `ActiveRecord::Base` held rather than
+  the one the tags are on. Each insert now takes a savepoint of its own.
+
+- `remove_unused_tags` did nothing at all when `tags_counter` was off, because the check read the
+  counter cache. With the counter off it now asks the tag's taggings directly, at the cost of one
+  indexed lookup per destroyed tagging. The documentation said the setting required `tags_counter`;
+  it no longer does.
+
+- `Utils.using_postgresql?` matched only the adapter named `PostgreSQL`, so a PostGIS application
+  took the MySQL path -- `LIKE` in place of `ILIKE`, which quietly made tag matching
+  case-sensitive, and the wrong grouping strategy in `all_tags_on` and `find_related_*`.
+
+### Changed
+
+- A migration dropping five indexes from `taggings` that no query planner can reach: `tag_id`,
+  `taggable_id`, `taggable_type` and `tagger_id` on their own, each a leading column of an index
+  that remains, plus a second copy of the tagger pair in the opposite column order. Twelve indexes
+  become seven, and every one of them is maintained on insert.
+
+  Install it with `rails make_taggable_engine:install:migrations`. It is reversible -- see
+  [docs/database.md](docs/database.md).
+
 ## [1.1.1] - 2026-08-22
 
 ### Fixed

data/db/migrate/7_remove_redundant_tagging_indexes.rb

@@ -0,0 +1,38 @@
+class RemoveRedundantTaggingIndexes < ActiveRecord::Migration[7.2]
+  # Migrations 2 and 5 between them put twelve indexes on the taggings table.
+  # Five of them earn nothing: a B-tree index already answers any query that
+  # filters on a leading subset of its columns, so an index on a single column
+  # is dead weight whenever another index starts with that same column.
+  #
+  #   tag_id        -> covered by taggings_idx and taggings_unowned_idx
+  #   taggable_id   -> covered by taggings_taggable_context_idx and taggings_idy
+  #   taggable_type -> covered by index_taggings_on_taggable_type_and_taggable_id
+  #   tagger_id     -> covered by index_taggings_on_tagger_id_and_tagger_type
+  #
+  # The fifth is the tagger pair, which migration 2 and migration 5 each added
+  # in opposite column orders. One of the two is enough; the order kept is the
+  # one the library's own queries filter in, tagger_id first.
+  #
+  # Every index is maintained on insert, so this is a write-cost and a
+  # disk-footprint change, not a query-plan one. Nothing here is load-bearing:
+  # each dropped index is a prefix of one that remains.
+  REDUNDANT_COLUMNS = [
+    [:tag_id],
+    [:taggable_id],
+    [:taggable_type],
+    [:tagger_id],
+    [:tagger_type, :tagger_id]
+  ].freeze
+
+  def up
+    REDUNDANT_COLUMNS.each do |columns|
+      remove_index MakeTaggable.taggings_table, column: columns if index_exists?(MakeTaggable.taggings_table, columns)
+    end
+  end
+
+  def down
+    REDUNDANT_COLUMNS.each do |columns|
+      add_index MakeTaggable.taggings_table, columns unless index_exists?(MakeTaggable.taggings_table, columns)
+    end
+  end
+end

data/docs/configuration.md

@@ -51,14 +51,18 @@ The library avoids creating both, but data loaded another way can still contain
 
 ### `remove_unused_tags`
 
-When the last tagging referencing a tag is destroyed, the tag row is destroyed too. Requires
-`tags_counter`, since it reads the counter cache to decide.
+When the last tagging referencing a tag is destroyed, the tag row is destroyed too.
+
+This works whether or not `tags_counter` is on. With the counter cache the tag row already carries
+the count and is only re-read; without it the tag's remaining taggings are queried directly, which
+costs one extra query per destroyed tagging.
 
 ### `tags_counter`
 
 Keeps `tags.taggings_count` up to date. Turning it off avoids a write to the tags row on every
-tagging, at the cost of `Tag.most_used`, `Tag.least_used` and `remove_unused_tags`, all of which
-read that counter.
+tagging, at the cost of `Tag.most_used` and `Tag.least_used`, both of which read that counter.
+
+`remove_unused_tags` is unaffected -- it falls back to querying the tag's taggings.
 
 Changing this on an existing application leaves the existing counts frozen at their current values
 rather than resetting them.

data/docs/contexts.md

@@ -40,6 +40,23 @@ user.skill_list_change            # => [["jogging"], ["diving"]]
 user.will_save_change_to_skill_list?
 ```
 
+### Naming a context
+
+Because the context becomes part of every name in the table above, it has to be usable as a Ruby
+method and instance variable name. A context starting with a digit, or containing a hyphen or a
+space, is rejected when the model declares it:
+
+```ruby
+class Book < ActiveRecord::Base
+  make_taggable :"1categories"
+end
+# => ArgumentError: :"1categories" cannot be used as a tag context: make_taggable generates
+#    methods and instance variables from it, and "1categories_list" is not a valid Ruby name.
+```
+
+Validity is decided by asking Ruby, not by a pattern, so anything that makes a legal method name is
+allowed — non-ASCII context names included.
+
 ## Adding contexts later
 
 Calling `make_taggable` again adds contexts rather than replacing them, which is what lets a

data/docs/database.md

@@ -26,13 +26,48 @@ Both table names are configurable — see [configuration.md](configuration.md).
 
 ## Indexes
 
-The shipped migrations index `taggings` heavily: the polymorphic references index themselves, and
-migration 5 adds standalone indexes on `taggable_id`, `tagger_id`, `taggable_type` and `context`,
-plus four composites.
+Migrations 2 and 5 between them put twelve indexes on `taggings`. Migration 7 drops five of them,
+leaving seven:
 
-That suits read-heavy tagging. If your application writes taggings in bulk, the write cost is worth
-looking at — every index is maintained on insert, and several of the standalone ones are prefixes of
-composites that already exist. Drop what your queries do not use.
+| Index | Columns | Why it is there |
+|---|---|---|
+| `taggings_idx` | `tag_id, taggable_id, taggable_type, context, tagger_id, tagger_type` | Unique. Stops a tag being applied twice in the same context by the same tagger |
+| `taggings_unowned_idx` | `tag_id, taggable_id, taggable_type, context` where `tagger_id IS NULL` | Unique, partial. See below. Not created on MySQL |
+| `taggings_taggable_context_idx` | `taggable_id, taggable_type, context` | Reading one record's tags in one context |
+| `taggings_idy` | `taggable_id, taggable_type, tagger_id, context` | Reading one record's owned tags |
+| — | `taggable_type, taggable_id` | The polymorphic association lookup |
+| — | `tagger_id, tagger_type` | `Tagging.owned_by`, and `tagged_with(owned_by:)` |
+| — | `context` | Filtering taggings by context alone |
+
+The five migration 7 removes were `tag_id`, `taggable_id`, `taggable_type` and `tagger_id` on their
+own, plus a second copy of the tagger pair in the opposite column order. A B-tree index already
+answers any query filtering on a leading subset of its columns, so a single-column index earns
+nothing when another index starts with that same column — and every index is maintained on insert.
+
+If you installed the migrations before version 1.2.0, running
+`rails make_taggable_engine:install:migrations` again copies migration 7 across. It is reversible,
+and nothing it drops is load-bearing: each one is a prefix of an index that remains.
+
+### Concurrent tag creation
+
+`tags.name` carries a unique index, so two requests creating the same tag at the same moment leave
+one of them holding an `ActiveRecord::RecordNotUnique`.
+
+`Tag.find_or_create_all_with_like_by_name` -- which every tag list goes through -- absorbs that. It
+re-reads the tags and retries, up to three times, and raises
+{MakeTaggable::DuplicateTagError} if the name is still taken after that.
+
+Each insert takes a savepoint of its own, so the failed insert is the only thing rolled back. If you
+call this inside a transaction of your own, that transaction and everything written into it survive
+the retry:
+
+```ruby
+Order.transaction do
+  order.update!(state: "placed")
+  order.tag_list = "priority"   # a race here rolls back nothing but the tag insert
+  order.save!
+end
+```
 
 ### Duplicate unowned taggings
 

data/docs/querying.md

@@ -28,12 +28,20 @@ empty relation rather than every record — worth knowing when the tags come fro
 | `:exclude` | Match records carrying none of the tags |
 | `:match_all` | Match records carrying only these tags and no others |
 | `:wild` | Match tags *containing* the given text, i.e. `%sci%` |
-| `:on` | Restrict to one context |
+| `: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 |
 
+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:
+
+```ruby
+Book.tagged_with([])                  # => none
+Book.tagged_with([], exclude: true)   # => every book
+```
+
 `:wild` combines with `:any` or `:exclude`:
 
 ```ruby

data/lib/make_taggable/tag.rb

@@ -139,6 +139,9 @@ module MakeTaggable
     # Finds every tag in a list by name, creating those that do not exist yet.
     #
     # A competing write that takes a name first is retried up to three times before giving up.
+    # Each insert runs in a savepoint of its own, so a name lost to a race unwinds that insert
+    # alone -- an enclosing transaction the caller opened is left untouched, along with everything
+    # written into it.
     #
     # @param list [Array<String>] the tag names
     # @return [Array<MakeTaggable::Tag>] in the order the names were given
@@ -162,10 +165,13 @@ module MakeTaggable
         # Tags created earlier in this call have to stay visible to the names
         # that follow, or a list holding both "Ruby" and "ruby" resolves to two
         # rows even though the two names compare equal.
-        create(name: tag_name).tap { |tag| existing_tags << tag }
+        #
+        # The insert gets a savepoint of its own so that a RecordNotUnique
+        # unwinds only the failed insert. Without one the caller's transaction
+        # is left in an aborted state and everything it had done is lost.
+        transaction(requires_new: true) { create(name: tag_name) }.tap { |tag| existing_tags << tag }
       rescue ActiveRecord::RecordNotUnique
         if (tries -= 1).positive?
-          ActiveRecord::Base.connection.execute "ROLLBACK"
           existing_tags = named_any(list).to_a
           retry
         end

data/lib/make_taggable/taggable/core.rb

@@ -129,7 +129,8 @@ module MakeTaggable::Taggable
       # @option options [Symbol, String] :on only tags applied in this context
       # @option options [Time, Date] :start_at only tags applied after this time
       # @option options [Time, Date] :end_at only tags applied before this time
-      # @return [ActiveRecord::Relation] empty when no tags are given
+      # @return [ActiveRecord::Relation] empty when no tags are given, except under `:exclude`,
+      #   where excluding no tags leaves the whole scope standing
       #
       # @example Every tag
       #   User.tagged_with(["awesome", "cool"])
@@ -144,7 +145,9 @@ module MakeTaggable::Taggable
         tag_list = MakeTaggable.default_parser.new(tags).parse
         options = options.dup
 
-        return none if tag_list.empty?
+        # Asking for no tags matches nothing, but *excluding* no tags rules
+        # nothing out, so the whole scope stands.
+        return options[:exclude].present? ? all : none if tag_list.empty?
 
         ::MakeTaggable::Taggable::TaggedWithQuery.build(self, MakeTaggable::Tag, MakeTaggable::Tagging, tag_list, options)
       end

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

@@ -20,15 +20,21 @@ module MakeTaggable::Taggable::TaggedWithQuery
     private
 
     def tags_not_in_list
-      taggable_arel_table[:id].not_in(
+      on_condition = tagging_arel_table[:tag_id].eq(tag_arel_table[:id])
+        .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.
+      if options[:on].present?
+        on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on]))
+      end
+
+      taggable_arel_table[taggable_model.primary_key].not_in(
         tagging_arel_table
           .project(tagging_arel_table[:taggable_id])
           .join(tag_arel_table)
-          .on(
-            tagging_arel_table[:tag_id].eq(tag_arel_table[:id])
-            .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
-            .and(tags_match_type)
-          )
+          .on(on_condition)
       )
 
       # FIXME: missing time scope, this is also missing in the original implementation

data/lib/make_taggable/taggable.rb

@@ -69,6 +69,7 @@ module MakeTaggable
     #
     def taggable_on(preserve_tag_order, *tag_types)
       tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
+      tag_types.each { |tag_type| validate_tag_context!(tag_type) }
 
       if taggable?
         self.tag_types = (self.tag_types + tag_types).uniq
@@ -97,5 +98,31 @@ module MakeTaggable
       include Ownership
       include Related
     end
+
+    # Rejects a context that cannot become the methods and instance variables the
+    # library generates from it.
+    #
+    # A context is interpolated straight into generated source -- `#{context}_list`,
+    # `#{context}_taggings`, `@#{context}_list`. A name that is not a valid identifier
+    # produces source Ruby cannot parse, and the resulting SyntaxError descends from
+    # ScriptError rather than StandardError, so it slips past an application's own
+    # rescue and takes the boot down pointing at Active Record's association builder
+    # rather than at the offending declaration.
+    #
+    # Validity is decided by asking Ruby rather than by pattern, so a context is
+    # accepted on exactly the terms the generated code needs -- non-ASCII names
+    # included, since those make perfectly good method names.
+    #
+    # @param tag_type [Symbol] the context being declared
+    # @return [void]
+    # @raise [ArgumentError] when the context cannot become an identifier
+    def validate_tag_context!(tag_type)
+      Object.new.instance_variable_defined?(:"@#{tag_type}_list")
+    rescue NameError
+      raise ArgumentError,
+        "#{tag_type.inspect} cannot be used as a tag context: " \
+        "make_taggable generates methods and instance variables from it, and " \
+        "\"#{tag_type}_list\" is not a valid Ruby name."
+    end
   end
 end

data/lib/make_taggable/tagging.rb

@@ -50,8 +50,21 @@ module MakeTaggable
 
     private
 
+    # Destroys the tag this tagging pointed at, if nothing else references it and the library is
+    # configured to clean up after itself. Runs after destroy.
+    #
+    # How "nothing else references it" is established depends on the counter cache. With
+    # `tags_counter` on, the count is already on the row and only needs re-reading. With it off
+    # there is no count to read, so the taggings are asked directly -- `none?` stops at the first
+    # row rather than counting them all.
+    #
+    # @return [void]
     def remove_unused_tags
-      if MakeTaggable.remove_unused_tags && MakeTaggable.tags_counter && tag.reload.taggings_count.zero?
+      return unless MakeTaggable.remove_unused_tags
+
+      if MakeTaggable.tags_counter
+        tag.destroy if tag.reload.taggings_count.zero?
+      elsif tag.taggings.reload.none?
         tag.destroy
       end
     end

data/lib/make_taggable/utils.rb

@@ -5,6 +5,17 @@ module MakeTaggable
   # Database differences the rest of the library needs to work around.
   #
   module Utils
+    ##
+    # Adapter names that are PostgreSQL as far as SQL generation is concerned.
+    #
+    # PostGIS is the PostgreSQL adapter with spatial types layered on top. It reports its own
+    # adapter name, so it has to be named here or the library treats a PostGIS application as
+    # though it were on MySQL -- `LIKE` in place of `ILIKE`, and the wrong grouping strategy.
+    #
+    # @return [Array<String>] frozen
+    #
+    POSTGRESQL_ADAPTER_NAMES = %w[PostgreSQL PostGIS].freeze
+
     class << self
       ##
       # The connection tags are read and written through.
@@ -18,10 +29,12 @@ module MakeTaggable
       ##
       # Whether tags are stored in PostgreSQL.
       #
+      # True for PostGIS as well, which is PostgreSQL underneath.
+      #
       # @return [TrueClass, FalseClass]
       #
       def using_postgresql?
-        connection && connection.adapter_name == "PostgreSQL"
+        !!connection && POSTGRESQL_ADAPTER_NAMES.include?(connection.adapter_name)
       end
 
       ##
@@ -47,7 +60,7 @@ module MakeTaggable
       ##
       # The case-insensitive pattern operator for the current adapter.
       #
-      # @return [String] `"ILIKE"` on PostgreSQL, otherwise `"LIKE"`
+      # @return [String] `"ILIKE"` on PostgreSQL and PostGIS, otherwise `"LIKE"`
       #
       def like_operator
         using_postgresql? ? "ILIKE" : "LIKE"

data/lib/make_taggable/version.rb

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

data/lib/make_taggable.rb

@@ -141,7 +141,8 @@ module MakeTaggable
   #   Whether tag names are parameterized before they are saved.
   #   @return [TrueClass, FalseClass] defaults to `false`
   # @!attribute [rw] remove_unused_tags
-  #   Whether a tag row is destroyed once its last tagging goes away. Requires `tags_counter`.
+  #   Whether a tag row is destroyed once its last tagging goes away. Works with or without
+  #   `tags_counter`; without it the check costs one extra query per destroyed tagging.
   #   @return [TrueClass, FalseClass] defaults to `false`
   # @!attribute [rw] default_parser
   #   The class used to turn tag input into a {MakeTaggable::TagList}.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: make_taggable
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.1
 platform: ruby
 authors:
 - Matthew Kennedy
@@ -47,6 +47,7 @@ files:
 - db/migrate/4_add_index_to_tags.rb
 - db/migrate/5_add_index_to_taggings.rb
 - db/migrate/6_add_unowned_taggings_unique_index.rb
+- db/migrate/7_remove_redundant_tagging_indexes.rb
 - docs/caching.md
 - docs/configuration.md
 - docs/contexts.md