activeadmin-command_palette 0.1.6

data/lib/activeadmin/command_palette/engine.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    class Engine < ::Rails::Engine
+      engine_name "activeadmin_command_palette"
+
+      initializer "activeadmin_command_palette.load_lib" do
+        require "activeadmin/command_palette"
+        ActiveAdmin::CommandPalette::Integration.install!
+      end
+
+      # Compile after ActiveAdmin loads admin files. A plain to_prepare can run after
+      # ActiveAdmin.unload! and before load!, which would leave an empty catalog.
+      initializer "activeadmin_command_palette.reload", after: :load_config_initializers do
+        ActiveAdmin.after_load do
+          ActiveAdmin::CommandPalette.reload!
+        end
+
+        if ActiveAdmin.application.loaded?
+          ActiveAdmin::CommandPalette.reload!
+        end
+      end
+
+      initializer "activeadmin_command_palette.assets" do |app|
+        assets_path = root.join("app/assets")
+        if app.config.respond_to?(:importmap)
+          app.config.importmap.cache_sweepers << assets_path.join("controllers")
+        end
+      end
+
+      initializer "activeadmin_command_palette.importmap", after: "active_admin.importmap" do
+        next unless defined?(ActiveAdmin) && ActiveAdmin.respond_to?(:importmap) && ActiveAdmin.importmap
+
+        ActiveAdmin.importmap.draw do
+          pin "controllers/activeadmin_command_palette/command_palette_controller",
+            to: "activeadmin_command_palette/command_palette_controller.js"
+        end
+      end
+
+      initializer "activeadmin_command_palette.i18n" do
+        I18n.load_path += Dir[root.join("config/locales/*.yml")]
+      end
+
+      initializer "activeadmin_command_palette.filter_parameters" do |app|
+        app.config.filter_parameters |= [:q]
+      end
+
+      initializer "activeadmin_command_palette.helpers", after: :load_config_initializers do
+        ActiveSupport.on_load(:action_controller) do
+          helper ActiveAdmin::CommandPalette::Helper if respond_to?(:helper)
+        end
+
+        if defined?(ActiveAdmin::BaseController)
+          ActiveAdmin::BaseController.helper ActiveAdmin::CommandPalette::Helper
+        end
+      end
+
+      initializer "activeadmin_command_palette.view_paths", after: :add_view_paths do
+        views_path = root.join("app/views").to_s
+        ActiveSupport.on_load(:action_controller) do
+          prepend_view_path(views_path)
+        end
+      end
+    end
+  end
+end

data/lib/activeadmin/command_palette/finder.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    class Finder
+      class << self
+        def options(kind:, query:, helpers:, user:)
+          config = ActiveAdmin::CommandPalette.configuration
+          term = query.to_s.strip
+          return [] if term.length < config.min_query_length
+
+          options_for_kind(
+            kind: kind,
+            query: term,
+            helpers: helpers,
+            user: user,
+            limit: config.limit
+          )
+        end
+
+        def options_for(kinds:, query:, helpers:, user:)
+          config = ActiveAdmin::CommandPalette.configuration
+          term = query.to_s.strip
+          return [] if term.length < config.min_query_length
+
+          collect_options(kinds: kinds, query: term, helpers: helpers, user: user, config: config)
+        end
+
+        def kinds
+          ActiveAdmin::CommandPalette.configuration.finder_kinds
+        end
+
+        private
+
+        def collect_options(kinds:, query:, helpers:, user:, config:)
+          remaining = [config.limit.to_i, 0].max
+          requested_kinds = bounded_kinds(kinds, config.search_kind_limit)
+
+          requested_kinds.each_with_object([]) do |kind, results|
+            break results if remaining.zero?
+
+            items = options_for_kind(
+              kind: kind,
+              query: query,
+              helpers: helpers,
+              user: user,
+              limit: remaining
+            )
+            results.concat(items)
+            remaining -= items.length
+          end
+        end
+
+        def bounded_kinds(kinds, limit)
+          Array(kinds).first([limit.to_i, 0].max).map(&:to_s).uniq
+        end
+
+        def options_for_kind(kind:, query:, helpers:, user:, limit:)
+          kind = kind.to_s
+          finder = ActiveAdmin::CommandPalette.configuration.finders[kind]
+          return [] unless finder
+
+          results = finder.call(query: query, helpers: helpers, user: user, limit: limit)
+          normalize_results(results, kind: kind, limit: limit)
+        end
+
+        def normalize_results(results, kind:, limit:)
+          results.take(limit).map { |item| normalize(item, kind) }
+        end
+
+        def normalize(item, default_kind)
+          hash = item.respond_to?(:to_h) ? item.to_h : item
+          hash = hash.transform_keys(&:to_sym)
+          normalized = normalized_fields(hash, default_kind)
+          add_optional_fields(normalized, hash)
+        end
+
+        def normalized_fields(hash, default_kind)
+          {
+            id: hash[:id],
+            kind: (hash[:kind] || default_kind).to_s,
+            label: hash[:label].to_s,
+            url: hash[:url].to_s,
+            method: (hash[:method] || "get").to_s
+          }
+        end
+
+        def add_optional_fields(normalized, hash)
+          detail = hash[:detail].presence || hash[:subtitle].presence
+          keywords = normalized_keywords(hash[:keywords])
+
+          normalized[:detail] = detail.to_s if detail.present?
+          normalized[:keywords] = keywords if keywords.any?
+          normalized
+        end
+
+        def normalized_keywords(value)
+          Array(value).map { |keyword| keyword.to_s.presence }.compact
+        end
+      end
+    end
+  end
+end

