no_fly_list 0.7.4 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a4d0bb308f36212383e565010061a086173ddbd9105fad575193d7abca8ffa5
-  data.tar.gz: 92772d14d0351c3a7a0d1e631d81590fb0a87e49460773cd68e78368ef55906b
+  metadata.gz: f6f9c09e56aee23105de3e334b059849897533057cbd53e48a1dc7436f693438
+  data.tar.gz: a76825bbc73c6ff0840cd2a362aaa30ecebba3cdd97c1f63ee9aa59d3bbfced0
 SHA512:
-  metadata.gz: 793849ef8f48b2ced0c5547187fa02cc704b05bb6ebad05b65c2d7e21780ab6b2efa6349a97ef74af310ef49afa28c79506ee431f45b74613bc9038482ebf970
-  data.tar.gz: 963dd7b6d64a7b159bc4085a6ea80f3641730a108dc820a91bb9201b8e636ac5705e07f4a561a6fa1089d377866ef9fbf0c55d2018796f1bd8a9750573584c85
+  metadata.gz: 44a42d785b563dd693515d30416a7eba3d27f506e432d33b48a8f0c182205d61cee306b8002bd49796c9022e4e69befe7806126b2e5b1cc559ac8f895aa9ed68
+  data.tar.gz: 5d33dcabce016e5eedda20f428b307a257ae3b27c34f6660ac89f2616f7cd63de88833c07a3442cd0ef6a21d93f8d563019b634c6656f20bd37376b48b57bc34

data/lib/generators/no_fly_list/install_generator.rb

@@ -14,6 +14,8 @@ module NoFlyList
       source_root File.expand_path("templates", __dir__)
 
       argument :connection_name, type: :string, desc: "The name of the database connection", default: "primary"
+      class_option :scope, type: :string,
+                           desc: "belongs_to association (e.g. entity) that keeps tags unique per scope"
 
       def copy_application_tag
         ensure_connection_exists
@@ -45,6 +47,15 @@ module NoFlyList
         klass&.name || "ApplicationRecord"
       end
 
+      # Column added to the tag table for --scope=NAME: NAME_id, or NAME when
+      # it already ends in _id.
+      def scope_column
+        scope = options[:scope]
+        return if scope.blank?
+
+        scope.end_with?("_id") ? scope : "#{scope}_id"
+      end
+
       def migration_version
         "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
       end

data/lib/generators/no_fly_list/tagging_generator.rb

@@ -13,6 +13,8 @@ module NoFlyList
 
       class_option :database, type: :string, default: "primary",
                               desc: "Use different database for migration"
+      class_option :scope, type: :string,
+                           desc: "belongs_to association (e.g. entity) that keeps tags unique per scope"
 
       def self.default_generator_root
         File.dirname(__FILE__)
@@ -60,6 +62,18 @@ module NoFlyList
         "#{model_table_name.singularize}_taggings"
       end
 
+      # Column added to the tag table for --scope=NAME: the foreign key of the
+      # model's NAME association, else NAME_id, or NAME when it ends in _id.
+      def scope_column
+        scope = options[:scope]
+        return if scope.blank?
+
+        reflection = target_class.reflect_on_association(scope)
+        return reflection.foreign_key.to_s if reflection
+
+        scope.end_with?("_id") ? scope : "#{scope}_id"
+      end
+
       def migration_version
         "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
       end

data/lib/generators/no_fly_list/templates/create_application_tagging_table.rb.erb

@@ -1,7 +1,13 @@
 class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
   def up
     create_table :application_tags do |t|
+<% if scope_column -%>
+      t.column :<%= scope_column %>, :bigint, null: false # Change to :uuid if you are using UUIDs
+      t.string :name, null: false
+      t.index %i[<%= scope_column %> name], unique: true
+<% else -%>
       t.string :name, null: false, index: { unique: true }
+<% end -%>
       t.timestamp :created_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
       t.timestamp :updated_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
     end

data/lib/generators/no_fly_list/templates/create_tagging_table.rb.erb

@@ -1,6 +1,9 @@
 class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
   def change
     create_table :<%= tag_table_name %>, id: :bigint do |t|
