no_fly_list 0.1.0 → 0.2.1

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  module TaggableRecord
+    module Query
+      module PostgresqlStrategy
+        extend BaseStrategy
+
+        module_function
+
+        def define_query_methods(setup)
+          context = setup.context
+          taggable_klass = setup.taggable_klass
+          tagging_klass = setup.tagging_class_name.constantize
+          tagging_table = tagging_klass.arel_table
+          tag_klass = setup.tag_class_name.constantize
+          tag_table = tag_klass.arel_table
+          singular_name = context.to_s.singularize
+
+          taggable_klass.class_eval do
+            # Find records with any of the specified tags
+            scope "with_any_#{context}", lambda { |*tags|
+              tags = tags.flatten.compact.uniq
+              return none if tags.empty?
+
+              query = Arel::SelectManager.new(self)
+                                         .from(table_name)
+                                         .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]))
+                                         .where(tagging_table[:context].eq(singular_name))
+                                         .where(tag_table[:name].in(tags))
+
+              where(arel_table[primary_key].in(query))
+            }
+
+            scope "with_all_#{context}", lambda { |*tags|
+              tags = tags.flatten.compact.uniq
+              return none if tags.empty?
+
+              count_function = Arel::Nodes::NamedFunction.new(
+                'COUNT',
+                [Arel::Nodes::NamedFunction.new('DISTINCT', [tag_table[:name]])]
+              )
+
+              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]))
+                                         .where(tagging_table[:context].eq(singular_name))
+                                         .where(tag_table[:name].in(tags))
+                                         .group(arel_table[primary_key])
+                                         .having(count_function.eq(tags.size))
+
+              where(arel_table[primary_key].in(query))
+            }
+
+            # Find records without any of the specified tags
+            scope "without_any_#{context}", lambda { |*tags|
+              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)
+            }
+
+            # Find records without any tags
+            scope "without_#{context}", lambda {
+              subquery = if setup.polymorphic
+                           setup.tagging_class_name.constantize
+                                .where(context: singular_name)
+                                .where(taggable_type: name)
+                                .select(:taggable_id)
+                         else
+                           setup.tagging_class_name.constantize
+                                .where(context: singular_name)
+                                .select(:taggable_id)
+                         end
+
+              where.not(primary_key => subquery)
+            }
+
+            # 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")
+                                 .where("#{tagging_table.name}.context = ?", context.to_s.singularize)
+                                 .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 = ?", context.to_s.singularize)
+                                   .where("#{tag_table.name}.name NOT IN (?)", tags)
+
+                # Combine queries
+                where("#{table_name}.#{primary_key} IN (?)", all_tags_query)
+                  .where("#{table_name}.#{primary_key} NOT IN (?)", other_tags_query)
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  module TaggableRecord
+    module Query
+      module SqliteStrategy
+        extend BaseStrategy
+
+        module_function
+
+        def define_query_methods(setup)
+          context = setup.context
+          taggable_klass = setup.taggable_klass
+          tagging_klass = setup.tagging_class_name.constantize
+          tagging_table = tagging_klass.arel_table
+          tag_klass = setup.tag_class_name.constantize
+          tag_table = tag_klass.arel_table
+          singular_name = context.to_s.singularize
+
+          taggable_klass.class_eval do
+            # Find records with any of the specified tags
+            scope "with_any_#{context}", lambda { |*tags|
+              tags = tags.flatten.compact.uniq
+              return none if tags.empty?
+
+              query = Arel::SelectManager.new(self)
+                                         .from(table_name)
+                                         .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]))
+                                         .where(tagging_table[:context].eq(singular_name))
+                                         .where(tag_table[:name].in(tags))
+
+              where(arel_table[primary_key].in(query))
+            }
+
+            scope "with_all_#{context}", lambda { |*tags|
+              tags = tags.flatten.compact.uniq
+              return none if tags.empty?
+
+              count_function = Arel::Nodes::NamedFunction.new(
+                'COUNT',
+                [Arel::Nodes::NamedFunction.new('DISTINCT', [tag_table[:name]])]
+              )
+
+              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]))
+                                         .where(tagging_table[:context].eq(singular_name))
+                                         .where(tag_table[:name].in(tags))
+                                         .group(arel_table[primary_key])
+                                         .having(count_function.eq(tags.size))
+
+              where(arel_table[primary_key].in(query))
+            }
+
+            # Find records without any of the specified tags
+            scope "without_any_#{context}", lambda { |*tags|
+              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])
+            }
+
+            # Find records without any tags
+            scope "without_#{context}", lambda {
+              subquery = if setup.polymorphic
+                           setup.tagging_class_name.constantize
+                                .where(context: singular_name, taggable_type: name)
+                                .select(:taggable_id)
+                         else
+                           setup.tagging_class_name.constantize
+                                .where(context: singular_name)
+                                .select(:taggable_id)
+                         end
+              where('id NOT IN (?)', subquery)
+            }
+
+            # 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")
+                                 .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")
+                                 .where("#{tagging_table.name}.context = ?", context.to_s.singularize)
+                                 .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 = ?", context.to_s.singularize)
+                                   .where("#{tag_table.name}.name NOT IN (?)", tags)
+
+                # Combine queries
+                where("#{table_name}.#{primary_key} IN (?)", all_tags_query)
+                  .where("#{table_name}.#{primary_key} NOT IN (?)", other_tags_query)
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/no_fly_list/taggable_record/query.rb