data/lib/activeadmin/command_palette/helper.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    module Helper
+      CONTROLLER_NAME = "activeadmin-command-palette--command-palette"
+
+      def command_palette_controller_name
+        CONTROLLER_NAME
+      end
+
+      def command_palette_navigate_items
+        Catalog.navigate(self)
+      end
+
+      def command_palette_action_items
+        Catalog.actions(self, context: command_palette_context)
+      end
+
+      def command_palette_options_url
+        active_admin_command_palette.options_path
+      end
+
+      def command_palette_context
+        config = active_admin_config_for_palette
+        action = controller_action_for_palette
+        namespace_name = config&.namespace&.name&.to_s.presence || "admin"
+
+        return other_context(namespace_name, action) if config.blank?
+        return page_context(namespace_name, action) if config.is_a?(ActiveAdmin::Page)
+
+        resource_name = config.resource_class.name.demodulize
+        resource_param = "id"
+        record_param = params[resource_param].presence || params[:id].presence
+        if record_param.blank? && %w[show edit update destroy].include?(action)
+          record_param = resource_param_for_palette
+        end
+
+        {
+          namespace: namespace_name,
+          resource: resource_name,
+          resource_param: resource_param,
+          record_param: record_param,
+          action: action,
+          page: "resource"
+        }
+      end
+
+      def command_palette_data_attributes
+        prefix = CONTROLLER_NAME
+        {
+          "data-#{prefix}-navigate-value" => command_palette_navigate_items.to_json,
+          "data-#{prefix}-actions-value" => command_palette_action_items.to_json,
+          "data-#{prefix}-context-value" => command_palette_context.to_json,
+          "data-#{prefix}-options-url-value" => command_palette_options_url,
+          "data-#{prefix}-csrf-value" => form_authenticity_token,
+          "data-#{prefix}-prefixes-value" => ActiveAdmin::CommandPalette.configuration.prefixes.to_json,
+          "data-#{prefix}-kinds-value" => ActiveAdmin::CommandPalette.configuration.finder_kinds.to_json,
+          "data-#{prefix}-min-query-length-value" => ActiveAdmin::CommandPalette.configuration.min_query_length,
+          "data-#{prefix}-empty-value" => I18n.t("active_admin.command_palette.empty"),
+          "data-#{prefix}-loading-value" => I18n.t("active_admin.command_palette.loading"),
+          "data-#{prefix}-error-value" => I18n.t("active_admin.command_palette.error"),
+          "data-#{prefix}-unauthorized-value" => I18n.t("active_admin.command_palette.unauthorized"),
+          "data-#{prefix}-forbidden-value" => I18n.t("active_admin.command_palette.forbidden"),
+          "data-#{prefix}-required-value" => I18n.t("active_admin.command_palette.required"),
+          "data-#{prefix}-optional-value" => I18n.t("active_admin.command_palette.optional"),
+          "data-#{prefix}-sign-in-path-value" => command_palette_sign_in_path,
+          "data-#{prefix}-help-items-value" => command_palette_help_items.to_json
+        }
+      end
+
+      def command_palette_sign_in_path
+        if respond_to?(:new_user_session_path)
+          new_user_session_path
+        else
+          "/user/sign_in"
+        end
+      end
+
+      def command_palette_help_items
+        [
+          {id: "help-go", kind: "help", label: I18n.t("active_admin.command_palette.help.go"), url: nil},
+          {id: "help-actions", kind: "help", label: I18n.t("active_admin.command_palette.help.actions"), url: nil},
+          {id: "help-resource", kind: "help", label: I18n.t("active_admin.command_palette.help.resource"), url: nil},
+          {id: "help-modes", kind: "help", label: I18n.t("active_admin.command_palette.help.modes"), url: nil}
+        ]
+      end
+
+      def render_command_palette
+        render partial: "active_admin/command_palette/palette"
+      end
+
+      private
+
+      def active_admin_config_for_palette
+        return active_admin_config if respond_to?(:active_admin_config)
+
+        nil
+      end
+
+      def controller_action_for_palette
+        return controller.action_name.to_s if respond_to?(:controller) && controller.respond_to?(:action_name)
+
+        "other"
+      end
+
+      def resource_param_for_palette
+        return resource.to_param if respond_to?(:resource) && resource.respond_to?(:to_param)
+
+        nil
+      end
+
+      def other_context(namespace_name, action)
+        {
+          namespace: namespace_name,
+          resource: nil,
+          resource_param: nil,
+          record_param: nil,
+          action: action,
+          page: "other"
+        }
+      end
+
+      def page_context(namespace_name, action)
+        {
+          namespace: namespace_name,
+          resource: nil,
+          resource_param: nil,
+          record_param: nil,
+          action: action,
+          page: "page"
+        }
+      end
+    end
+  end
+end

