no_fly_list 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fbe92a4791b7cf24e4a2ca876b1c7f62cd5a37d653cdcad45f752a393c04f16
-  data.tar.gz: 00c74e1f82fea31e30f517ff102d5fc41c714392c73b05c841737837b521b370
+  metadata.gz: a736dbad67c9674eb172dc3633226f261d4d6bfaba47e06b3c539f98dfbfc439
+  data.tar.gz: 378ddddcfc84f69bc667df66195a87298705f6fe4ebd3067bce71d295a7eb309
 SHA512:
-  metadata.gz: 590cf033d9ed9fa653341b8aedb2e731244e45505b0945147e7da1ca0fac264e7f161cd5bb5608e95c5567f17fdba5837338e851e1dc76d707b8bfef379974ce
-  data.tar.gz: b55be12266e3e9ee2deeb8fa82aa4e405762ad8a2f3bb6643933f30dab10a918b5add73ffb7a29b17f741be404afc952027e53e85c4253f8deee4d6630b3966b
+  metadata.gz: 2f5dada9474e4defdd42556d2ab049a85774d9d7e75966c75ceac76ec9c1a793873f13b06281a12089264aa64de94268db2b5e1724d3bccf2e8c9c79062ceba9
+  data.tar.gz: 888516a4c63cc367b976e7c0626efef8d65cb06d9d3d207f6100a0a6cb3590528f1f6f3f44b7fb697cb8bf3271f90d23878725615dd1304f10d74fa0fc313198

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

@@ -1,15 +1,25 @@
 class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
   def up
     create_table :application_tags do |t|
-      t.string :name
-      t.timestamps
+      t.string :name, null: false, index: { unique: true }
+      t.timestamp :created_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
+      t.timestamp :updated_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
     end
 
     create_table :application_taggings do |t|
-      t.bigint :tag_id, null: false
-      t.foreign_key :application_tags, column: :tag_id
+      t.references :tag, null: false, foreign_key: { to_table: :application_tags }
       t.references :taggable, polymorphic: true, null: false
-      t.timestamps
+      t.string :context, null: false
+      t.timestamp :created_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
+      t.timestamp :updated_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
+
+      # Add index for uniqueness and performance
+      t.index [:taggable_type, :taggable_id, :context, :tag_id],
+              unique: true,
+              name: 'index_app_taggings_uniqueness'
+
+      # Add index for faster lookups by context
+      t.index [:context]
     end
   end
 end

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

@@ -2,14 +2,16 @@ class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version
   def change
     create_table :<%= tag_table_name %>, id: :bigint do |t|
       t.string :name, null: false
-      t.timestamps default: -> { 'CURRENT_TIMESTAMP' }
+      t.timestamp :created_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
+      t.timestamp :updated_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
     end
 
     create_table :<%= tagging_table_name %> do |t|
       t.column :taggable_id, :bigint, null: false, index: true # Change to :uuid if you are using UUIDs
       t.column :tag_id, :bigint, null: false, index: true
       t.string :context, null: false
-      t.timestamps default: -> { 'CURRENT_TIMESTAMP' }
+      t.timestamp :created_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
+      t.timestamp :updated_at, default: -> { 'CURRENT_TIMESTAMP' }, null: false
     end
 
     add_index :<%= tag_table_name %>, :name, unique: true

data/lib/no_fly_list/application_tag.rb

@@ -12,12 +12,5 @@ module NoFlyList
   #   end
   module ApplicationTag
     extend ActiveSupport::Concern
-
-    included do
-      self.table_name = Rails.configuration.no_fly_list.application_tag_table_name || 'application_tags'
-
-      has_many :taggings, class_name: 'ApplicationTagging', dependent: :destroy, foreign_key: 'tag_id'
-      has_many :taggables, through: :taggings, source: :taggable
-    end
   end
 end

data/lib/no_fly_list/application_tagging.rb

@@ -12,11 +12,5 @@ module NoFlyList
   #   end
   module ApplicationTagging
     extend ActiveSupport::Concern
-
-    included do
-      self.table_name = Rails.configuration.no_fly_list.application_tagging_table_name || 'application_taggings'
-      belongs_to :tag, class_name: 'ApplicationTag', foreign_key: 'tag_id'
-      belongs_to :taggable, polymorphic: true
-    end
   end
 end

data/lib/no_fly_list/tag_record.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module NoFlyList
-  # This module provides functionality for a tag table that contains global tags for a model.
+  # This module provides functionality for a tag table that contains tags for a model.
   #
   # @example Usage
   #   class User::Tag < ApplicationRecord
-  #     include NoFlyList::TagModel
+  #     include NoFlyList::TagRecord
   #   end
   module TagRecord
     extend ActiveSupport::Concern