+<% if scope_column -%>
+      t.column :<%= scope_column %>, :bigint, null: false # Change to :uuid if you are using UUIDs
+<% end -%>
       t.string :name, null: false
       t.timestamp :created_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
       t.timestamp :updated_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
@@ -14,7 +17,11 @@ class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version
       t.timestamp :updated_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
     end
 
+<% if scope_column -%>
+    add_index :<%= tag_table_name %>, %i[<%= scope_column %> name], unique: true
+<% else -%>
     add_index :<%= tag_table_name %>, :name, unique: true
+<% end -%>
     add_index :<%= tagging_table_name %>, %i[taggable_id tag_id], unique: true
     add_foreign_key :<%= tagging_table_name %>, :<%= tag_table_name %>, column: :tag_id
     add_foreign_key :<%= tagging_table_name %>, :<%= model_table_name %>, column: :taggable_id

data/lib/no_fly_list/taggable_record/config.rb

@@ -14,6 +14,7 @@ module NoFlyList
       context = context.to_sym
       tag_class_name = determine_tag_class_name(options)
       tagging_class_name = determine_tagging_class_name(options)
+      ensure_consistent_scope(context, tag_class_name, options[:scope])
 
       @tag_contexts[context] = {
         taggable_class: @taggable_class.to_s,
@@ -25,12 +26,25 @@ module NoFlyList
         limit: options.fetch(:limit, nil),
         case_sensitive: options.fetch(:case_sensitive, true),
         adapter: @adapter,
-        counter_cache: options.fetch(:counter_cache, false)
+        counter_cache: options.fetch(:counter_cache, false),
+        scope: options[:scope]
       }
     end
 
     private
 
+    # Contexts that share a tag table must agree on its scope, otherwise an
+    # unscoped context would match tags across scopes.
+    def ensure_consistent_scope(context, tag_class_name, scope)
+      other = @tag_contexts.find do |name, config|
+        name != context && config[:tag_class_name] == tag_class_name && config[:scope] != scope
+      end
+      return unless other
+
+      raise ArgumentError, "NoFlyList: #{@taggable_class}##{context} uses scope #{scope.inspect} but " \
+                           "#{other.first} uses scope #{other.last[:scope].inspect} on the same tag class #{tag_class_name}"
+    end
+
     def determine_adapter
       case taggable_class.connection.adapter_name.downcase
       when "postgresql"

data/lib/no_fly_list/taggable_record/configuration.rb

@@ -249,7 +249,8 @@ module NoFlyList
               setup.context,
               transformer: setup.transformer,
               restrict_to_existing: setup.restrict_to_existing,
-              limit: calculate_limit(setup.limit)
+              limit: calculate_limit(setup.limit),
+              scope_column: setup.scope_column
             )
             instance_variable_set(instance_variable_name, proxy)
           end

data/lib/no_fly_list/taggable_record/query/mysql_strategy.rb

@@ -28,9 +28,9 @@ module NoFlyList
                                          .project(arel_table[primary_key])
                                          .distinct
                                          .join(tagging_table).on(tagging_table[:taggable_id].eq(arel_table[primary_key]))
-                                         .join(tag_table).on(tag_table[:id].eq(tagging_table[:tag_id]))
+                                         .join(tag_table).on(Query.tag_join_condition(setup, arel_table, tagging_table, tag_table))
                                          .where(tagging_table[:context].eq(singular_name))
-                                         .where(tag_table[:name].in(tags))
+                                         .where(Query.name_in(setup, tag_table, tags))
 
               where(arel_table[primary_key].in(query))
             }
@@ -41,18 +41,18 @@ module NoFlyList
 
               count_function = Arel::Nodes::NamedFunction.new(
                 "COUNT",
-                [ Arel::Nodes::NamedFunction.new("DISTINCT", [ tag_table[:name] ]) ]
+                [ Arel::Nodes::NamedFunction.new("DISTINCT", [ Query.name_column(setup, tag_table) ]) ]
               )
 
               query = Arel::SelectManager.new(self)
                                          .from(table_name)
                                          .project(arel_table[primary_key])
                                          .join(tagging_table).on(tagging_table[:taggable_id].eq(arel_table[primary_key]))
