no_fly_list 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0fbe92a4791b7cf24e4a2ca876b1c7f62cd5a37d653cdcad45f752a393c04f16
+  data.tar.gz: 00c74e1f82fea31e30f517ff102d5fc41c714392c73b05c841737837b521b370
+SHA512:
+  metadata.gz: 590cf033d9ed9fa653341b8aedb2e731244e45505b0945147e7da1ca0fac264e7f161cd5bb5608e95c5567f17fdba5837338e851e1dc76d707b8bfef379974ce
+  data.tar.gz: b55be12266e3e9ee2deeb8fa82aa4e405762ad8a2f3bb6643933f30dab10a918b5add73ffb7a29b17f741be404afc952027e53e85c4253f8deee4d6630b3966b

data/lib/generators/no_fly_list/install_generator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+require 'rails/generators/named_base'
+
+# Usage:
+# bin/rails generate no_fly_list:application_tag
+
+module NoFlyList
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path('templates', __dir__)
+
+      argument :connection_name, type: :string, desc: 'The name of the database connection', default: 'primary'
+
+      def copy_application_tag
+        ensure_connection_exists
+        template 'application_tag.rb.erb', File.join('app/models', 'application_tag.rb')
+        template 'application_tagging.rb.erb', File.join('app/models', 'application_tagging.rb')
+        migration_template 'create_application_tagging_table.rb.erb', 'db/migrate/create_application_tagging_table.rb'
+      end
+
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      private
+
+      def ensure_connection_exists
+        connection_db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).find do |config|
+          config.name == connection_name
+        end
+        return if connection_db_config
+
+        say "Connection '#{connection_name}' does not exist. Please provide a valid connection name."
+      end
+
+      def connection_abstract_class_name
+        # should be abstract class name
+        ActiveRecord::Base.descendants.find do |klass|
+          klass.abstract_class? && klass.connection_db_config.name == connection_name
+        end.name
+      end
+
+      def migration_version
+        "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/no_fly_list/models_generator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'rails/generators'
+require 'rails/generators/active_record'
+require 'rails/generators/named_base'
+
+module NoFlyList
+  module Generators
+    class ModelsGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('templates', __dir__)
+
+      def create_model_files
+        return unless validate_model # Ensure it's an ActiveRecord model
+
+        template 'tagging_model.rb.erb', File.join('app/models', class_path, "#{file_name.underscore}/tagging.rb")
+        template 'tag_model.rb.erb', File.join('app/models', class_path, "#{file_name.underscore}_tag.rb")
+      end
+
+      private
+
+      def model_class
+        @model_class ||= class_name.constantize
+      end
+      alias taggable_klass class_name
+
+      def tag_class_name
+        "#{class_name}Tag"
+      end
+
+      def tagging_class_name
+        "#{class_name}::Tagging"
+      end
+
+      def validate_model
+        if model_class < ActiveRecord::Base
+          true
+        else
+          say "#{class_name} is not an ActiveRecord model. Aborting generator.", :red
+          false
+        end
+      rescue NameError
+        say "#{class_name} is not a valid constant. Aborting generator.", :red
+        false
+      end
+
+      def model_abstract_class_name
+        model_class.ancestors.find do |klass|
+          klass.is_a?(Class) && klass.abstract_class?
+        end.name
+      end
+    end
+  end
+end