@@ -6,93 +6,25 @@ module NoFlyList
       module_function
 
       def define_query_methods(setup)
-        context = setup.context
-        taggable_klass = setup.taggable_klass
-        singular_name = context.to_s.singularize
-
-        taggable_klass.class_eval do
-          # Find records with any of the specified tags
-          scope "with_any_#{context}", lambda { |*tags|
-            tags = tags.flatten.compact.uniq
-            return none if tags.empty?
-
-            joins(:"#{singular_name}_taggings")
-              .joins(context)
-              .where("#{singular_name}_taggings": { context: singular_name })
-              .where(context => { name: tags })
-              .distinct
-          }
-
-          # Find records without any tags
-          scope "without_#{context}", lambda {
-            where.not(
-              id: setup.tagging_class_name.constantize.where(context: singular_name).select(:taggable_id)
-            )
-          }
-
-          # Find records with all specified tags
-          scope "with_all_#{context}", lambda { |*tags|
-            tags = tags.flatten.compact.uniq
-            return none if tags.empty?
-
-            tag_count = tags.size
-            joins(:"#{singular_name}_taggings")
-              .joins(context)
-              .where("#{singular_name}_taggings": { context: singular_name })
-              .where(context => { name: tags })
-              .group(:id)
-              .having("COUNT(DISTINCT #{context}.name) = ?", tag_count)
-          }
-
-          # Find records without specific tags
-          scope "without_any_#{context}", lambda { |*tags|
-            tags = tags.flatten.compact.uniq
-            return all if tags.empty?
-
-            where.not(
-              id: joins(:"#{singular_name}_taggings")
-                    .joins(context)
-                    .where("#{singular_name}_taggings": { context: singular_name })
-                    .where(context => { name: tags })
-                    .select(:id)
-            )
-          }
-
-          # Find records with exactly these tags
-          scope "with_exact_#{context}", lambda { |*tags|
-            tags = tags.flatten.compact.uniq
+        case setup.adapter
+        when :postgresql
+          PostgresqlStrategy.define_query_methods(setup)
+        when :mysql
+          MysqlStrategy.define_query_methods(setup)
+        else
+          SqliteStrategy.define_query_methods(setup)
+        end
+      end
 
-            if tags.empty?
-              send("without_#{context}")
-            else
-              # Get records with the exact count of specified tags
-              having_exact_tags =
-                joins(:"#{singular_name}_taggings")
-                .joins(context)
-                .where("#{singular_name}_taggings": { context: singular_name })
-                .where(context => { name: tags })
-                .group(:id)
-                .having("COUNT(DISTINCT #{context}.name) = ?", tags.size)
-                .select(:id)
+      module BaseStrategy
+        module_function
 
-              # Exclude records that have any other tags
-              having_exact_tags.where.not(
-                id: joins(:"#{singular_name}_taggings")
-                      .joins(context)
-                      .where("#{singular_name}_taggings": { context: singular_name })
-                      .where.not(context => { name: tags })
-                      .select(:id)
-              )
-            end
-          }
+        def case_insensitive_where(table, column, values)
+          raise NotImplementedError
+        end
 