-                                         .join(tag_table).on(tag_table[:id].eq(tagging_table[:tag_id]))
+                                         .join(tag_table).on(Query.tag_join_condition(setup, arel_table, tagging_table, tag_table))
                                          .where(tagging_table[:context].eq(singular_name))
-                                         .where(tag_table[:name].in(tags))
+                                         .where(Query.name_in(setup, tag_table, tags))
                                          .group(arel_table[primary_key])
-                                         .having(count_function.eq(tags.size))
+                                         .having(count_function.eq(Query.distinct_names(setup, tags).size))
 
               where(arel_table[primary_key].in(query))
             }
@@ -62,17 +62,13 @@ module NoFlyList
               tags = tags.flatten.compact.uniq
               return all if tags.empty?
 
-              subquery = joins(tagging_table)
-                         .where(tagging_table[:context].eq(singular_name))
-                         .where(tagging_table.name => { context: singular_name })
-                         .where(tag_table.name => { name: tags })
-                         .select(primary_key)
-
-              where("#{table_name}.#{primary_key} NOT IN (?)", subquery)
+              where(arel_table[primary_key].not_in(Query.tagged_ids(self, setup, tags)))
             }
 
             # Find records without any tags
             scope "without_#{context}", lambda {
+              return where(arel_table[primary_key].not_in(Query.tagged_ids(self, setup))) if setup.scope_column
+
               subquery = if setup.polymorphic
                            setup.tagging_class_name.constantize
                                 .where(context: singular_name)
@@ -102,18 +98,18 @@ module NoFlyList
                 # Build the query for records having exactly the tags
                 all_tags_query = select(arel_table[primary_key])
                                  .joins("INNER JOIN #{tagging_table.name} ON #{tagging_table.name}.taggable_id = #{table_name}.#{primary_key}")
-                                 .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id")
+                                 .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id#{Query.scope_join_sql(setup, tag_table.name, table_name)}")
                                  .where("#{tagging_table.name}.context = ?", context.to_s.singularize)
-                                 .where("#{tag_table.name}.name IN (?)", tags)
+                                 .where(*Query.name_in_sql(setup, tag_table, tags))
                                  .group(arel_table[primary_key])
-                                 .having("COUNT(DISTINCT #{tag_table.name}.id) = ?", tags.size)
+                                 .having("#{Query.distinct_tag_count_sql(setup, tag_table)} = ?", Query.distinct_names(setup, tags).size)
 
                 # Build query for records with other tags
                 other_tags_query = select(arel_table[primary_key])
                                    .joins("INNER JOIN #{tagging_table.name} ON #{tagging_table.name}.taggable_id = #{table_name}.#{primary_key}")
-                                   .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id")
+                                   .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id#{Query.scope_join_sql(setup, tag_table.name, table_name)}")
                                    .where("#{tagging_table.name}.context = ?", context.to_s.singularize)
-                                   .where("#{tag_table.name}.name NOT IN (?)", tags)
+                                   .where(*Query.name_in_sql(setup, tag_table, tags, negate: true))
 
                 # Combine queries
                 where("#{table_name}.#{primary_key} IN (?)", all_tags_query)

data/lib/no_fly_list/taggable_record/query/postgresql_strategy.rb

@@ -28,9 +28,9 @@ module NoFlyList
                                          .project(arel_table[primary_key])
                                          .distinct
                                          .join(tagging_table).on(tagging_table[:taggable_id].eq(arel_table[primary_key]))
-                                         .join(tag_table).on(tag_table[:id].eq(tagging_table[:tag_id]))
+                                         .join(tag_table).on(Query.tag_join_condition(setup, arel_table, tagging_table, tag_table))
                                          .where(tagging_table[:context].eq(singular_name))
-                                         .where(tag_table[:name].in(tags))
+                                         .where(Query.name_in(setup, tag_table, tags))
 
               where(arel_table[primary_key].in(query))
             }
