pin_flags 0.1.0

data/app/assets/stylesheets/pin_flags/forms.css

@@ -0,0 +1,8 @@
+/* Hide the HTML datalist wonky arrow in Safari and Chrome, since we add it via bulma. */
+[list]::-webkit-calendar-picker-indicator {
+  opacity: 0;
+}
+
+a[disabled] {
+  pointer-events: none;
+}

data/app/controllers/pin_flags/application_controller.rb

@@ -0,0 +1,6 @@
+module PinFlags
+  class ApplicationController < ActionController::Base
+    layout "pin_flags/application"
+    protect_from_forgery with: :exception
+  end
+end

data/app/controllers/pin_flags/feature_tags/exports_controller.rb

@@ -0,0 +1,18 @@
+module PinFlags
+  module FeatureTags
+    class ExportsController < ApplicationController
+      def index
+        respond_to do |format|
+          format.json { send_data(PinFlags::FeatureTag.export_as_json, filename: export_filename) }
+        end
+      end
+
+      private
+
+      def export_filename
+        timestamp = Time.zone.now.strftime("%Y%m%d%H%M%S")
+        "pin_flags_feature_tags_#{timestamp}.json"
+      end
+    end
+  end
+end

data/app/controllers/pin_flags/feature_tags/feature_subscriptions_controller.rb

@@ -0,0 +1,138 @@
+module PinFlags
+  module FeatureTags
+    class FeatureSubscriptionsController < ApplicationController
+      rescue_from ActiveRecord::RecordNotFound, with: :record_not_found
+
+      before_action :set_feature_tag
+      before_action :set_current_page, only: %i[create destroy]
+      before_action :set_filter_param, only: %i[create destroy]
+      before_action :set_feature_taggable_type, only: %i[create destroy]
+      before_action :set_feature_subscription, only: %i[destroy]
+
+      def new
+        @feature_subscription = @feature_tag.feature_subscriptions.new
+      end
+
+      def create
+        if feature_subscription_params[:bulk_upload] == "1"
+          create_feature_subscriptions_in_bulk
+        else
+          create_single_feature_subscription
+        end
+      end
+
+      def destroy
+        @feature_subscription.destroy
+
+        respond_to do |format|
+          format.html { redirect_to @feature_tag, notice: "Feature Subscription was successfully destroyed." }
+          format.turbo_stream
+        end
+      end
+
+      private
+
+      def set_feature_tag
+        @feature_tag = PinFlags::FeatureTag.find_by(id: params[:feature_tag_id])
+        raise ActiveRecord::RecordNotFound if @feature_tag.blank?
+      end
+
+      def set_current_page
+        @current_page = params.fetch(:page, 1).to_i
+      end
+
+      def set_filter_param
+        @filter_param = params.fetch(:filter, nil)
+      end
+
+      def set_feature_taggable_type
+        @feature_taggable_type = params.fetch(:feature_taggable_type, nil)
+      end
+
+      def feature_subscription_params
+        params.expect(feature_subscription: [ :feature_taggable_type, :feature_taggable_id, :bulk_upload ])
+      end
+
+      def set_feature_subscription
+        @feature_subscription = @feature_tag.feature_subscriptions.find_by(id: params[:id])
+        raise ActiveRecord::RecordNotFound if @feature_subscription.blank?
+      end
+
+      def record_not_found
+        alert_message = @feature_tag.blank? ? "Feature Tag not found." : "Feature Subscription not found."
+        redirect_to pin_flags.feature_tags_path, alert: alert_message
+      end
+
+      def create_single_feature_subscription
+        @feature_subscription = @feature_tag.feature_subscriptions.new(feature_subscription_params.except(:bulk_upload))
+
+        if @feature_subscription.save
+          set_paginated_feature_subscriptions
+
+          respond_to do |format|
+            format.html { redirect_to pin_flags.feature_tag_path(@feature_tag, filter: @filter_param, feature_taggable_type: @feature_taggable_type), notice: "Feature Subscription was successfully created." }
+            format.turbo_stream
+          end
+        else
+          render :new, status: :unprocessable_content
+        end
+      end
+
+      def create_feature_subscriptions_in_bulk
+        feature_taggable_ids = feature_subscription_params[:feature_taggable_id].split(",")
+
+        if PinFlags::FeatureSubscription.create_in_bulk(
+          feature_tag: @feature_tag,
+          feature_taggable_type: feature_subscription_params[:feature_taggable_type],
+          feature_taggable_ids: feature_taggable_ids
+        )
+          handle_feature_subscriptions_in_bulk_success
+        else
+          handle_feature_subscriptions_in_bulk_failure
+        end
+      end
+
+      def handle_feature_subscriptions_in_bulk_success
+        set_paginated_feature_subscriptions
+
+        respond_to do |format|
+          format.html do
+            redirect_to pin_flags.feature_tag_path(@feature_tag, filter: @filter_param, feature_taggable_type: @feature_taggable_type), notice: "Feature Subscriptions were successfully created."
+          end
+          format.turbo_stream
+        end
+      end
+
+      def handle_feature_subscriptions_in_bulk_failure
+        alert_message = "One or more Feature Taggable IDs are invalid."
+        flash.now[:alert] = alert_message
+        @feature_subscription = @feature_tag.feature_subscriptions.new(
+          feature_taggable_type: feature_subscription_params[:feature_taggable_type],
+          feature_taggable_id: feature_subscription_params[:feature_taggable_id]
+        )
+        @feature_subscription.errors.add(:feature_taggable_id, alert_message)
+        render :new, status: :unprocessable_content
+      end
+
+      def fetch_filtered_feature_subscriptions
+        feature_subscriptions = @feature_tag.feature_subscriptions.order(created_at: :desc)
+
+        if @feature_taggable_type.present?
+          feature_subscriptions = feature_subscriptions.where(feature_taggable_type: @feature_taggable_type)
+        end
+
+        if @filter_param.present?
+          feature_subscriptions = feature_subscriptions.where(feature_taggable_id: @filter_param.strip)
+        end
+
+        feature_subscriptions
+      end
+
+      def set_paginated_feature_subscriptions
+        filtered_subscriptions = fetch_filtered_feature_subscriptions
+        @paginator = PinFlags::Page.new(filtered_subscriptions, page: @current_page, page_size: PinFlags::FeatureTagsController::PER_PAGE)
+        @feature_subscriptions = @paginator.records
+      end
+    end
+  end
+end