data/lib/generators/no_fly_list/tagging_generator.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'rails/generators'
+require 'rails/generators/active_record'
+require 'rails/generators/named_base'
+
+module NoFlyList
+  module Generators
+    class TaggingGenerator < Rails::Generators::NamedBase
+      include ActiveRecord::Generators::Migration
+
+      class_option :database, type: :string, default: 'primary',
+                              desc: 'Use different database for migration'
+
+      def self.default_generator_root
+        File.dirname(__FILE__)
+      end
+
+      def create_migration_file
+        ensure_model_exists
+        migration_template 'create_tagging_table.rb.erb',
+                           [db_migrate_path, "create_#{migration_name}.rb"].compact.join('/')
+      end
+
+      def self.next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      private
+
+      def ensure_model_exists
+        name.constantize
+      rescue NameError
+        raise ArgumentError, "Model '#{name}' does not exist. Please provide a valid model name."
+      end
+
+      def migration_name
+        "tagging_#{name.underscore.tr('/', '_')}"
+      end
+
+      def migration_class_name
+        "CreateTagging#{name.gsub('::', '')}"
+      end
+
+      def target_class
+        @target_class ||= name.constantize
+      end
+
+      def model_table_name
+        target_class.table_name
+      end
+
+      def tag_table_name
+        "#{model_table_name.singularize}_tags"
+      end
+
+      def tagging_table_name
+        "#{model_table_name.singularize}_taggings"
+      end
+
+      def migration_version
+        "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+class ApplicationTag < <%= connection_abstract_class_name %>
+  include NoFlyList::ApplicationTag
+end

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

@@ -0,0 +1,3 @@
+class ApplicationTagging < <%= connection_abstract_class_name %>
+  include NoFlyList::ApplicationTagging
+end

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

@@ -0,0 +1,15 @@
+class <%= migration_class_name %> < ActiveRecord::Migration<%= migration_version %>
+  def up
+    create_table :application_tags do |t|
+      t.string :name
+      t.timestamps
+    end
+
+    create_table :application_taggings do |t|
+      t.bigint :tag_id, null: false
+      t.foreign_key :application_tags, column: :tag_id
+      t.references :taggable, polymorphic: true, null: false
+      t.timestamps
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+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' }
+    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' }
+    end
+
+    add_index :<%= tag_table_name %>, :name, unique: true
+    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
+  end
+end

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

@@ -0,0 +1,9 @@
+<% module_namespacing do -%>
+class <%= taggable_klass %>Tag < <%= model_abstract_class_name %>
+  self.table_name = '<%="#{model_class.table_name.singularize}_tags" %>'
+
+  has_many :taggings, class_name: '<%= tagging_class_name %>', dependent: :destroy
+  has_many :taggables, through: :taggings, source: :taggable, source_type: '<%= taggable_klass %>'
+  include NoFlyList::TagRecord
+end
+<% end -%>

data/lib/generators/no_fly_list/templates/tag_parser.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ApplicationTagTransformer
+  module_function
+
+  # @param tags [String|Array<String>]
+  def parse_tags(tags)
+    tags = recreate_string(tags) if tags.is_a?(Array)
+    tags.split(separator).map(&:strip)
+  end
+
+  # Recreate a string from an array of tags
+  # @param tags [Array<String>]
+  # @return [String]
+  def recreate_string(tags)
+    tags.join(separator)
+  end
+
+  # @return [String]
+  def separator
+    ','
+  end
+end

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

@@ -0,0 +1,9 @@
+<% module_namespacing do -%>
+class <%= taggable_klass %>::Tagging < <%= model_abstract_class_name %>
+  self.table_name = '<%="#{model_class.table_name.singularize}_taggings"  %>'
+
+  belongs_to :taggable, class_name: '<%= model_class.name  %>', foreign_key: 'taggable_id'
+  belongs_to :tag, class_name: '<%= tag_class_name %>'
+  include NoFlyList::TaggingRecord
+end
+<% end -%>

data/lib/generators/no_fly_list/transformer_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'rails/generators'
+require 'rails/generators/active_record'
+require 'rails/generators/named_base'
+
+unless defined?(ApplicationTagTransformer)
+  module NoFlyList
+    module Generators
+      class TransformerGenerator < Rails::Generators::Base
+        source_root File.expand_path('templates', __dir__)
+        def create_tag_transformer_file
+          template 'tag_transformer.rb', File.join('app/transformers', 'application_tag_transformer.rb')
+        end
+      end
+    end
+  end
+end