data/lib/activeadmin/command_palette/integration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    module Integration
+      class << self
+        def install!
+          return if @installed
+
+          ActiveAdmin::Resource.include(ResourceMethods)
+          ActiveAdmin::ResourceDSL.prepend(DSL)
+          @installed = true
+        end
+      end
+    end
+  end
+end

data/lib/activeadmin/command_palette/resource_config.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    class ResourceConfig
+      attr_accessor :kind, :noun, :label_method, :order_column
+      attr_reader :find_columns, :standard_actions, :create_help, :create_params, :members
+
+      def initialize
+        @kind = nil
+        @noun = nil
+        @label_method = nil
+        @order_column = nil
+        @find_columns = []
+        @standard_actions = []
+        @create_help = nil
+        @create_params = []
+        @members = []
+        @enabled = false
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def enable!
+        @enabled = true
+      end
+
+      def find_by(*columns)
+        enable!
+        @find_columns = columns.flatten.map(&:to_s)
+      end
+
+      def actions(*names)
+        enable!
+        @standard_actions = names.flatten.map(&:to_sym)
+      end
+
+      def create(help: nil, params: [])
+        enable!
+        @create_help = help
+        @create_params = Array(params).map { |param| param.transform_keys(&:to_sym) }
+      end
+
+      def member(label, **options)
+        enable!
+        @members << options.transform_keys(&:to_sym).merge(label: label.to_s)
+      end
+    end
+  end
+end

data/lib/activeadmin/command_palette/resource_dsl.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    class ResourceDSL
+      def initialize(config)
+        @config = config
+      end
+
+      def kind(value)
+        @config.enable!
+        @config.kind = value.to_s
+      end
+
+      def noun(value)
+        @config.enable!
+        @config.noun = value.to_s
+      end
+
+      def label_method(value)
+        @config.enable!
+        @config.label_method = value.to_sym
+      end
+
+      def order(value)
+        @config.enable!
+        @config.order_column = value.to_sym
+      end
+
+      def find_by(*columns)
+        @config.find_by(*columns)
+      end
+
+      def actions(*names)
+        @config.actions(*names)
+      end
+
+      def create(help: nil, params: [])
+        @config.create(help: help, params: params)
+      end
+
+      def member(label, **options)
+        @config.member(label, **options)
+      end
+    end
+  end
+end

data/lib/activeadmin/command_palette/resource_methods.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    module ResourceMethods
+      def command_palette_config
+        @command_palette_config ||= ResourceConfig.new
+      end
+    end
+  end
+end

data/lib/activeadmin/command_palette/url_helpers.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    # Path helpers for finder callbacks. Uses the host application routes so
+    # engine mounting cannot hide ActiveAdmin member paths.
+    class UrlHelpers
+      def method_missing(method_name, ...)
+        helpers = Rails.application.routes.url_helpers
+        if helpers.respond_to?(method_name)
+          helpers.public_send(method_name, ...)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        Rails.application.routes.url_helpers.respond_to?(method_name) || super
+      end
+    end
+  end
+end

data/lib/activeadmin/command_palette/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    VERSION = "0.1.6"
+  end
+end

data/lib/activeadmin/command_palette.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "activeadmin/command_palette/version"
+require "activeadmin/command_palette/configuration"
+require "activeadmin/command_palette/resource_config"
+require "activeadmin/command_palette/resource_dsl"
+require "activeadmin/command_palette/resource_methods"
+require "activeadmin/command_palette/dsl"
+require "activeadmin/command_palette/compiler"
+require "activeadmin/command_palette/catalog"
+require "activeadmin/command_palette/finder"
+require "activeadmin/command_palette/helper"
+require "activeadmin/command_palette/url_helpers"
+require "activeadmin/command_palette/integration"
+
+module ActiveAdmin
+  module CommandPalette
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield configuration
+      end
+
+      def reset_configuration!
+        @configuration = Configuration.new
+      end
+
+      def reload!
+        configuration.reload!
+      end
+    end
+  end
+end
+
+require "activeadmin/command_palette/engine"

data/sig/activeadmin/command_palette.rbs

@@ -0,0 +1,5 @@
+module ActiveAdmin
+  module CommandPalette
+    VERSION: String
+  end
+end