data/app/controllers/pin_flags/feature_tags/imports_controller.rb

@@ -0,0 +1,65 @@
+module PinFlags
+  module FeatureTags
+    class ImportsController < ApplicationController
+      MAX_FILE_SIZE ||= 2.megabytes
+
+      def create
+        if valid_json_file? && import_successful?
+          respond_with_success
+        else
+          respond_with_error
+        end
+      end
+
+      private
+
+      def import_params
+        params.permit(:json_file, :authenticity_token, :commit)
+      end
+
+      def valid_json_file?
+        return false if import_params[:json_file].blank?
+
+        file = import_params[:json_file]
+        correct_type = file.content_type == "application/json"
+        correct_size = file.size <= MAX_FILE_SIZE
+
+        correct_type && correct_size
+      end
+
+      def import_successful?
+        file_contents = import_params[:json_file].read
+        PinFlags::FeatureTag.import_from_json(file_contents)
+      rescue PinFlags::FeatureTagImportError => e
+        Rails.logger.error(e.message)
+        false
+      end
+
+      def respond_with_success
+        respond_to do |format|
+          format.html { redirect_to feature_tags_path, notice: "Feature tags were successfully imported." }
+        end
+      end
+
+      def error_message
+        if import_params[:json_file].blank?
+          "No file uploaded."
+        elsif import_params[:json_file].content_type != "application/json"
+          "File must be JSON format."
+        elsif import_params[:json_file].size > MAX_FILE_SIZE
+          "File size must be less than #{MAX_FILE_SIZE / 1.megabyte}MB."
+        else
+          "Invalid JSON file or import failed."
+        end
+      end
+
+      def respond_with_error
+        message = error_message
+
+        respond_to do |format|
+          format.html { redirect_to feature_tags_path, alert: message }
+        end
+      end
+    end
+  end
+end

data/app/controllers/pin_flags/feature_tags_controller.rb