data/lib/no_fly_list/application_tag.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  # This module provides functionality for global tags.
+  # Only one instance of this tag is allowed per database/schema.
+  #
+  # This concern can be included in models that represent global tags to ensure uniqueness across the database/schema.
+  #
+  # @example Usage
+  #   class ApplicationTag < ApplicationRecord
+  #     include NoFlyList::ApplicationTag
+  #   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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  # This module provides functionality for global tags.
+  # Only one instance of this tag is allowed per database/schema.
+  #
+  # This concern can be included in models that represent global tags to ensure uniqueness across the database/schema.
+  #
+  # @example Usage
+  #   class ApplicationTagging < ApplicationRecord
+  #     include NoFlyList::ApplicationTagging
+  #   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/railtie.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'active_record/railtie'
+require 'rails'
+
+module NoFlyList
+  class Railtie < Rails::Railtie # :nodoc:
+    config.no_fly_list = ActiveSupport::OrderedOptions.new
+    config.no_fly_list.tag_class_name = 'ApplicationTag'
+    config.no_fly_list.tag_table_name = 'application_tags'
+    config.no_fly_list.tagging_class_name = 'ApplicationTagging'
+    config.no_fly_list.tagging_table_name = 'application_taggings'
+
+    rake_tasks do
+      load 'no_fly_list/railties/tasks.rake'
+    end
+  end
+end

data/lib/no_fly_list/railties/tasks.rake

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+namespace :no_fly_list do
+  desc 'List all taggable records'
+  task taggable_records: :environment do
+    Rails.application.eager_load!
+    taggable_classes = ActiveRecord::Base.descendants.select do |klass|
+      klass.included_modules.any? { |mod| mod.in?([NoFlyList::TaggableRecord]) }
+    end
+
+    puts "Found #{taggable_classes.size} taggable classes:\n\n"
+
+    taggable_classes.each do |klass|
+      puts "Class: #{klass.name}"
+    end
+  end
+
+  desc 'List all tag records'
+  task tag_records: :environment do
+    Rails.application.eager_load!
+    tag_classes = ActiveRecord::Base.descendants.select do |klass|
+      klass.included_modules.any? { |mod| mod.in?([NoFlyList::ApplicationTag, NoFlyList::TagRecord]) }
+    end
+
+    puts "Found #{tag_classes.size} tag classes:\n\n"
+
+    tag_classes.each do |klass|
+      puts "Class: #{klass.name}"
+    end
+  end
+
+  desc 'Check taggable records and their associated tables'
+  task check_taggable_records: :environment do
+    Rails.application.eager_load!
+    taggable_classes = ActiveRecord::Base.descendants.select do |klass|
+      klass.included_modules.any? { |mod| mod.in?([NoFlyList::TaggableRecord]) }
+    end
+
+    puts "Checking #{taggable_classes.size} taggable classes:\n\n"
+
+    taggable_classes.each do |klass|
+      puts "Checking Class: #{klass.name}"
+
+      # ANSI color codes
+      green = "\e[32m"
+      red = "\e[31m"
+      reset = "\e[0m"
+
+      # Check main table exists
+      begin
+        klass.table_exists?
+        puts "  #{green}✓#{reset} Main table exists: #{klass.table_name}"
+      rescue StandardError => e
+        puts "  #{red}✗#{reset} Error checking main table: #{e.message}"
+      end
+
+      # Dynamically find tag and tagging class names
+      tag_class_name = "#{klass.name}Tag"
+      tagging_class_name = "#{klass.name}::Tagging"
+
+      begin
+        tag_class = Object.const_get(tag_class_name)
+
+        # Check tags table exists
+        if tag_class.table_exists?
+          puts "  #{green}✓#{reset} Tags table exists: #{tag_class.table_name}"
+        else
+          puts "  #{red}✗#{reset} Tags table missing: #{tag_class.table_name}"
+        end
+      rescue NameError
+        puts "  #{red}✗#{reset} Tag class not found: #{tag_class_name}"
+      rescue StandardError => e
+        puts "  #{red}✗#{reset} Error checking tag class: #{e.message}"
+      end
+
+      begin
+        tagging_class = Object.const_get(tagging_class_name)
+
+        # Check taggings table exists
+        if tagging_class.table_exists?
+          puts "  #{green}✓#{reset} Taggings table exists: #{tagging_class.table_name}"
+        else
+          puts "  #{red}✗#{reset} Taggings table missing: #{tagging_class.table_name}"
+        end
+      rescue NameError
+        puts "  #{red}✗#{reset} Tagging class not found: #{tagging_class_name}"
+      rescue StandardError => e
+        puts "  #{red}✗#{reset} Error checking tagging class: #{e.message}"
+      end
+
+      puts "\n"
+    end
+  end
+end