@@ -41,18 +41,18 @@ module NoFlyList
 
               count_function = Arel::Nodes::NamedFunction.new(
                 "COUNT",
-                [ Arel::Nodes::NamedFunction.new("DISTINCT", [ tag_table[:name] ]) ]
+                [ Arel::Nodes::NamedFunction.new("DISTINCT", [ Query.name_column(setup, tag_table) ]) ]
               )
 
               query = Arel::SelectManager.new(self)
                                          .from(table_name)
                                          .project(arel_table[primary_key])
                                          .join(tagging_table).on(tagging_table[:taggable_id].eq(arel_table[primary_key]))
-                                         .join(tag_table).on(tag_table[:id].eq(tagging_table[:tag_id]))
+                                         .join(tag_table).on(Query.tag_join_condition(setup, arel_table, tagging_table, tag_table))
                                          .where(tagging_table[:context].eq(singular_name))
-                                         .where(tag_table[:name].in(tags))
+                                         .where(Query.name_in(setup, tag_table, tags))
                                          .group(arel_table[primary_key])
-                                         .having(count_function.eq(tags.size))
+                                         .having(count_function.eq(Query.distinct_names(setup, tags).size))
 
               where(arel_table[primary_key].in(query))
             }
@@ -62,17 +62,13 @@ module NoFlyList
               tags = tags.flatten.compact.uniq
               return all if tags.empty?
 
-              subquery = joins(tagging_table)
-                         .where(tagging_table[:context].eq(singular_name))
-                         .where(tagging_table.name => { context: singular_name })
-                         .where(tag_table.name => { name: tags })
-                         .select(primary_key)
-
-              where.not(primary_key => subquery)
+              where(arel_table[primary_key].not_in(Query.tagged_ids(self, setup, tags)))
             }
 
             # Find records without any tags
             scope "without_#{context}", lambda {
+              return where(arel_table[primary_key].not_in(Query.tagged_ids(self, setup))) if setup.scope_column
+
               subquery = if setup.polymorphic
                            setup.tagging_class_name.constantize
                                 .where(context: singular_name)
@@ -102,18 +98,18 @@ module NoFlyList
                 # Build the query for records having exactly the tags
                 all_tags_query = select(arel_table[primary_key])
                                  .joins("INNER JOIN #{tagging_table.name} ON #{tagging_table.name}.taggable_id = #{table_name}.#{primary_key}")
-                                 .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id")
+                                 .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id#{Query.scope_join_sql(setup, tag_table.name, table_name)}")
                                  .where("#{tagging_table.name}.context = ?", context.to_s.singularize)
-                                 .where("#{tag_table.name}.name IN (?)", tags)
+                                 .where(*Query.name_in_sql(setup, tag_table, tags))
                                  .group(arel_table[primary_key])
-                                 .having("COUNT(DISTINCT #{tag_table.name}.id) = ?", tags.size)
+                                 .having("#{Query.distinct_tag_count_sql(setup, tag_table)} = ?", Query.distinct_names(setup, tags).size)
 
                 # Build query for records with other tags
                 other_tags_query = select(arel_table[primary_key])
                                    .joins("INNER JOIN #{tagging_table.name} ON #{tagging_table.name}.taggable_id = #{table_name}.#{primary_key}")
-                                   .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id")
+                                   .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id#{Query.scope_join_sql(setup, tag_table.name, table_name)}")
                                    .where("#{tagging_table.name}.context = ?", context.to_s.singularize)
-                                   .where("#{tag_table.name}.name NOT IN (?)", tags)
+                                   .where(*Query.name_in_sql(setup, tag_table, tags, negate: true))
 
                 # Combine queries
                 where("#{table_name}.#{primary_key} IN (?)", all_tags_query)

data/lib/no_fly_list/taggable_record/query/sqlite_strategy.rb

@@ -28,9 +28,9 @@ module NoFlyList
                                          .project(arel_table[primary_key])
                                          .distinct
                                          .join(tagging_table).on(tagging_table[:taggable_id].eq(arel_table[primary_key]))
-                                         .join(tag_table).on(tag_table[:id].eq(tagging_table[:tag_id]))
+                                         .join(tag_table).on(Query.tag_join_condition(setup, arel_table, tagging_table, tag_table))
                                          .where(tagging_table[:context].eq(singular_name))
-                                         .where(tag_table[:name].in(tags))
+                                         .where(Query.name_in(setup, tag_table, tags))
 
               where(arel_table[primary_key].in(query))
             }