@@ -0,0 +1,141 @@
+module PinFlags
+  class FeatureTagsController < ApplicationController
+    rescue_from ActiveRecord::RecordNotFound, with: :handle_record_not_found
+
+    before_action :set_filter_param, only: %i[index show]
+    before_action :set_enabled_param, only: %i[index show]
+    before_action :set_subscriptions_param, only: %i[index]
+    before_action :set_current_page, only: %i[index show create]
+    before_action :set_feature_taggable_type, only: %i[show]
+    before_action :set_feature_tag, only: %i[show update destroy]
+
+    PER_PAGE ||= 10
+
+    def index
+      @paginator = PinFlags::Page.new(fetch_feature_tags, page: @current_page, page_size: PER_PAGE)
+      @feature_tags = @paginator.records
+
+      # Handle overflow (when page number is too high)
+      if @paginator.index > @paginator.pages_count && @paginator.pages_count&.positive?
+        redirect_to feature_tags_path(search: @filter_param, enabled: @enabled_param, subscriptions: @subscriptions_param)
+      end
+    end
+
+    def show
+      @paginator = PinFlags::Page.new(fetch_feature_subscriptions, page: @current_page, page_size: PER_PAGE)
+      @feature_subscriptions = @paginator.records
+
+      # Handle overflow for feature subscriptions
+      if @paginator.index > @paginator.pages_count && @paginator.pages_count&.positive?
+        redirect_to feature_tag_path(@feature_tag, feature_taggable_type: @feature_taggable_type, filter: @filter_param)
+      end
+    end
+
+    def new
+      @feature_tag = PinFlags::FeatureTag.new
+    end
+
+    def create
+      @feature_tag = PinFlags::FeatureTag.new(feature_tag_params)
+
+      if @feature_tag.save
+        @feature_tags = fetch_feature_tags
+        @paginator = PinFlags::Page.new(@feature_tags, page: @current_page, page_size: PER_PAGE)
+        @feature_tags = @paginator.records
+        handle_success(:create)
+      else
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    def update
+      if @feature_tag.update(feature_tag_params)
+        handle_success(:update)
+      else
+        render :index, status: :unprocessable_content
+      end
+    end
+
+    def destroy
+      @feature_tag.destroy
+      handle_success(:delete)
+    end
+
+    private
+
+    def set_current_page
+      @current_page = params.fetch(:page, 1).to_i
+    end
+
+    def set_feature_tag
+      @feature_tag = PinFlags::FeatureTag.find(params[:id])
+    end
+
+    def feature_tag_params
+      params.expect(feature_tag: [ :name, :enabled ])
+    end
+
+    def set_filter_param
+      @filter_param = params.fetch(:filter, nil)
+    end
+
+    def set_enabled_param
+      @enabled_param = params.fetch(:enabled, nil)
+    end
+
+    def set_subscriptions_param
+      @subscriptions_param = params.fetch(:subscriptions, nil)
+    end
+
+    def set_feature_taggable_type
+      @feature_taggable_type = params.fetch(:feature_taggable_type, nil)
+    end
+
+    def fetch_feature_tags
+      scope = FeatureTag.all.includes(:feature_subscriptions).order(created_at: :desc)
+      scope = scope.with_name_like(@filter_param) if @filter_param.present?
+      scope = filter_by_enabled_status(scope) if @enabled_param.present?
+      scope = filter_by_subscriptions_status(scope) if @subscriptions_param.present?
+      scope
+    end
+
+    def fetch_feature_subscriptions
+      feature_subscriptions = @feature_tag.feature_subscriptions.order(created_at: :desc)
+
+      if @feature_taggable_type.present?
+        feature_subscriptions = feature_subscriptions.where(feature_taggable_type: @feature_taggable_type)
+      end
+
+      if @filter_param.present?
+        feature_subscriptions = feature_subscriptions.where(feature_taggable_id: @filter_param.strip)
+      end
+
+      feature_subscriptions
+    end
+
+
+    def filter_by_enabled_status(scope)
+      enabled = ActiveModel::Type::Boolean.new.cast(@enabled_param)
+      enabled ? scope.enabled : scope.disabled
+    end
+
+    def filter_by_subscriptions_status(scope)
+      has_subscriptions = ActiveModel::Type::Boolean.new.cast(@subscriptions_param)
+      has_subscriptions ? scope.joins(:feature_subscriptions).distinct : scope.left_joins(:feature_subscriptions).where(feature_subscriptions: { id: nil })
+    end
+
+    def handle_success(action)
+      flash_notice = "Feature tag was successfully #{action}d."
+
+      respond_to do |format|
+        format.html { redirect_to feature_tags_path, notice: flash_notice }
+        format.turbo_stream { flash.now[:notice] = flash_notice }
+      end
+    end
+
+    def handle_record_not_found
+      flash[:error] = "Feature tag not found."
+      redirect_to pin_flags.feature_tags_path, status: :see_other
+    end
+  end
+end

data/app/helpers/pin_flags/application_helper.rb