data/lib/no_fly_list/tag_record.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  # This module provides functionality for a tag table that contains global tags for a model.
+  #
+  # @example Usage
+  #   class User::Tag < ApplicationRecord
+  #     include NoFlyList::TagModel
+  #   end
+  module TagRecord
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :to_s, to: :name
+      alias_attribute :tag_name, :name
+      def inspect
+        "#<#{self.class.name} id: #{id}, name: #{name} >"
+      end
+    end
+  end
+end

data/lib/no_fly_list/taggable_record/configuration.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative 'mutation'
+require_relative 'query'
+
+module NoFlyList
+  module TaggableRecord
+    module Configuration
+      module_function
+
+      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
+        end
+      end
+
+      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)
+        )
+      end
+
+      def determine_tag_class_name(taggable_klass, options)
+        if options[:global]
+          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[:global]
+          Rails.application.config.no_fly_list.tagging_class_name
+        else
+          options.fetch(:tagging_class_name, "#{taggable_klass.name}::Tagging")
+        end
+      end
+
+      def define_tag_structure(setup)
+        define_tag_classes(setup) unless setup.global
+        define_tagging_associations(setup)
+      end
+
+      def define_tag_classes(setup)
+        base_class = find_abstract_class(setup.taggable_klass)
+
+        define_constant_in_namespace(setup.tag_class_name) do
+          create_tag_class(setup, base_class)
+        end
+
+        define_constant_in_namespace(setup.tagging_class_name) do
+          create_tagging_class(setup, base_class)
+        end
+      end
+
+      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
+
+      def create_tagging_class(setup, base_class)
+        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
+          include NoFlyList::TaggingRecord
+        end
+      end
+
+      def define_tagging_associations(setup)
+        singular_name = setup.context.to_s.singularize
+
+        setup.taggable_klass.class_eval do
+          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
+
+      def define_list_methods(setup)
+        context = setup.context
+        taggable_klass = setup.taggable_klass
+
+        # 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
+                          setup.tag_class_name.constantize
+                        else
+                          self.class.const_get("#{self.class.name}Tag")
+                        end
+
+            proxy = NoFlyList::TaggingProxy.new(
+              self,
+              tag_model,
+              setup.context,
+              transformer: setup.transformer,
+              restrict_to_existing: setup.restrict_to_existing,
+              limit: calculate_limit(setup.limit)
+            )
+            instance_variable_set(instance_variable_name, proxy)
+          end
+
+          define_method :calculate_limit do |limit|
+            limit.is_a?(Proc) ? limit.call(self) : limit
+          end
+
+          define_method :reset_proxy_for do |context|
+            instance_variable_name = "@_#{context}_list_proxy"
+            remove_instance_variable(instance_variable_name) if instance_variable_defined?(instance_variable_name)
+          end
+        end
+
+        # Include the helper methods
+        taggable_klass.include(helper_module)
+
+        # Define the public interface methods
+        taggable_klass.class_eval do
+          define_method "#{context}_list" do
+            instance_variable_name = "@_#{context}_list_proxy"
+
+            if instance_variable_defined?(instance_variable_name)
+              instance_variable_get(instance_variable_name)
+            else
+              create_and_set_proxy(instance_variable_name, setup)
+            end
+          end
+
+          define_method "#{context}_list=" do |tag_list|
+            reset_proxy_for(context)
+            proxy = send("#{context}_list")
+            proxy.send("#{context}_list=", tag_list)
+          end
+
+          define_method "reset_#{context}_list" do
+            reset_proxy_for(context)
+          end
+        end
+      end
+
+      def find_abstract_class(klass)
+        while klass && !klass.abstract_class?
+          klass = klass.superclass
+          break if klass == ActiveRecord::Base || klass.nil?
+        end
+        klass || ActiveRecord::Base
+      end
+
+      def define_constant_in_namespace(const_name)
+        parts = const_name.split('::')
+        const_name = parts.pop
+        namespace = parts.join('::').safe_constantize || Object
+        return if namespace.const_defined?(const_name, false)
+
+        namespace.const_set(const_name, yield)
+      end
+    end
+  end
+end

