activeadmin-command_palette 0.1.6

data/app/controllers/active_admin/command_palette/options_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    class OptionsController < ::ApplicationController
+      before_action :prevent_command_palette_caching
+      before_action :authenticate_command_palette_user!
+
+      def index
+        unless authorized_for_palette?
+          head :forbidden
+          return
+        end
+
+        render json: finder_options
+      end
+
+      private
+
+      def finder_options
+        arguments = {
+          query: params[:q],
+          helpers: UrlHelpers.new,
+          user: current_palette_user
+        }
+        return Finder.options_for(kinds: params[:kinds], **arguments) if params[:kinds].present?
+
+        Finder.options(kind: params[:kind], **arguments)
+      end
+
+      def prevent_command_palette_caching
+        response.headers["Cache-Control"] = "no-store"
+      end
+
+      def authenticate_command_palette_user!
+        method_name = ActiveAdmin.application.authentication_method
+        if method_name.present?
+          send(method_name)
+        elsif current_palette_user.blank?
+          head :unauthorized
+        end
+      end
+
+      def authorized_for_palette?
+        authorizer = ActiveAdmin::CommandPalette.configuration.authorize_with
+        if authorizer
+          authorizer.call(self)
+        else
+          current_palette_user.present?
+        end
+      end
+
+      def current_palette_user
+        method_name = ActiveAdmin.application.current_user_method
+        return unless method_name.present?
+
+        send(method_name)
+      end
+    end
+  end
+end

data/app/views/active_admin/command_palette/_palette.html.erb

@@ -0,0 +1,45 @@
+<div
+  data-activeadmin-command-palette--command-palette-target="dialog"
+  class="hidden fixed inset-0 z-50 flex items-start justify-center pt-[12vh] px-4"
+  role="dialog"
+  aria-modal="true"
+  aria-label="<%= t("active_admin.command_palette.title") %>"
+  data-action="keydown->activeadmin-command-palette--command-palette#onDialogKeydown">
+  <div
+    class="absolute inset-0 bg-black/40"
+    data-action="click->activeadmin-command-palette--command-palette#close"
+    aria-hidden="true"></div>
+  <div
+    class="relative w-full max-w-xl rounded-lg border border-gray-200 bg-white shadow-2xl dark:border-gray-700 dark:bg-gray-900"
+    data-activeadmin-command-palette--command-palette-target="panel">
+    <div class="border-b border-gray-200 px-3 py-2 dark:border-gray-700">
+      <input
+        type="search"
+        autocomplete="off"
+        role="combobox"
+        aria-expanded="false"
+        aria-label="<%= t("active_admin.command_palette.query_label") %>"
+        aria-haspopup="listbox"
+        aria-controls="activeadmin-command-palette-list"
+        aria-autocomplete="list"
+        data-activeadmin-command-palette--command-palette-target="query"
+        data-action="input->activeadmin-command-palette--command-palette#onInput keydown->activeadmin-command-palette--command-palette#onKeydown"
+        placeholder="<%= t("active_admin.command_palette.placeholder") %>"
+        class="w-full border-0 bg-transparent text-base text-gray-950 dark:text-gray-100 focus:outline-none focus:ring-0" />
+    </div>
+    <ul
+      id="activeadmin-command-palette-list"
+      data-activeadmin-command-palette--command-palette-target="list"
+      class="max-h-80 overflow-auto py-1"
+      role="listbox"></ul>
+    <div
+      class="sr-only"
+      role="status"
+      aria-live="polite"
+      aria-atomic="true"
+      data-activeadmin-command-palette--command-palette-target="announcer"></div>
+    <div class="border-t border-gray-200 px-3 py-2 text-xs text-gray-500 dark:border-gray-700 dark:text-gray-400">
+      <%= t("active_admin.command_palette.footer") %>
+    </div>
+  </div>
+</div>

data/config/locales/activeadmin_command_palette.en.yml

@@ -0,0 +1,21 @@
+en:
+  active_admin:
+    command_palette:
+      title: Command palette
+      open: Open command palette
+      open_short: Search
+      query_label: Search commands
+      placeholder: "Go to…  > actions  ? help"
+      footer: "↑↓ navigate  ↵ open  esc close"
+      empty: No matches
+      loading: Searching…
+      error: Search failed. Try again.
+      unauthorized: Session expired. Sign in again to keep searching.
+      forbidden: You do not have permission to search these records.
+      required: required
+      optional: optional
+      help:
+        go: "Go / Find — type to jump pages and records"
+        actions: "> Actions — run registered commands"
+        resource: "> View / Create — search or open new; Edit / Delete on a record page"
+        modes: "? Help — show these mode tips"