@@ -0,0 +1,20 @@
+module PinFlags
+  module ApplicationHelper
+    def flash_class(type)
+      case type.to_s
+      when "notice", "success"
+        "is-success"
+      when "alert", "error"
+        "is-danger"
+      when "warning"
+        "is-warning"
+      else
+        "is-info"
+      end
+    end
+
+    def page_title
+      content_for?(:title) ? content_for(:title) : "Dashboard"
+    end
+  end
+end

data/app/helpers/pin_flags/feature_tags/feature_subscriptions_helper.rb

@@ -0,0 +1,23 @@
+module PinFlags
+  module FeatureTags
+    module FeatureSubscriptionsHelper
+      def display_feature_subscription_table_turbo_frame_row_id(feature_subscription)
+        "feature_subscriptions_table_row_#{dom_id(feature_subscription)}"
+      end
+
+      def display_feature_subscription_row_delete_confirmation(feature_subscription)
+        taggable_type = strip_tags(feature_subscription.feature_taggable_type)
+        taggable_id = feature_subscription.feature_taggable_id
+
+        "Are you sure you want to delete the feature subscription for '#{taggable_type}' with ID '#{taggable_id}'?"
+      end
+
+      def display_feature_subscription_delete_button_aria_label(feature_subscription)
+        feature_taggable_type = strip_tags(feature_subscription.feature_taggable_type)
+        feature_taggable_id = feature_subscription.feature_taggable_id
+
+        "Delete Feature Subscription for #{feature_taggable_type} with ID #{feature_taggable_id}"
+      end
+    end
+  end
+end

data/app/helpers/pin_flags/feature_tags/imports_helper.rb

@@ -0,0 +1,7 @@
+module PinFlags
+  module FeatureTags
+    module ImportsHelper
+      def display_import_form_modal_id = "pin-flags-import-form-modal"
+    end
+  end
+end

data/app/helpers/pin_flags/feature_tags_helper.rb

@@ -0,0 +1,12 @@
+module PinFlags
+  module FeatureTagsHelper
+    def display_feature_tag_table_turbo_frame_row_id(feature_tag)
+      "feature_tags_table_row_#{dom_id(feature_tag)}"
+    end
+
+    def display_feature_tag_row_delete_confirmation(feature_tag)
+      sanitized_name = strip_tags(feature_tag.name)
+      "Are you sure you want to delete the feature tag '#{sanitized_name}'?"
+    end
+  end
+end

data/app/jobs/pin_flags/application_job.rb

@@ -0,0 +1,4 @@
+module PinFlags
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/pin_flags/application_mailer.rb

@@ -0,0 +1,6 @@
+module PinFlags
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/concerns/pin_flags/feature_taggable.rb

@@ -0,0 +1,39 @@
+module PinFlags
+  module FeatureTaggable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many  :feature_subscriptions,
+                class_name: "PinFlags::FeatureSubscription",
+                as: :feature_taggable,
+                dependent: :destroy
+
+      has_many  :feature_tags,
+                class_name: "PinFlags::FeatureTag",
+                through: :feature_subscriptions
+    end
+
+    def feature_tag_pin(tag_name)
+      feature_tags << PinFlags::FeatureTag.find_or_create_by(name: tag_name)
+    rescue ActiveRecord::RecordNotUnique
+      feature_tags
+    end
+
+    def feature_tag_unpin(tag_name)
+      existing_tag = feature_tags.find_by(name: tag_name)
+      feature_tags.delete(existing_tag) if existing_tag
+    end
+
+    def feature_tag?(tag_name)
+      feature_tags.exists?(name: tag_name)
+    end
+
+    def feature_tag_enabled?(tag_name)
+      feature_tags.enabled.exists?(name: tag_name)
+    end
+
+    def feature_tag_disabled?(tag_name)
+      feature_tags.disabled.exists?(name: tag_name)
+    end
+  end
+end

data/app/models/pin_flags/application_record.rb

@@ -0,0 +1,5 @@
+module PinFlags
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/pin_flags/feature_subscription/bulk_processor.rb