-          # Count tags for each record
-          scope "#{context}_count", lambda {
-            left_joins(:"#{singular_name}_taggings")
-              .where("#{singular_name}_taggings": { context: singular_name })
-              .group(:id)
-              .select("#{table_name}.*, COUNT(DISTINCT #{singular_name}_taggings.id) as #{context}_count")
-          }
+        def define_query_methods(setup)
+          raise NotImplementedError
         end
       end
     end

data/lib/no_fly_list/taggable_record/tag_setup.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  module TaggableRecord
+    class TagSetup
+      attr_reader :taggable_klass, :context, :transformer, :polymorphic,
+                  :restrict_to_existing, :limit,
+                  :tag_class_name, :tagging_class_name, :adapter
+
+      def initialize(taggable_klass, context, options = {})
+        @taggable_klass = taggable_klass
+        @context = context
+        @transformer = options.fetch(:transformer, ApplicationTagTransformer)
+        @polymorphic = options.fetch(:polymorphic, false)
+        @restrict_to_existing = options.fetch(:restrict_to_existing, false)
+        @limit = options.fetch(:limit, nil)
+        @tag_class_name = determine_tag_class_name(taggable_klass, options)
+        @tagging_class_name = determine_tagging_class_name(taggable_klass, options)
+        @adapter = determine_adapter
+      end
+
+      private
+
+      def determine_adapter
+        case ActiveRecord::Base.connection.adapter_name.downcase
+        when 'postgresql'
+          :postgresql
+        when 'mysql2'
+          :mysql
+        else
+          :sqlite
+        end
+      end
+
+      def determine_tag_class_name(taggable_klass, options)
+        if options[:polymorphic]
+          Rails.application.config.no_fly_list.tag_class_name
+        else
+          options.fetch(:tag_class_name, "#{taggable_klass.name}Tag")
+        end
+      end
+
+      def determine_tagging_class_name(taggable_klass, options)
+        if options[:polymorphic]
+          Rails.application.config.no_fly_list.tagging_class_name
+        else
+          options.fetch(:tagging_class_name, "#{taggable_klass.name}::Tagging")
+        end
+      end
+    end
+  end
+end

data/lib/no_fly_list/taggable_record.rb

@@ -5,22 +5,73 @@ module NoFlyList
     extend ActiveSupport::Concern
 
     included do
+      class_attribute :_no_fly_list, instance_writer: false
+      self._no_fly_list = Config.new self
+
       before_save :save_tag_proxies
+      before_validation :validate_tag_proxies
     end
 
     private
 
+    def validate_tag_proxies
+      return true if @validating_proxies
+
+      @validating_proxies = true
+      begin
+        instance_variables.each do |var|
+          next unless var.to_s.match?(/_list_proxy$/)
+
+          proxy = instance_variable_get(var)
+          next if proxy.nil? || proxy.valid?
+
+          proxy.errors.each do |error|
+            errors.add(:base, error.message)
+          end
+          return false
+        end
+        true
+      ensure
+        @validating_proxies = false
+      end
+    end
+
     def save_tag_proxies
-      instance_variables.each do |var|
-        next unless var.to_s.match?(/_list_proxy$/)
+      return true if @saving_proxies
+
+      @saving_proxies = true
+      begin
+        instance_variables.each do |var|
+          next unless var.to_s.match?(/_list_proxy$/)
 
-        proxy = instance_variable_get(var)
-        return false unless proxy.save
+          proxy = instance_variable_get(var)
+          next if proxy.nil?
+          return false unless proxy.save
+        end
+        true
+      ensure
+        @saving_proxies = false
       end
     end
 
+    def no_fly_list_config
+      self.class._no_fly_list
+    end
+
+    def tag_contexts
+      no_fly_list_config.tag_contexts
+    end
+
+    def options_for_context(context)
+      tag_contexts[context.to_sym]
+    end
+
     class_methods do
       def has_tags(*contexts, **options)
+        contexts.each do |context|
+          _no_fly_list.add_context(context, options)
+        end
+
         Configuration.setup_tagging(self, contexts, options)
       end
     end