data/config/locales/activeadmin_command_palette.fi.yml

@@ -0,0 +1,21 @@
+fi:
+  active_admin:
+    command_palette:
+      title: Komentovalikko
+      open: Avaa komentovalikko
+      open_short: Haku
+      query_label: Hae komentoja
+      placeholder: "Siirry…  > toiminnot  ? ohje"
+      footer: "↑↓ siirry  ↵ avaa  esc sulje"
+      empty: Ei osumia
+      loading: Haetaan…
+      error: Haku epäonnistui. Yritä uudelleen.
+      unauthorized: Istunto päättyi. Kirjaudu uudelleen jatkaaksesi hakua.
+      forbidden: Sinulla ei ole oikeutta hakea näitä tietueita.
+      required: pakollinen
+      optional: valinnainen
+      help:
+        go: "Siirry / Haku — kirjoita sivuille ja tietueisiin"
+        actions: "> Toiminnot — suorita rekisteröityjä komentoja"
+        resource: "> Näytä / Luo — hae tai avaa uusi; Muokkaa / Poista tietuesivulla"
+        modes: "? Ohje — näytä nämä tilavihjeet"

data/config/locales/activeadmin_command_palette.sv.yml

@@ -0,0 +1,21 @@
+sv:
+  active_admin:
+    command_palette:
+      title: Kommandopalett
+      open: Öppna kommandopaletten
+      open_short: Sök
+      query_label: Sök kommandon
+      placeholder: "Gå till…  > åtgärder  ? hjälp"
+      footer: "↑↓ navigera  ↵ öppna  esc stäng"
+      empty: Inga träffar
+      loading: Söker…
+      error: Sökningen misslyckades. Försök igen.
+      unauthorized: Sessionen har gått ut. Logga in igen för att fortsätta söka.
+      forbidden: Du har inte behörighet att söka efter dessa poster.
+      required: obligatorisk
+      optional: valfri
+      help:
+        go: "Gå / Sök — skriv för att hoppa till sidor och poster"
+        actions: "> Åtgärder — kör registrerade kommandon"
+        resource: "> Visa / Skapa — sök eller öppna ny; Redigera / Ta bort på postsida"
+        modes: "? Hjälp — visa dessa tipslägen"

data/config/polyrun_coverage.yml

@@ -0,0 +1,8 @@
+track_under:
+  - lib
+  - app
+minimum_line_percent: 50
+report_formats:
+  - html
+  - cobertura
+  - console

data/config/routes.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+ActiveAdmin::CommandPalette::Engine.routes.draw do
+  scope module: "active_admin/command_palette" do
+    match "options", to: "options#index", as: :options, via: [:get, :post]
+  end
+end