@@ -41,18 +41,18 @@ module NoFlyList
 
               count_function = Arel::Nodes::NamedFunction.new(
                 "COUNT",
-                [ Arel::Nodes::NamedFunction.new("DISTINCT", [ tag_table[:name] ]) ]
+                [ Arel::Nodes::NamedFunction.new("DISTINCT", [ Query.name_column(setup, tag_table) ]) ]
               )
 
               query = Arel::SelectManager.new(self)
                                          .from(table_name)
                                          .project(arel_table[primary_key])
                                          .join(tagging_table).on(tagging_table[:taggable_id].eq(arel_table[primary_key]))
-                                         .join(tag_table).on(tag_table[:id].eq(tagging_table[:tag_id]))
+                                         .join(tag_table).on(Query.tag_join_condition(setup, arel_table, tagging_table, tag_table))
                                          .where(tagging_table[:context].eq(singular_name))
-                                         .where(tag_table[:name].in(tags))
+                                         .where(Query.name_in(setup, tag_table, tags))
                                          .group(arel_table[primary_key])
-                                         .having(count_function.eq(tags.size))
+                                         .having(count_function.eq(Query.distinct_names(setup, tags).size))
 
               where(arel_table[primary_key].in(query))
             }
@@ -62,19 +62,13 @@ module NoFlyList
               tags = tags.flatten.compact.uniq
               return all if tags.empty?
 