data/lib/no_fly_list/taggable_record/mutation.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  module TaggableRecord
+    module Mutation
+      module_function
+
+      def define_mutation_methods(setup)
+        context = setup.context
+        taggable_klass = setup.taggable_klass
+
+        taggable_klass.class_eval do
+          # Add multiple tags
+          define_method "add_#{context}" do |*tags|
+            send("#{context}_list").add(*tags)
+          end
+          alias_method "add_#{context}=", "add_#{context}"
+
+          # Remove multiple tags
+          define_method "remove_#{context}" do |*tags|
+            send("#{context}_list").remove(*tags)
+          end
+          alias_method "remove_#{context}=", "remove_#{context}"
+
+          # Set tags (replaces existing)
+          define_method "set_#{context}" do |*tags|
+            send("#{context}_list=", tags)
+          end
+          alias_method "set_#{context}=", "set_#{context}"
+
+          # Clear all tags
+          define_method "clear_#{context}" do
+            send("#{context}_list").clear
+          end
+
+          define_method "clear_#{context}!" do
+            send("#{context}_list").clear!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/no_fly_list/taggable_record/query.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  module TaggableRecord
+    module Query
+      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
+
+            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)
+
+              # 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
+          }
+
+          # 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")
+          }
+        end
+      end
+    end
+  end
+end

data/lib/no_fly_list/taggable_record.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  module TaggableRecord
+    extend ActiveSupport::Concern
+
+    included do
+      before_save :save_tag_proxies
+    end
+
+    private
+
+    def save_tag_proxies
+      instance_variables.each do |var|
+        next unless var.to_s.match?(/_list_proxy$/)
+
+        proxy = instance_variable_get(var)
+        return false unless proxy.save
+      end
+    end
+
+    class_methods do
+      def has_tags(*contexts, **options)
+        Configuration.setup_tagging(self, contexts, options)
+      end
+    end
+  end
+end