data/lib/activeadmin/command_palette/catalog.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    class Catalog
+      class << self
+        def navigate(view)
+          menu = view.try(:current_menu)
+          return [] if menu.blank?
+
+          walk_menu(menu, view)
+        rescue NoMethodError, TypeError, ArgumentError
+          []
+        end
+
+        def actions(view, context: nil)
+          context = normalize_context(context || view.try(:command_palette_context))
+
+          ActiveAdmin::CommandPalette.configuration.actions.filter_map do |entry|
+            next unless matches_context?(entry, context)
+            next unless enabled?(entry, view)
+
+            verb = entry[:verb].to_s
+            url = resolve_url(view, entry, context)
+            next if url.blank? && verb != "view"
+
+            item = {
+              id: entry[:id],
+              kind: "action",
+              label: entry[:label],
+              url: url,
+              method: (entry[:method] || "get").to_s,
+              confirm: entry[:confirm],
+              scope: entry[:scope],
+              when: entry[:when],
+              resource: entry[:resource],
+              verb: entry[:verb],
+              params: entry[:params],
+              help: entry[:help],
+              finder_kind: entry[:finder_kind]
+            }
+            detail = entry[:detail].presence || entry[:subtitle].presence
+            item[:detail] = detail.to_s if detail.present?
+            keywords = Array(entry[:keywords]).map { |keyword| keyword.to_s.presence }.compact
+            item[:keywords] = keywords if keywords.any?
+            item
+          end
+        end
+
+        def resolve_url(view, entry, context = {})
+          context = normalize_context(context)
+          url =
+            if entry[:url].present?
+              interpolate(entry[:url], context)
+            else
+              path = entry[:path]
+              return if path.blank?
+
+              args = path_args_for(entry, context)
+              return if entry[:scope].to_s == "member" && !entry.key?(:path_args) && args.empty?
+
+              view.public_send(path, *args)
+            end
+
+          append_query(url, entry[:query], context)
+        rescue NoMethodError, ActionController::UrlGenerationError
+          nil
+        end
+
+        def matches_context?(entry, context)
+          context = normalize_context(context)
+          scope = (entry[:scope] || "global").to_s
+          when_list = Array(entry[:when] || "any").map(&:to_s)
+          action = gated_action(context[:action])
+
+          return false if scope == "member" && context[:record_param].blank?
+          return false if scope == "collection" && action != "index"
+          return false unless when_list.include?("any") || when_list.include?(action) || when_list.include?(context[:action].to_s)
+
+          if %w[member collection].include?(scope) && entry[:resource].present?
+            return false if context[:resource].to_s != entry[:resource].to_s
+          end
+
+          true
+        end
+
+        def enabled?(entry, view)
+          return true unless entry.key?(:if)
+
+          condition = entry[:if]
+          return !!condition unless condition.respond_to?(:call)
+
+          !!view.instance_exec(&condition)
+        end
+
+        private
+
+        def normalize_context(context)
+          hash = (context || {}).transform_keys(&:to_sym)
+          {
+            namespace: hash[:namespace],
+            resource: hash[:resource],
+            resource_param: hash[:resource_param],
+            record_param: hash[:record_param],
+            action: hash[:action].to_s.presence || "other",
+            page: hash[:page]
+          }
+        end
+
+        def gated_action(action)
+          case action.to_s
+          when "create" then "new"
+          when "update" then "edit"
+          else action.to_s
+          end
+        end
+
+        def path_args_for(entry, context)
+          return Array(entry[:path_args]) if entry.key?(:path_args)
+
+          if entry[:scope].to_s == "member"
+            record = context[:record_param]
+            return [] if record.blank?
+
+            return [record]
+          end
+
+          []
+        end
+
+        def interpolate(value, context)
+          value.to_s
+            .gsub("%{record_param}", context[:record_param].to_s)
+            .gsub("%{resource}", context[:resource].to_s)
+        end
+
+        def append_query(url, query, context)
+          return url if url.blank? || query.blank?
+
+          pairs = query.filter_map do |key, value|
+            interpolated = interpolate(value, context)
+            next if interpolated.blank?
+
+            [key.to_s, interpolated]
+          end
+          return url if pairs.empty?
+
+          uri, fragment = url.to_s.split("#", 2)
+          base, existing = uri.split("?", 2)
+          merged = Rack::Utils.parse_nested_query(existing.to_s)
+          pairs.each { |key, value| merged[key] = value }
+          qs = merged.to_query
+          built = qs.present? ? "#{base}?#{qs}" : base
+          fragment.present? ? "#{built}##{fragment}" : built
+        end
+
+        def walk_menu(menu, view, parents: [])
+          menu.items(view).flat_map do |item|
+            label = item.label(view).to_s
+            children = item.items(view).presence
+            crumbs = parents + [label]
+
+            if children
+              walk_menu(item, view, parents: crumbs)
+            elsif (url = item.url(view)).present?
+              keywords = crumbs.map { |crumb| crumb.to_s.downcase.strip }.reject(&:blank?).uniq
+              entry = {
+                id: "nav-#{item.id}",
+                kind: "navigate",
+                label: crumbs.join(" › "),
+                url: url,
+                method: "get"
+              }
+              entry[:keywords] = keywords if keywords.any?
+              [entry]
+            else
+              []
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activeadmin/command_palette/compiler.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    class Compiler
+      Registration = Struct.new(
+        :kind,
+        :noun,
+        :resource_name,
+        :resource_class,
+        :find_columns,
+        :label_method,
+        :order_column,
+        :show_path,
+        :new_path,
+        :edit_path
+      )
+
+      class << self
+        def compile
+          actions = []
+          finders = []
+
+          each_resource do |resource|
+            palette = resource.command_palette_config
+            next unless palette.enabled?
+
+            registration = build_registration(resource, palette)
+            actions.concat(standard_actions_for(registration, palette))
+            actions.concat(member_actions_for(registration, palette))
+            finders << registration if registration.find_columns.any?
+          end
+
+          {actions: actions, finders: finders}
+        end
+
+        private
+
+        def each_resource
+          return unless defined?(ActiveAdmin) && ActiveAdmin.application
+
+          ActiveAdmin.application.namespaces.each do |namespace|
+            namespace.resources.each do |resource|
+              next unless resource.is_a?(ActiveAdmin::Resource)
+              next unless resource.respond_to?(:command_palette_config)
+
+              yield resource
+            end
+          end
+        end
+
+        def build_registration(resource, palette)
+          namespace = resource.namespace.name.to_s
+          singular = resource.resource_name.singular
+          kind = palette.kind.presence || resource.resource_class.name.demodulize.underscore
+          noun = palette.noun.presence || kind.tr("_", " ")
+
+          Registration.new(
+            kind: kind,
+            noun: noun,
+            resource_name: resource.resource_class.name.demodulize,
+            resource_class: resource.resource_class,
+            find_columns: palette.find_columns,
+            label_method: palette.label_method,
+            order_column: palette.order_column,
+            show_path: :"#{namespace}_#{singular}_path",
+            new_path: :"new_#{namespace}_#{singular}_path",
+            edit_path: :"edit_#{namespace}_#{singular}_path"
+          )
+        end
+
+        def standard_actions_for(registration, palette)
+          actions = []
+          noun = registration.noun
+          kind = registration.kind
+          resource = registration.resource_name
+
+          if palette.standard_actions.include?(:view)
+            actions << {
+              id: "view-#{kind.tr("_", "-")}",
+              label: "View #{noun}",
+              verb: "view",
+              finder_kind: kind,
+              scope: "global",
+              when: "any",
+              help: "View #{noun} — type a search term"
+            }
+          end
+
+          if palette.standard_actions.include?(:create)
+            entry = {
+              id: "create-#{kind.tr("_", "-")}",
+              label: "Create #{noun}",
+              verb: "create",
+              path: registration.new_path,
+              scope: "global",
+              when: "any",
+              help: palette.create_help.presence || "Create #{noun}"
+            }
+            entry[:params] = palette.create_params if palette.create_params.any?
+            actions << entry
+          end
+
+          if palette.standard_actions.include?(:edit)
+            actions << {
+              id: "edit-#{kind.tr("_", "-")}",
+              label: "Edit #{noun}",
+              verb: "edit",
+              path: registration.edit_path,
+              scope: "member",
+              when: "show",
+              resource: resource
+            }
+          end
+
+          if palette.standard_actions.include?(:destroy)
+            actions << {
+              id: "delete-#{kind.tr("_", "-")}",
+              label: "Delete #{noun}",
+              verb: "destroy",
+              path: registration.show_path,
+              method: "delete",
+              confirm: "Delete this #{noun}?",
+              scope: "member",
+              when: "show",
+              resource: resource
+            }
+          end
+
+          actions
+        end
+
+        def member_actions_for(registration, palette)
+          palette.members.map do |member|
+            id = member[:id].presence || "#{member[:label].to_s.parameterize}-#{registration.kind.tr("_", "-")}"
+            entry = {
+              id: id,
+              label: member[:label],
+              scope: member.fetch(:scope, "member"),
+              when: member.fetch(:when, "show"),
+              resource: registration.resource_name,
+              method: member[:method] || "get",
+              confirm: member[:confirm],
+              path: member[:path],
+              url: member[:url],
+              path_args: member.key?(:path_args) ? member[:path_args] : nil,
+              query: member[:query],
+              verb: member[:verb] || "custom",
+              if: member.key?(:if) ? member[:if] : nil
+            }
+            entry.delete(:path_args) if entry[:path_args].nil?
+            entry.delete(:if) unless member.key?(:if)
+            entry.compact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activeadmin/command_palette/configuration.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    class Configuration
+      DEFAULT_MIN_QUERY_LENGTH = 2
+      DEFAULT_LIMIT = 20
+      DEFAULT_SEARCH_KIND_LIMIT = 20
+      ALLOWED_METHODS = %w[get post put delete].freeze
+      ALLOWED_SCOPES = %w[global collection member].freeze
+      ALLOWED_WHENS = %w[any index show new edit].freeze
+
+      attr_accessor :min_query_length, :limit, :search_kind_limit, :authorize_with, :default_finder
+      attr_reader :finders, :actions, :prefixes
+
+      def initialize
+        @min_query_length = DEFAULT_MIN_QUERY_LENGTH
+        @limit = DEFAULT_LIMIT
+        @search_kind_limit = DEFAULT_SEARCH_KIND_LIMIT
+        @finders = {}
+        @manual_finders = {}
+        @actions = []
+        @global_actions = []
+        @prefixes = {}
+        @authorize_with = nil
+        @default_finder = nil
+      end
+
+      def register_finder(kind, &block)
+        raise ArgumentError, "finder block required" unless block
+
+        kind = kind.to_s
+        @manual_finders[kind] = block
+        @finders[kind] = block
+      end
+
+      def register_prefix(prefix, kind:)
+        @prefixes[prefix.to_s] = kind.to_s
+      end
+
+      # Global allow-list (non-resource shortcuts). Resource DSL actions merge in on reload!.
+      def actions=(entries)
+        @global_actions = Array(entries).map { |entry| normalize_action(entry) }
+        @actions = @global_actions
+      end
+
+      def finder_kinds
+        @finders.keys
+      end
+
+      def reload!
+        compiled = Compiler.compile
+        @finders = @manual_finders.dup
+        compiled[:finders].each do |registration|
+          next if @finders.key?(registration.kind)
+          next if default_finder.blank?
+
+          @finders[registration.kind] = finder_proc_for(registration)
+        end
+        @actions = @global_actions + compiled[:actions].map { |entry| normalize_action(entry) }
+        self
+      end
+
+      private
+
+      def finder_proc_for(registration)
+        builder = default_finder
+        lambda do |query:, helpers:, user:, limit:|
+          builder.call(
+            registration: registration,
+            query: query,
+            helpers: helpers,
+            user: user,
+            limit: limit
+          )
+        end
+      end
+
+      def normalize_action(entry)
+        hash = entry.transform_keys(&:to_sym)
+        raise ArgumentError, "action id required" if hash[:id].to_s.strip.empty?
+        raise ArgumentError, "action label required" if hash[:label].to_s.strip.empty?
+
+        method = (hash[:method] || "get").to_s.downcase
+        unless ALLOWED_METHODS.include?(method)
+          raise ArgumentError, "unsupported action method #{method.inspect}"
+        end
+
+        if %w[post put delete].include?(method) && hash[:confirm].to_s.strip.empty?
+          raise ArgumentError, "POST, PUT, and DELETE actions require non-empty confirm text"
+        end
+
+        scope = (hash[:scope] || "global").to_s
+        unless ALLOWED_SCOPES.include?(scope)
+          raise ArgumentError, "unsupported action scope #{scope.inspect}"
+        end
+
+        when_list = normalize_when(hash[:when])
+        params = Array(hash[:params]).map { |param| normalize_param(param) }
+        query = normalize_query(hash[:query])
+
+        normalized = hash.merge(
+          method: method,
+          scope: scope,
+          when: when_list,
+          params: params,
+          query: query
+        )
+        normalized[:verb] = hash[:verb].to_s if hash[:verb].present?
+        normalized[:resource] = hash[:resource].to_s if hash[:resource].present?
+        normalized[:help] = hash[:help].to_s if hash[:help].present?
+        normalized[:finder_kind] = hash[:finder_kind].to_s if hash[:finder_kind].present?
+        normalized[:path_args] = Array(hash[:path_args]) if hash.key?(:path_args)
+        normalized[:if] = hash[:if] if hash.key?(:if)
+        normalized
+      end
+
+      def normalize_when(value)
+        list = Array(value.nil? ? "any" : value).flat_map { |item| item.to_s.split(",") }.map(&:strip)
+        list = ["any"] if list.empty?
+        list.each do |item|
+          unless ALLOWED_WHENS.include?(item)
+            raise ArgumentError, "unsupported action when #{item.inspect}"
+          end
+        end
+        list
+      end
+
+      def normalize_param(entry)
+        hash = entry.transform_keys(&:to_sym)
+        raise ArgumentError, "param name required" if hash[:name].to_s.strip.empty?
+
+        {
+          name: hash[:name].to_s,
+          required: hash[:required] ? true : false,
+          help: hash[:help]&.to_s,
+          query_key: hash[:query_key]&.to_s
+        }.compact
+      end
+
+      def normalize_query(value)
+        return {} if value.blank?
+
+        value.to_h.transform_keys(&:to_s).transform_values(&:to_s)
+      end
+    end
+  end
+end

data/lib/activeadmin/command_palette/dsl.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveAdmin
+  module CommandPalette
+    module DSL
+      def command_palette(&block)
+        definition = ResourceDSL.new(config.command_palette_config)
+        definition.instance_exec(&block) if block
+        config.command_palette_config
+      end
+    end
+  end
+end