data/lib/no_fly_list/taggable_record/config.rb

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

data/lib/no_fly_list/taggable_record/configuration.rb

@@ -2,56 +2,64 @@
 
 require_relative 'mutation'
 require_relative 'query'
+require_relative 'tag_setup'
 
 module NoFlyList
   module TaggableRecord
+    # Configuration module handles the setup and structure of tagging functionality
+    # This includes creating necessary classes, setting up associations, and defining
+    # the interface for tag manipulation
     module Configuration
       module_function
 
+      # Main entry point for setting up tagging functionality on a model
+      # @param taggable_klass [Class] The model class to make taggable
+      # @param contexts [Array<Symbol>] The contexts to create tags for (e.g., :tags, :colors)
+      # @param options [Hash] Configuration options for tagging behavior
       def setup_tagging(taggable_klass, contexts, options = {})
         contexts.each do |context|
           setup = build_tag_setup(taggable_klass, context, options)
           define_tag_structure(setup)
           define_list_methods(setup)
-          Mutation.define_mutation_methods(setup) # Add mutation methods
-          Query.define_query_methods(setup) # Add query methods
+          Mutation.define_mutation_methods(setup)
+          Query.define_query_methods(setup)
         end
       end
 
+      # Creates a new TagSetup instance with the given configuration
       def build_tag_setup(taggable_klass, context, options)
-        OpenStruct.new(
-          taggable_klass: taggable_klass,
-          context: context,
-          transformer: options.fetch(:transformer, ApplicationTagTransformer),
-          global: options.fetch(:global, 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)
-        )
+        TagSetup.new(taggable_klass, context, options)
       end
 
+      # Determines the appropriate class name for tags based on configuration
+      # For global tags, uses application-wide tag class
+      # For local tags, creates model-specific tag classes
       def determine_tag_class_name(taggable_klass, options)
-        if options[:global]
+        if options[:polymorphic]
           Rails.application.config.no_fly_list.tag_class_name
         else
           options.fetch(:tag_class_name, "#{taggable_klass.name}Tag")
         end
       end
 
+      # Determines the appropriate class name for taggings based on configuration
+      # For global tags, uses application-wide tagging class
+      # For local tags, creates model-specific tagging classes
       def determine_tagging_class_name(taggable_klass, options)
-        if options[:global]
+        if options[:polymorphic]
           Rails.application.config.no_fly_list.tagging_class_name
         else
           options.fetch(:tagging_class_name, "#{taggable_klass.name}::Tagging")
         end
       end
 
+      # Sets up the complete tag structure including classes and associations
       def define_tag_structure(setup)
-        define_tag_classes(setup) unless setup.global
+        define_tag_classes(setup) unless setup.polymorphic
         define_tagging_associations(setup)
       end
 
+      # Creates the tag and tagging classes for local (non-global) tags
       def define_tag_classes(setup)
         base_class = find_abstract_class(setup.taggable_klass)
 
@@ -64,40 +72,159 @@ module NoFlyList
         end
       end
 
+      # Creates a new tag class with appropriate configuration
       def create_tag_class(setup, base_class)
         Class.new(base_class) do
           self.table_name = "#{setup.taggable_klass.table_name.singularize}_tags"
-
-          has_many :taggings, class_name: setup.tagging_class_name, dependent: :destroy
-          has_many :taggables, through: :taggings, source: :taggable, source_type: setup.taggable_klass.name
           include NoFlyList::TagRecord
         end
       end
 
+      # Creates a new tagging class with appropriate configuration
       def create_tagging_class(setup, base_class)
+        setup.context.to_s.singularize
+
         Class.new(base_class) do
           self.table_name = "#{setup.taggable_klass.table_name.singularize}_taggings"
 
-          belongs_to :taggable, class_name: setup.taggable_klass.name, foreign_key: 'taggable_id'
-          belongs_to :tag, class_name: setup.tag_class_name
+          # Add the basic associations
+          belongs_to :tag,
+                     class_name: setup.tag_class_name,
+                     foreign_key: 'tag_id'
+
+          belongs_to :taggable,
+                     class_name: setup.taggable_klass.name,
+                     foreign_key: 'taggable_id'
+
           include NoFlyList::TaggingRecord
         end
       end
 
+      # Sets up all necessary associations between tags, taggings, and the taggable model
       def define_tagging_associations(setup)
         singular_name = setup.context.to_s.singularize
 