data/lib/no_fly_list/tagging_proxy.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  class TaggingProxy
+    include Enumerable
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
+    extend ActiveModel::Naming
+
+    delegate :blank?, :present?, :each, :==, to: :current_list
+    attr_reader :model, :tag_model, :context, :transformer
+
+    validate :validate_limit
+    validate :validate_existing_tags
+
+    def initialize(model, tag_model, context,
+                   transformer: ApplicationTagTransformer,
+                   restrict_to_existing: false,
+                   limit: nil)
+      @model = model
+      @tag_model = tag_model
+      @context = context
+      @transformer = transformer.is_a?(String) ? transformer.constantize : transformer
+      @restrict_to_existing = restrict_to_existing
+      @limit = limit
+      @pending_changes = []
+    end
+
+    def method_missing(method_name, *args)
+      if current_list.respond_to?(method_name)
+        current_list.send(method_name, *args)
+      else
+        case method_name.to_s
+        when /\A(.+)_list=\z/
+          set_list(::Regexp.last_match(1), args.first)
+        when /\A(.+)_list\z/
+          get_list(::Regexp.last_match(1))
+        else
+          super
+        end
+      end
+    end
+
+    def respond_to_missing?(method_name, _include_private = false)
+      current_list.respond_to?(method_name) ||
+        method_name.to_s =~ /\A(.+)_list(=)?\z/
+    end
+
+    def coerce(other)
+      [other, to_a]
+    end
+
+    def to_ary
+      current_list
+    end
+
+    # @return [Boolean] true if the proxy is valid
+    def save
+      return true unless @pending_changes.any?
+
+      if valid?
+        @model.transaction do
+          @model.send(@context.to_s).destroy_all
+          @pending_changes.each do |tag_name|
+            tag = find_or_create_tag(tag_name)
+            @model.send(@context.to_s) << tag if tag
+          end
+        end
+        refresh_from_database
+        true
+      else
+        false
+      end
+    end
+
+    # @raise [ActiveModel::ValidationError] if the proxy is not valid
+    # @return [Boolean] true if the proxy is valid and the changes were saved
+    def save!
+      valid? || raise(ActiveModel::ValidationError, self)
+      save
+    end
+
+    # @return [Integer]
+    def count
+      @model.send(@context.to_s).count
+    end
+
+    # @return [Integer]
+    def size
+      if @pending_changes.any?
+        @pending_changes.size
+      else
+        @model.send(@context.to_s).size
+      end
+    end
+
+    # @return [Array<String>]
+    def to_a
+      current_list
+    end
+
+    # @return [String]
+    def to_s
+      transformer.recreate_string(current_list)
+    end
+
+    # @return [String] The name of the parser used to transform tags
+    def transformer_name
+      @transformer_name ||= transformer.name
+    end
+
+    # @return [String]
+    def inspect
+      "#<#{self.class.name} tags=#{current_list.inspect} transformer_with=#{transformer_name} >"
+    end
+
+    def add(tag)
+      return self if limit_reached?
+
+      new_tags = transformer.parse_tags(tag)
+      return self if new_tags.empty?
+
+      @pending_changes = current_list + new_tags
+      @pending_changes.uniq!
+      self
+    end
+
+    def add!(tag)
+      add(tag)
+      save
+    end
+
+    def remove(tag)
+      @pending_changes = current_list - [tag.to_s.strip]
+      self
+    end
+
+    def remove!(tag)
+      remove(tag)
+      save
+    end
+
+    def clear
+      @pending_changes = []
+      self
+    end
+
+    def clear!
+      @model.send(@context.to_s).destroy_all
+      @pending_changes = []
+      self
+    end
+
+    def include?(tag)
+      current_list.include?(tag.to_s.strip)
+    end
+
+    def empty?
+      current_list.empty?
+    end
+
+    def persisted?
+      false
+    end
+
+    private
+
+    def set_list(_context, value)
+      @pending_changes = transformer.parse_tags(value)
+      valid? # Just check validity without raising
+      self
+    end
+
+    def get_list(_context)
+      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
+
+    def validate_limit
+      return unless @limit
+      return if @pending_changes.size <= @limit
+
+      errors.add(:base, "Cannot have more than #{@limit} tags (attempting to save #{@pending_changes.size})")
+    end
+
+    def validate_existing_tags
+      return unless @restrict_to_existing
+      return if @pending_changes.empty?
+
+      existing_tags = @tag_model.where(name: @pending_changes).pluck(:name)
+      missing_tags = @pending_changes - existing_tags
+
+      return unless missing_tags.any?
+
+      errors.add(:base, "The following tags do not exist: #{missing_tags.join(', ')}")
+    end
+
+    def find_or_create_tag(tag_name)
+      if @restrict_to_existing
+        @tag_model.find_by(name: tag_name)
+      else
+        @tag_model.find_or_create_by(name: tag_name)
+      end
+    end
+
+    def limit_reached?
+      @limit && current_list.size >= @limit
+    end
+  end
+end