@@ -0,0 +1,80 @@
+class PinFlags::FeatureSubscription::BulkProcessor
+  include ActiveModel::Model
+  include ActiveModel::Attributes
+  include ActiveModel::Validations
+
+  attribute :feature_tag
+  attribute :feature_taggable_type, :string
+
+  attr_accessor :feature_taggable_ids
+
+  validates :feature_tag, presence: true
+  validates :feature_taggable_type, presence: true
+  validates :feature_taggable_ids, presence: true
+  validate :validate_feature_taggable_type_is_valid_class
+  validate :validate_feature_taggable_ids_exist
+
+  def initialize(attributes = {})
+    super
+    @feature_taggable_ids = Array(attributes[:feature_taggable_ids]) if attributes[:feature_taggable_ids]
+  end
+
+  def process
+    return false unless valid?
+
+    # Prepare records for upsert_all
+    records = sanitized_feature_taggable_ids.map do |feature_taggable_id|
+      {
+        feature_tag_id: feature_tag.id,
+        feature_taggable_type: feature_taggable_type,
+        feature_taggable_id: feature_taggable_id,
+        created_at: Time.current,
+        updated_at: Time.current
+      }
+    end
+
+    begin
+      # Use upsert_all to insert or update records in bulk
+      PinFlags::FeatureSubscription.upsert_all(
+        records,
+        unique_by: [ :feature_tag_id, :feature_taggable_type, :feature_taggable_id ]
+      )
+      true
+    rescue ActiveRecord::RecordInvalid, ActiveRecord::StatementInvalid => _e
+      false
+    end
+  end
+
+  private
+
+  def sanitized_feature_taggable_ids
+    @sanitized_feature_taggable_ids ||= Array(feature_taggable_ids).map(&:strip)
+  end
+
+  def feature_taggable_class
+    @feature_taggable_class ||= feature_taggable_type.constantize
+  rescue NameError
+    nil
+  end
+
+  def validate_feature_taggable_type_is_valid_class
+    return if feature_taggable_type.blank?
+
+    if feature_taggable_class.nil?
+      errors.add(:feature_taggable_type, "is not a valid class")
+    end
+  end
+
+  def validate_feature_taggable_ids_exist
+    return if feature_taggable_ids.blank? || feature_taggable_class.nil?
+
+    existing_ids = feature_taggable_class.where(id: sanitized_feature_taggable_ids)
+                                        .pluck(:id)
+                                        .map(&:to_s)
+    invalid_ids = sanitized_feature_taggable_ids - existing_ids
+
+    if invalid_ids.any?
+      errors.add(:feature_taggable_ids, "contain non-existent IDs: #{invalid_ids.join(', ')}")
+    end
+  end
+end

data/app/models/pin_flags/feature_subscription.rb

@@ -0,0 +1,21 @@
+module PinFlags
+  class FeatureSubscription < ApplicationRecord
+    self.table_name = "pin_flags_feature_subscriptions"
+
+    belongs_to :feature_tag
+    belongs_to :feature_taggable, polymorphic: true
+
+    validates :feature_taggable_id, uniqueness: {
+      scope: %i[feature_tag_id feature_taggable_type],
+      message: "already has this feature tag applied"
+    }
+
+    def self.create_in_bulk(feature_tag:, feature_taggable_type:, feature_taggable_ids:)
+      BulkProcessor.new(
+        feature_tag: feature_tag,
+        feature_taggable_type: feature_taggable_type,
+        feature_taggable_ids: feature_taggable_ids
+      ).process
+    end
+  end
+end

data/app/models/pin_flags/feature_tag/cacheable.rb

@@ -0,0 +1,44 @@
+module PinFlags::FeatureTag::Cacheable
+  extend ActiveSupport::Concern
+
+  included do
+    after_commit :clear_cache
+  end
+
+  class_methods do
+    def clear_tag_cache(tag_name)
+      normalized_name = normalize_tag_name(tag_name)
+      Rails.cache.delete("#{PinFlags.cache_prefix}:enabled:#{normalized_name}")
+    end
+
+    def clear_all_cache
+      Rails.cache.delete_matched("#{PinFlags.cache_prefix}:*")
+    end
+
+    def enabled?(tag_name)
+      normalized_name = normalize_tag_name(tag_name)
+      cache_key = "#{PinFlags.cache_prefix}:enabled:#{normalized_name}"
+
+      Rails.cache.fetch(cache_key, expires_in: PinFlags.cache_expiry) do
+        enabled.exists?(name: normalized_name)
+      end
+    end
+
+    def disabled?(tag_name)
+      !enabled?(tag_name)
+    end
+
+    private
+
+    def cache_key_for(tag_name)
+      normalized_name = normalize_tag_name(tag_name)
+      "#{PinFlags.cache_prefix}:enabled:#{normalized_name}"
+    end
+  end
+
+  private
+
+  def clear_cache
+    self.class.clear_tag_cache(name)
+  end
+end