-        setup.taggable_klass.class_eval do
-          has_many :"#{singular_name}_taggings",
+        if setup.polymorphic
+          setup_polymorphic_tag_associations(setup, singular_name)
+        else
+          setup_local_tag_associations(setup, singular_name)
+        end
+
+        setup_taggable_associations(setup, singular_name)
+      end
+
+      # Sets up associations for polymorphic tags
+      def setup_polymorphic_tag_associations(setup, singular_name)
+        # Set up the tag model associations
+        setup.tag_class_name.constantize.class_eval do
+          # Fix: Use 'tagging' for the join association when context is 'tag'
+          association_name = (singular_name == 'tag' ? :taggings : :"#{singular_name}_taggings")
+
+          has_many association_name,
                    -> { where(context: singular_name) },
                    class_name: setup.tagging_class_name,
-                   foreign_key: 'taggable_id',
+                   foreign_key: 'tag_id',
                    dependent: :destroy
 
+          # Fix: Use consistent naming for through association
           has_many setup.context,
+                   through: association_name,
+                   source: :taggable,
+                   source_type: setup.taggable_klass.name
+        end
+
+        # Set up the tagging model with global scope
+        setup.tagging_class_name.constantize.class_eval do
+          belongs_to :tag,
+                     class_name: setup.tag_class_name,
+                     foreign_key: 'tag_id'
+
+          belongs_to :taggable,
+                     polymorphic: true
+
+          validates :tag, :taggable, :context, presence: true
+
+          # Add scope for specific taggable type
+          scope :for_taggable_type, ->(type) { where(taggable_type: type) }
+
+          validates :tag_id, uniqueness: {
+            scope: %i[taggable_type taggable_id context],
+            message: 'has already been tagged on this record in this context'
+          }
+        end
+      end
+
+      # Sets up associations for local (non-global) tags
+      def setup_local_tag_associations(setup, singular_name)
+        # Set up tag class associations
+        setup.tag_class_name.constantize.class_eval do
+          has_many :"#{singular_name}_taggings",
+                   -> { where(context: singular_name) },
+                   class_name: setup.tagging_class_name,
+                   foreign_key: 'tag_id',
+                   dependent: :destroy
+
+          has_many :"#{singular_name}_taggables",
                    through: :"#{singular_name}_taggings",
-                   source: :tag,
-                   class_name: setup.tag_class_name
+                   source: :taggable
+        end
+
+        # Set up tagging class associations
+        setup.tagging_class_name.constantize.class_eval do
+          belongs_to :tag,
+                     class_name: setup.tag_class_name,
+                     foreign_key: 'tag_id'
+
+          # For local tags, we use a simple belongs_to without polymorphic
+          belongs_to :taggable,
+                     class_name: setup.taggable_klass.name,
+                     foreign_key: 'taggable_id'
+
+          validates :tag, :taggable, :context, presence: true
+          validates :tag_id, uniqueness: {
+            scope: %i[taggable_id context],
+            message: 'has already been tagged on this record in this context'
+          }
+        end
+      end
+
+      # Sets up associations on the taggable model
+      def setup_taggable_associations(setup, singular_name)
+        setup.taggable_klass.class_eval do
+          if setup.polymorphic
+            # Global tags need polymorphic associations
+            has_many :"#{singular_name}_taggings",
+                     -> { where(context: singular_name) },
+                     class_name: setup.tagging_class_name,
+                     foreign_key: 'taggable_id',
+                     as: :taggable,
+                     dependent: :destroy
+
+            has_many setup.context,
+                     through: :"#{singular_name}_taggings",
+                     source: :tag,
+                     class_name: setup.tag_class_name do
+              def by_type(taggable_type)
+                where(taggings: { taggable_type: taggable_type })
+              end
+
+              def shared_with(other_taggable)
+                where(id: other_taggable.send(proxy_association.name).pluck(:id))
+              end
+            end
+          else
+            # Local tags should use simple associations
+            has_many :"#{singular_name}_taggings",
+                     -> { where(context: singular_name) },
+                     class_name: setup.tagging_class_name,
+                     foreign_key: 'taggable_id',
+                     dependent: :destroy
+
+            has_many setup.context,
+                     through: :"#{singular_name}_taggings",
+                     source: :tag,
+                     class_name: setup.tag_class_name
+          end
         end
       end
 
@@ -108,13 +235,13 @@ module NoFlyList
         # Define helper methods module for this context
         helper_module = Module.new do
           define_method :create_and_set_proxy do |instance_variable_name, setup|
-            tag_model = if setup.global
+            tag_model = if setup.polymorphic
                           setup.tag_class_name.constantize
                         else
                           self.class.const_get("#{self.class.name}Tag")
                         end
 
-            proxy = NoFlyList::TaggingProxy.new(
+            proxy = TaggingProxy.new(
               self,
               tag_model,
               setup.context,

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  module TaggableRecord
+    module Query
+      module MysqlStrategy
+        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 # Arel
+          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("#{table_name}.#{primary_key} NOT IN (?)", 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("#{table_name}.#{primary_key} 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 = ?", 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