data/lib/no_fly_list/tagging_record.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  # This module provides functionality for a tag table that contains global tags for a model.
+  #
+  # This concern can be included in models that represent tags to manage global tags across different records.
+  #
+  # @example Usage
+  #   class User::Tag < ApplicationRecord
+  #     include NoFlyList::TaggingModel
+  #   end
+  module TaggingRecord
+    extend ActiveSupport::Concern
+
+    delegate :tag_name, to: :tag
+
+    def inspect
+      "#<#{self.class.name} id: #{id}, tag_name: #{tag_name} >"
+    end
+  end
+end

data/lib/no_fly_list/test_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  # = NoFlyList Test Helper
+  #
+  # Include <tt>NoFlyList::TestHelper</tt> in your test case to get access to the assertion methods.
+  module TestHelper
+    def assert_taggable_record(klass, *contexts)
+      assert klass.respond_to?(:has_tags), "#{klass} does not respond to has_tags"
+      contexts.each do |context|
+        assert klass.new.respond_to?(:"#{context}_list"), "#{klass} does not respond to #{context}_list"
+      end
+    end
+  end
+end

data/lib/no_fly_list/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NoFlyList
+  VERSION = '0.1.0'
+end

data/lib/no_fly_list.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'active_support'
+require 'active_support/rails'
+require 'active_support/core_ext/numeric/time'
+require_relative 'no_fly_list/version'
+require 'no_fly_list/railtie' if defined?(Rails)
+require 'ostruct'
+
+module NoFlyList
+  extend ActiveSupport::Autoload
+  # Global tagging tables
+  autoload :ApplicationTag
+  autoload :ApplicationTagging
+
+  # Common tagging tables
+  autoload :TaggableRecord
+  autoload_under 'taggable_record' do
+    autoload :Configuration
+  end
+  autoload :TaggingRecord
+  autoload :TagRecord
+
+  autoload :TaggingProxy
+
+  autoload :TestHelper
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: no_fly_list
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Abdelkader Boudih
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-12-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Tagging system for ActiveRecord models inspired by the TSA
+email:
+- terminale@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/no_fly_list/install_generator.rb
+- lib/generators/no_fly_list/models_generator.rb
+- lib/generators/no_fly_list/tagging_generator.rb
+- lib/generators/no_fly_list/templates/application_tag.rb.erb
+- lib/generators/no_fly_list/templates/application_tagging.rb.erb
+- lib/generators/no_fly_list/templates/create_application_tagging_table.rb.erb
+- lib/generators/no_fly_list/templates/create_tagging_table.rb.erb
+- lib/generators/no_fly_list/templates/tag_model.rb.erb
+- lib/generators/no_fly_list/templates/tag_parser.rb
+- lib/generators/no_fly_list/templates/tagging_model.rb.erb
+- lib/generators/no_fly_list/transformer_generator.rb
+- lib/no_fly_list.rb
+- lib/no_fly_list/application_tag.rb
+- lib/no_fly_list/application_tagging.rb
+- lib/no_fly_list/railtie.rb
+- lib/no_fly_list/railties/tasks.rake
+- lib/no_fly_list/tag_record.rb
+- lib/no_fly_list/taggable_record.rb
+- lib/no_fly_list/taggable_record/configuration.rb
+- lib/no_fly_list/taggable_record/mutation.rb
+- lib/no_fly_list/taggable_record/query.rb
+- lib/no_fly_list/tagging_proxy.rb
+- lib/no_fly_list/tagging_record.rb
+- lib/no_fly_list/test_helper.rb
+- lib/no_fly_list/version.rb
+homepage: https://github.com/contriboss/no_fly_list
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Tagging system for ActiveRecord models
+test_files: []