-              # Build dynamic joins
-              tagged_ids = distinct
-                           .joins("INNER JOIN #{tagging_table} ON #{tagging_table}.taggable_id = #{table_name}.id")
-                           .joins("INNER JOIN #{context} ON #{context}.id = #{tagging_table}.tag_id")
-                           .where("#{context}.name IN (?)", tags)
-                           .pluck("#{table_name}.id")
-
-              # Handle empty tagged_ids explicitly for SQLite compatibility
-              where("#{table_name}.id NOT IN (?)", tagged_ids.present? ? tagged_ids : [ -1 ])
+              where(arel_table[primary_key].not_in(Query.tagged_ids(self, setup, tags)))
             }
 
             # Find records without any tags
             scope "without_#{context}", lambda {
+              return where(arel_table[primary_key].not_in(Query.tagged_ids(self, setup))) if setup.scope_column
+
               subquery = if setup.polymorphic
                            setup.tagging_class_name.constantize
                                 .where(context: singular_name, taggable_type: name)
@@ -102,53 +96,18 @@ module NoFlyList
                 # Build the query for records having exactly the tags
                 all_tags_query = select(arel_table[primary_key])
                                  .joins("INNER JOIN #{tagging_table.name} ON #{tagging_table.name}.taggable_id = #{table_name}.#{primary_key}")
-                                 .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id")
-                                 .where("#{tagging_table.name}.context = ?", singular_name)
-                                 .where("#{tag_table.name}.name IN (?)", tags)
-                                 .group(arel_table[primary_key])
-                                 .having("COUNT(DISTINCT #{tag_table.name}.id) = ?", tags.size)
-
-                # Build query for records with other tags
-                other_tags_query = select(arel_table[primary_key])
-                                   .joins("INNER JOIN #{tagging_table.name} ON #{tagging_table.name}.taggable_id = #{table_name}.#{primary_key}")
-                                   .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id")
-                                   .where("#{tagging_table.name}.context = ?", singular_name)
-                                   .where("#{tag_table.name}.name NOT IN (?)", tags)
-
-                # Combine queries using subqueries
-                where("#{table_name}.#{primary_key} IN (?)", all_tags_query)
-                  .where("#{table_name}.#{primary_key} NOT IN (?)", other_tags_query)
-              end
-            }
-
-            # Add tag counts
-            # Find records with exactly these tags
-            scope "with_exact_#{context}", lambda { |*tags|
-              tags = tags.flatten.compact.uniq
-
-              if tags.empty?
-                send("without_#{context}")
-              else
-                Arel::Nodes::NamedFunction.new(
-                  "COUNT",
-                  [ Arel::Nodes::NamedFunction.new("DISTINCT", [ tag_table[:id] ]) ]
-                )
-
-                # Build the query for records having exactly the tags
-                all_tags_query = select(arel_table[primary_key])
-                                 .joins("INNER JOIN #{tagging_table.name} ON #{tagging_table.name}.taggable_id = #{table_name}.#{primary_key}")
-                                 .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id")
+                                 .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id#{Query.scope_join_sql(setup, tag_table.name, table_name)}")
                                  .where("#{tagging_table.name}.context = ?", context.to_s.singularize)
-                                 .where("#{tag_table.name}.name IN (?)", tags)
+                                 .where(*Query.name_in_sql(setup, tag_table, tags))
                                  .group(arel_table[primary_key])
-                                 .having("COUNT(DISTINCT #{tag_table.name}.id) = ?", tags.size)
+                                 .having("#{Query.distinct_tag_count_sql(setup, tag_table)} = ?", Query.distinct_names(setup, tags).size)
 
                 # Build query for records with other tags
                 other_tags_query = select(arel_table[primary_key])
                                    .joins("INNER JOIN #{tagging_table.name} ON #{tagging_table.name}.taggable_id = #{table_name}.#{primary_key}")
-                                   .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id")
+                                   .joins("INNER JOIN #{tag_table.name} ON #{tag_table.name}.id = #{tagging_table.name}.tag_id#{Query.scope_join_sql(setup, tag_table.name, table_name)}")
                                    .where("#{tagging_table.name}.context = ?", context.to_s.singularize)
-                                   .where("#{tag_table.name}.name NOT IN (?)", tags)
+                                   .where(*Query.name_in_sql(setup, tag_table, tags, negate: true))
 
                 # Combine queries
                 where("#{table_name}.#{primary_key} IN (?)", all_tags_query)

data/lib/no_fly_list/taggable_record/query.rb

@@ -22,18 +22,89 @@ module NoFlyList
         end
       end
 
-      module BaseStrategy
-        module_function
+      # Builds a subquery selecting the ids of taggable rows that have at least
+      # one tagging in the setup's context, limited to tags named +names+ when
+      # given.
+      # @param relation [ActiveRecord::Relation] Taggable relation the scope runs on
+      # @param setup [TagSetup] Tag setup configuration
+      # @param names [Array<String>, nil] Tag names to match
+      # @return [Arel::SelectManager] Subquery projecting taggable ids
+      def tagged_ids(relation, setup, names = nil)
+        taggable_table = relation.arel_table
+        tagging_table = setup.tagging_class_name.constantize.arel_table
+        tag_table = setup.tag_class_name.constantize.arel_table
 
-        # Performs case-insensitive column comparison
-        # @param table [Arel::Table] Database table
-        # @param column [Symbol] Column name
-        # @param values [Array<String>] Values to compare
-        # @return [Arel::Node] Query node
-        # @abstract
-        def case_insensitive_where(table, column, values)
-          raise NotImplementedError
+        query = Arel::SelectManager.new(relation)
+                                   .from(relation.table_name)
+                                   .project(taggable_table[relation.primary_key])
+                                   .join(tagging_table).on(tagging_table[:taggable_id].eq(taggable_table[relation.primary_key]))
+                                   .join(tag_table).on(tag_join_condition(setup, taggable_table, tagging_table, tag_table))
+                                   .where(tagging_table[:context].eq(setup.context.to_s.singularize))
+        query.where(tagging_table[:taggable_type].eq(relation.name)) if setup.polymorphic
+        query.where(name_in(setup, tag_table, names)) if names
+        query
+      end
+
+      # Join condition from a tagging to its tag. Scoped tags must also share
+      # the taggable row's scope value.
+      # @return [Arel::Nodes::Node] Join condition
+      def tag_join_condition(setup, taggable_table, tagging_table, tag_table)
+        condition = tag_table[:id].eq(tagging_table[:tag_id])
+        column = setup.scope_column
+        column ? condition.and(tag_table[column].eq(taggable_table[column])) : condition
+      end
+
+      # SQL counterpart of #tag_join_condition, appended to a raw tag join.
+      # @return [String] Extra join condition, empty for unscoped tags
+      def scope_join_sql(setup, tag_table_name, taggable_table_name)
+        column = setup.scope_column
+        column ? " AND #{tag_table_name}.#{column} = #{taggable_table_name}.#{column}" : ""
+      end
+
+      # Tag name as compared by the context: the column itself, or LOWER(name)
+      # when the context is case insensitive.
+      # @return [Arel::Nodes::Node] Name expression
+      def name_column(setup, tag_table)
+        setup.case_sensitive ? tag_table[:name] : tag_table[:name].lower
+      end
+
+      # Condition matching tags named +names+. Case insensitive contexts
+      # compare LOWER(name) with LOWER of each value.
+      # @return [Arel::Nodes::Node] Name condition
+      def name_in(setup, tag_table, names)
+        return tag_table[:name].in(names) if setup.case_sensitive
+
+        name_column(setup, tag_table).in(names.map { |name| Arel::Nodes::NamedFunction.new("LOWER", [ Arel::Nodes.build_quoted(name) ]) })
+      end
+
+      # +where+ arguments for the raw SQL queries, matching (or with
+      # +negate+, excluding) tags named +names+.
+      # @return [Array] Arguments for ActiveRecord::QueryMethods#where
+      def name_in_sql(setup, tag_table, names, negate: false)
+        if setup.case_sensitive
+          [ "#{tag_table.name}.name #{negate ? 'NOT IN' : 'IN'} (?)", names ]
+        else
+          condition = name_in(setup, tag_table, names)
+          [ negate ? condition.not : condition ]
         end
+      end
+
+      # Requested names without duplicates, ignoring case when the context is
+      # case insensitive, so counts compare against distinct names.
+      # @return [Array<String>] Distinct names
+      def distinct_names(setup, names)
+        setup.case_sensitive ? names : names.uniq(&:downcase)
+      end
+
+      # SQL counting a row's distinct matching tags: by id, or by LOWER(name)
+      # when the context is case insensitive.
+      # @return [String] Aggregate expression
+      def distinct_tag_count_sql(setup, tag_table)
+        setup.case_sensitive ? "COUNT(DISTINCT #{tag_table.name}.id)" : "COUNT(DISTINCT LOWER(#{tag_table.name}.name))"
+      end
+
+      module BaseStrategy
+        module_function
 
         # Defines database-specific query methods
         # @abstract

data/lib/no_fly_list/taggable_record/tag_setup.rb

@@ -34,6 +34,12 @@ module NoFlyList
       # @return [Symbol] Database adapter type (:postgresql, :mysql, :sqlite)
       attr_reader :adapter
 
+      # @return [Symbol, nil] belongs_to association (or column) that partitions tags
+      attr_reader :scope
+
+      # @return [Boolean] Whether tag names are compared case sensitively
+      attr_reader :case_sensitive
+
       # Creates new tag setup configuration
       # @param taggable_klass [Class] Model to configure
       # @param context [Symbol] Tag context name
@@ -50,6 +56,26 @@ module NoFlyList
         @tag_class_name = determine_tag_class_name(taggable_klass, options)
         @tagging_class_name = determine_tagging_class_name(taggable_klass, options)
         @adapter = determine_adapter
+        @scope = options[:scope]
+        @case_sensitive = options.fetch(:case_sensitive, true)
+      end
+
+      # Column shared by the taggable and tag tables that keeps tags unique per
+      # scope: the foreign key of the +scope+ association, or +scope+ itself
+      # when no such association exists. Resolved on first use so +has_tags+
+      # may be declared before the association.
+      # @return [String, nil] Scope column name, or nil for unscoped tags
+      def scope_column
+        return unless scope
+
+        @scope_column ||= begin
+          reflection = taggable_klass.reflect_on_association(scope)
+          if reflection&.polymorphic?
+            raise ArgumentError, "NoFlyList: scope #{scope.inspect} on #{taggable_klass.name} is a polymorphic association, which is not supported"
+          end
+
+          reflection ? reflection.foreign_key.to_s : scope.to_s
+        end
       end
 
       private

data/lib/no_fly_list/tagging_proxy.rb

@@ -18,16 +18,19 @@ module NoFlyList
     # @param transformer [Class] Class for transforming tag strings
     # @param restrict_to_existing [Boolean] Only allow existing tags
     # @param limit [Integer, nil] Maximum number of tags allowed
+    # @param scope_column [String, nil] Column that keeps tags unique per scope
     def initialize(model, tag_model, context,
                    transformer: "ApplicationTagTransformer",
                    restrict_to_existing: false,
-                   limit: nil)
+                   limit: nil,
+                   scope_column: nil)
       @model = model
       @tag_model = tag_model
       @context = context
       @transformer = resolve_transformer(transformer)
       @restrict_to_existing = restrict_to_existing
       @limit = limit