data/lib/no_fly_list/tagging_proxy.rb

@@ -57,19 +57,48 @@ module NoFlyList
     # @return [Boolean] true if the proxy is valid
     def save
       return true unless @pending_changes.any?
+      return false unless valid?
+
+      # Prevent recursive validation
+      @saving = true
+      begin
+        model.class.transaction do
+          # Always save parent first if needed
+          if model.new_record? && !model.save
+            errors.add(:base, 'Failed to save parent record')
+            raise ActiveRecord::Rollback
+          end
+
+          # Clear existing tags
+          model.send(context_taggings).delete_all
 
-      if valid?
-        @model.transaction do
-          @model.send(@context.to_s).destroy_all
+          # Create new tags
           @pending_changes.each do |tag_name|
             tag = find_or_create_tag(tag_name)
-            @model.send(@context.to_s) << tag if tag
+            next unless tag
+
+            attributes = {
+              tag: tag,
+              context: @context.to_s.singularize
+            }
+
+            if setup[:polymorphic]
+              attributes[:taggable_type] = model.class.name
+              attributes[:taggable_id] = model.id
+            end
+
+            # Use create! to ensure we catch any errors
+            model.send(context_taggings).create!(attributes)
           end
         end
+
         refresh_from_database
         true
-      else
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved => e
+        errors.add(:base, e.message)
         false
+      ensure
+        @saving = false
       end
     end
 
@@ -175,14 +204,6 @@ module NoFlyList
       current_list
     end
 
-    def current_list
-      if @pending_changes.any?
-        @pending_changes
-      else
-        @model.send(@context.to_s).pluck(:name)
-      end
-    end
-
     def refresh_from_database
       @pending_changes = []
     end
@@ -198,7 +219,9 @@ module NoFlyList
       return unless @restrict_to_existing
       return if @pending_changes.empty?
 
-      existing_tags = @tag_model.where(name: @pending_changes).pluck(:name)
+      # Transform tags to lowercase for comparison
+      normalized_changes = @pending_changes.map(&:downcase)
+      existing_tags = @tag_model.where('LOWER(name) IN (?)', normalized_changes).pluck(:name)
       missing_tags = @pending_changes - existing_tags
 
       return unless missing_tags.any?
@@ -206,6 +229,17 @@ module NoFlyList
       errors.add(:base, "The following tags do not exist: #{missing_tags.join(', ')}")
     end
 
+    def context_taggings
+      @context_taggings ||= "#{@context.to_s.singularize}_taggings"
+    end
+
+    def setup
+      @setup ||= begin
+        context = @context.to_sym
+        @model.class._no_fly_list.tag_contexts[context]
+      end
+    end
+
     def find_or_create_tag(tag_name)
       if @restrict_to_existing
         @tag_model.find_by(name: tag_name)
@@ -214,6 +248,49 @@ module NoFlyList
       end
     end
 
+    def save_changes
+      # Clear existing tags
+      model.send(context_taggings).delete_all
+
+      # Create new tags
+      @pending_changes.each do |tag_name|
+        tag = find_or_create_tag(tag_name)
+        next unless tag
+
+        attributes = {
+          tag: tag,
+          context: @context.to_s.singularize
+        }
+
+        # Add polymorphic attributes for polymorphic tags
+        if setup[:polymorphic]
+          attributes[:taggable_type] = model.class.name
+          attributes[:taggable_id] = model.id
+        end
+
+        # Use create! to ensure we catch any errors
+        model.send(context_taggings).create!(attributes)
+      end
+
+      refresh_from_database
+      true
+    end
+
+    def current_list
+      if @pending_changes.any?
+        @pending_changes
+      elsif setup[:polymorphic]
+        tagging_table = setup[:tagging_class_name].tableize
+        @model.send(@context.to_s)
+              .joins("INNER JOIN #{tagging_table} ON #{tagging_table}.tag_id = tags.id")
+              .where("#{tagging_table}.taggable_type = ? AND #{tagging_table}.taggable_id = ?",
+                     @model.class.name, @model.id)
+              .pluck(:name)
+      else
+        @model.send(@context.to_s).pluck(:name)
+      end
+    end
+
     def limit_reached?
       @limit && current_list.size >= @limit
     end