make_taggable 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d900a8ac37e0f88ead6c0516fd30ddee5e8cc11c893b7d64e85c090a8b59598
-  data.tar.gz: b364eef565e3a171c56558f928360de5230c445b4b210e1aab8f536f9b998c70
+  metadata.gz: 990809ed5f39d8db0f974dbc5666dd040d5d8297423a3fc13b3af555ae5f1735
+  data.tar.gz: 20a3ec9542d5089d7fa953540e6233ad22a0f8857ac21dcac664b9833cc2bdb1
 SHA512:
-  metadata.gz: 611fd4635e580ff5aaaee314600d2d66e7cdb70a2bd22d8988e3eb541c3d632fc25625e485880821beeec8f0bfb71677242f3d0d14ba96e98e0dd4d15038e0ae
-  data.tar.gz: b1713ea6a65eb7a8e45dfb0d4b8d41c9d72334cfb8de93ef2c1e60a21a6a4e04758acdcb7761a117b8b275f0aecb3e98d78258a8c7f8389f433836353e676958
+  metadata.gz: 44636fc042b034366c843c5ca909ea2ddbafbbd6d75d69976416b0fa956baffbb81e5beab0d746f87e1b5db320b3a42dc34b87fb632dcff3545d1e5f2461b502
+  data.tar.gz: 113d18d8f21957b8ab11d3c044144afccc21c5c11726c3f757587fbf73d252cdb14913b0dd99168b7b8e725346e85f1afbcfc4392ce32605373732d0c7402a59

data/CHANGELOG.md

@@ -5,6 +5,24 @@ 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.6.0] - 2026-08-23
+
+### Fixed
+
+- `includes(:tags)` made reading tag lists **slower**: it cost two extra queries and saved none,
+  because `tag_list` always queried for a context's unowned tags rather than reading what had been
+  preloaded. Reading five records' lists went from 8 queries to 3, and the count no longer grows
+  with the collection. Records loaded without the preload are unaffected.
+
+- `tag_counts_on` raised `sub-select returns N columns - expected 1` on a relation built with
+  `includes`. An eager load builds its own column list, which survived the `except(:select)` used to
+  reduce the scope to primary keys.
+
+- `all_tags` and `all_tag_counts` could not be ordered by a `taggings` column --
+  `order: "taggings.created_at desc"` raised `no such column`. The derived table they join now
+  exposes the latest `created_at` for each tag, so ordering by it means "when this tag was last
+  applied".
+
 ## [1.5.0] - 2026-08-23
 
 ### Added

data/docs/querying.md

@@ -168,6 +168,18 @@ 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.
 
+## Reading tag lists across a collection
+
+Reading `<context>_list` on each of a set of records queries once per record. Eager load the tags to
+avoid it:
+
+```ruby
+Book.includes(:tags).each { |book| book.tag_list }   # constant queries, whatever the count
+```
+
+The lists are then read from the preload. Owned tags are still excluded from `tag_list`, as they are
+without it.
+
 ## Grouping and ordering by tagging columns
 
 `tagged_with` does not join the taggings table, so a `taggings` column is not in scope on the
@@ -181,6 +193,23 @@ 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.
 
+## Counting tags for a subset of records
+
+`tag_counts_on` and `all_tags` apply to whatever scope they are called on, so narrowing the records
+narrows the counts:
+
+```ruby
+Book.where(published: true).tag_counts_on(:genres)
+Book.joins(:author).where(authors: {country: "IE"}).tag_counts_on(:genres)
+```
+
+`:order` accepts a `taggings` column, which orders by when a tag was last applied:
+
+```ruby
+Book.all_tags(order: "taggings.created_at desc")     # most recently used first
+Book.all_tag_counts(order: "count desc", limit: 10)
+```
+
 ## Performance notes
 
 - `tagged_with` tests for each tag with an `EXISTS` subquery, one per tag, and joins nothing. That

data/lib/make_taggable/taggable/collection.rb

@@ -107,7 +107,9 @@ module MakeTaggable::Taggable
         options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
 
         ## Generate scope:
-        tagging_scope = MakeTaggable::Tagging.select("#{MakeTaggable::Tagging.table_name}.tag_id")
+        tagging_scope = MakeTaggable::Tagging.select(
+          "#{MakeTaggable::Tagging.table_name}.tag_id, #{last_applied_at_projection}"
+        )
         tag_scope = MakeTaggable::Tag.select("#{MakeTaggable::Tag.table_name}.*").order(options[:order]).limit(options[:limit])
 
         # Joins and conditions
@@ -147,7 +149,9 @@ module MakeTaggable::Taggable
         options[:conditions] = sanitize_sql(options[:conditions]) if options[:conditions]
 
         ## Generate scope:
-        tagging_scope = MakeTaggable::Tagging.select("#{MakeTaggable::Tagging.table_name}.tag_id, COUNT(#{MakeTaggable::Tagging.table_name}.tag_id) AS tags_count")
+        tagging_scope = MakeTaggable::Tagging.select(
+          "#{MakeTaggable::Tagging.table_name}.tag_id, COUNT(#{MakeTaggable::Tagging.table_name}.tag_id) AS tags_count, #{last_applied_at_projection}"
+        )
         tag_scope = MakeTaggable::Tag.select("#{MakeTaggable::Tag.table_name}.*, #{MakeTaggable::Tagging.table_name}.tags_count AS count").order(options[:order]).limit(options[:limit])
 
         # Current model is STI descendant, so add type checking to the join condition
@@ -200,12 +204,38 @@ module MakeTaggable::Taggable
           scoped_ids = pluck(table_name_pkey)
           tagging_scope = tagging_scope.where("#{MakeTaggable::Tagging.table_name}.taggable_id IN (?)", scoped_ids)
         else
-          tagging_scope = tagging_scope.where("#{MakeTaggable::Tagging.table_name}.taggable_id IN(#{safe_to_sql(except(:select).select(table_name_pkey))})")
+          tagging_scope = tagging_scope.where("#{MakeTaggable::Tagging.table_name}.taggable_id IN(#{safe_to_sql(taggable_ids_scope(table_name_pkey))})")
         end
 
         tagging_scope
       end
 
+      # The current scope reduced to primary keys, for embedding in an IN clause.
+      #
+      # `except(:select)` is not enough on its own. An eager load builds its own column list rather
+      # than storing it in select_values, so it survives and the subquery comes back with a column
+      # per attribute of every table involved -- where the IN needs exactly one. Turning the eager
+      # load into a join keeps any condition on the joined table while selecting only the key.
+      def taggable_ids_scope(table_name_pkey)
+        scope = except(:select)
+        eager_loaded = scope.includes_values + scope.eager_load_values
+
+        scope = scope.except(:includes, :eager_load, :preload).left_joins(*eager_loaded) if eager_loaded.any?
+
+        scope.select(table_name_pkey)
+      end
+
+      # The tagging scope is embedded as a derived table aliased to the taggings table name, so
+      # `order: "taggings.created_at"` resolves against that rather than the real table -- which
+      # projected tag_id alone, and the column appeared not to exist.
+      #
+      # It groups by tag_id, so a tag may stand for many taggings and there is no single created_at
+      # to expose. The latest is the useful one: ordering by it means "when this tag was last
+      # applied".
+      def last_applied_at_projection
+        "MAX(#{MakeTaggable::Tagging.table_name}.created_at) AS created_at"
+      end
+
       def tagging_conditions(options)
         tagging_conditions = []
         tagging_conditions.push sanitize_sql(["#{MakeTaggable::Tagging.table_name}.created_at <= ?", options.delete(:end_at)]) if options[:end_at]

data/lib/make_taggable/taggable/core.rb

@@ -408,7 +408,7 @@ module MakeTaggable::Taggable
         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))
+          MakeTaggable::TagList.new(unowned_tag_names_on(context))
         end
 
       # Note what was there the first time the list is built, before anything
@@ -469,6 +469,48 @@ module MakeTaggable::Taggable
       end.to_a
     end
 
+    ##
+    # The names of a context's unowned tags, read from the preloaded taggings where they are
+    # available and queried where they are not.
+    #
+    # `includes(:tags)` loads the per-context taggings association as well as the tags themselves,
+    # and those taggings carry `tagger_id` -- which is what makes them usable here, since the list
+    # excludes owned tags and the tags association alone cannot say which are owned.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [Array<String>]
+    #
+    # @api private
+    #
+    def unowned_tag_names_on(context)
+      preloaded = preloaded_taggings_on(context)
+      return tags_on(context).map(&:name) unless preloaded
+
+      preloaded.map { |tagging| tagging.tag.name }
+    end
+
+    ##
+    # A context's taggings if they are already in memory, otherwise `nil`.
+    #
+    # Only unowned taggings are returned, in tagging order where the model preserves it, so the
+    # result matches what {#tags_on} would have queried.
+    #
+    # @param context [Symbol, String] the tagging context
+    # @return [Array<MakeTaggable::Tagging>, NilClass]
+    #
+    # @api private
+    #
+    def preloaded_taggings_on(context)
+      name = :"#{context.to_s.singularize}_taggings"
+      return unless self.class.reflect_on_association(name)
+
+      association = association(name)
+      return unless association.loaded?
+
+      taggings = association.target.reject(&:tagger_id)
+      self.class.preserve_tag_order? ? taggings.sort_by(&:id) : taggings
+    end
+
     ##
     # Returns all tags that are not owned of a given context
     def tags_on(context)

data/lib/make_taggable/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: make_taggable
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Matthew Kennedy