+      @scope_column = scope_column
       @pending_changes = nil # Use nil to indicate no changes yet
       @clear_operation = false
     end
@@ -105,11 +108,9 @@ module NoFlyList
           # Update counter
           model.update_column("#{@context}_count", 0) if setup[:counter_cache]
 
-          # Create new tags
-          pending_list.each do |tag_name|
-            tag = find_or_create_tag(tag_name)
-            next unless tag
-
+          # Create new tags. Names differing only in case resolve to the same
+          # tag when matching is case insensitive, so tag it once.
+          pending_list.filter_map { |tag_name| find_or_create_tag(tag_name) }.uniq.each do |tag|
             attributes = {
               tag: tag,
               context: @context.to_s.singularize
@@ -374,8 +375,13 @@ module NoFlyList
 
       # Transform tags to lowercase for comparison
       normalized_changes = pending_list.map(&:downcase)
-      existing_tags = @tag_model.where("LOWER(name) IN (?)", normalized_changes).pluck(:name)
-      missing_tags = pending_list - existing_tags
+      existing_tags = tag_scope.where("LOWER(name) IN (?)", normalized_changes).pluck(:name)
+      missing_tags = if setup[:case_sensitive]
+                       pending_list - existing_tags
+      else
+                       existing = existing_tags.map(&:downcase)
+                       pending_list.reject { |tag_name| existing.include?(tag_name.downcase) }
+      end
 
       return unless missing_tags.any?
 
@@ -394,13 +400,28 @@ module NoFlyList
     end
 
     def find_or_create_tag(tag_name)
-      if @restrict_to_existing
-        @tag_model.find_by(name: tag_name)
+      tag = find_tag(tag_name)
+      return tag if tag || @restrict_to_existing
+
+      tag_scope.create(name: tag_name)
+    end
+
+    def find_tag(tag_name)
+      if setup[:case_sensitive]
+        tag_scope.find_by(name: tag_name)
       else
-        @tag_model.find_or_create_by(name: tag_name)
+        tag_scope.find_by(@tag_model.arel_table[:name].lower.eq(tag_name.downcase))
       end
     end
 
+    # Tags available to the model: all tags, or only those sharing the
+    # model's scope value when tags are scoped.
+    def tag_scope
+      return @tag_model unless @scope_column
+
+      @tag_model.where(@scope_column => @model[@scope_column])
+    end
+
     # Helper method to get the list of tags that should be saved
     def pending_list
       if @clear_operation

data/lib/no_fly_list/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module NoFlyList
-  VERSION = "0.7.4"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: no_fly_list
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.8.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: '8.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: '8.1'
 description: A flexible, high-performance tagging system for Rails applications with
   support for polymorphic tags, custom transformers, and database-specific optimizations
 email:
@@ -80,14 +80,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 4.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
-summary: Modern tagging system for Rails 7.2+ applications
+summary: Modern tagging system for Rails 8.1+ applications
 test_files: []