activeadmin_configurable_columns 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bdf4162f0335b3294ed14cc99cc72ed22ce80e798276f9903e3f6a55fe2858f6
+  data.tar.gz: 6082979b4e9332a4f3d904b6ae1838855515d4a26756ba6dc2f54edd0cb06720
+SHA512:
+  metadata.gz: 33db6eb5c5af30b9fc6e092942549b791fbf48f9e691daa3ee9d273f30b0af3bb41f55137429a626465497cf83a35f5bfadb8683e47fc86c837e80a14c66b33b
+  data.tar.gz: 02a8485aa3eaac9ea24037f261ec15e82b519f216b5de39e61057fdbb7582face1cc01cb18ad7fd89854d176e2440f2fb85f7f8abc07423f3de32f2f5d5e1959

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 1.0.0 (2026-09-30)
+
+Initial release.
+
+- `configurable_columns` DSL to declare the columns an admin may pick from.
+- `configurable_columns` index-table renderer that shows the columns the
+  current admin chose, falling back to the declared defaults.
+- "Columns" picker in the sidebar of every configurable index.
+- "Table columns" admin page to review and change every table at once.
+- Per-admin persistence in the `activeadmin_configurable_columns_preferences`
+  table, with a pluggable preference store.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Kyryl Oliinyk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,170 @@
+# activeadmin_configurable_columns
+
+[![CI](https://github.com/kyryloliinyk/activeadmin_configurable_columns/actions/workflows/ci.yml/badge.svg)](https://github.com/kyryloliinyk/activeadmin_configurable_columns/actions/workflows/ci.yml)
+
+Per-admin configurable index table columns for [ActiveAdmin](https://activeadmin.info) 4.
+
+ActiveAdmin has no built-in way to let each admin choose which columns of an
+index table they see. This gem adds one, built on ActiveAdmin's own extension
+points:
+
+- a `configurable_columns do ... end` DSL declares the columns an admin may pick from;
+- `configurable_columns` inside an `index` block renders the ones the current admin chose;
+- a "Columns" picker appears in the sidebar of every configurable index;
+- a "Table columns" admin page lets an admin review and change every table at once;
+- each admin's choice is stored in the database, per admin and per table.
+
+## Requirements
+
+- Ruby >= 3.1
+- Rails >= 7.1
+- ActiveAdmin 4.0 (beta15 or later)
+
+## Installation
+
+Add the gem to your Gemfile:
+
+```ruby
+gem 'activeadmin_configurable_columns'
+```
+
+Install the migration and migrate:
+
+```sh
+bin/rails activeadmin_configurable_columns:install:migrations
+bin/rails db:migrate
+```
+
+This creates the `activeadmin_configurable_columns_preferences` table. The
+`admin` reference is polymorphic with a string id, so it works with any
+current-user model and any primary key type (integer, uuid, ...).
+
+## Usage
+
+Declare the available columns in an ActiveAdmin registration, and render them
+in the index:
+
+```ruby
+ActiveAdmin.register Product do
+  configurable_columns do
+    column :brand
+    column :sku, label: 'SKU'
+    column(:qty, sortable: 'stock_items_quantity') { |product| product.total_quantity }
+    column :notes, default: false        # available, but hidden until picked
+  end
+
+  index do
+    selectable_column
+    configurable_columns
+    actions
+  end
+end
+```
+
+`column` mirrors the arguments of ActiveAdmin's own `column`, so a declaration
+reads the same as the index DSL it replaces:
+
+| Argument | Meaning |
+| --- | --- |
+| `key` | Identifies the column in the picker and in stored preferences. Also the rendered attribute unless `attribute:` or a block says otherwise. |
+| `label:` | Column header and checkbox label. Defaults to the model's `human_attribute_name`. |
+| `default:` | Whether the column is visible for admins who never picked anything. Defaults to `true`. |
+| `attribute:` | The attribute to render when it differs from the key. |
+| a block | Renders the cell. The block is evaluated against the index table, so view helpers work, exactly as in a regular `index` column. |
+| anything else | Passed through to ActiveAdmin's `column` (e.g. `sortable:`, `class:`). |
+
+Every resource that declares `configurable_columns` gets a "Columns" sidebar
+section on its index, and a card on the "Table columns" page. Selections are
+saved per admin; unknown or stale keys are dropped on read and write, and an
+empty selection falls back to the declared defaults, so an admin can never end
+up with an empty table.
+
+## Configuration
+
+All settings are optional. In `config/initializers/activeadmin_configurable_columns.rb`:
+
+```ruby
+ActiveadminConfigurableColumns.configure do |config|
+  # Options for the "Table columns" page's `menu` call, or false to keep the
+  # page out of the navigation. Default: a translated label, top level.
+  config.menu = { parent: 'Settings', priority: 0 }
+
+  # Priority of the "Columns" sidebar section. ActiveAdmin's filters sidebar
+  # uses 10; the default (20) renders right below it.
+  config.sidebar_priority = 20
+
+  # Where selections are read from and written to. Any object answering
+  #   visible_column_keys(admin, resource_key) -> [Symbol] | nil  (nil = never saved)
+  #   store(admin:, resource_key:, keys:)
+  # can be plugged in. Default: the bundled Preference model.
+  config.preference_store = MyOwnStore
+end
+```
+
+The current admin is whatever ActiveAdmin's `current_active_admin_user`
+returns, so the gem follows your `config.current_user_method` setting.
+
+## Translations
+
+The gem ships English strings under standard ActiveAdmin keys; override them
+per locale in your application:
+
+```yaml
+en:
+  active_admin:
+    sidebars:
+      columns: "Columns"
+    table_columns:
+      title: "Table columns"
+      save: "Save columns"
+      saved: "Columns saved"
+      empty: "No table has configurable columns yet."
+      unknown_resource: "Unknown table"
+```
+
+Column checkbox labels come from `human_attribute_name`, so your existing
+Active Record attribute translations apply.
+
+## Tailwind CSS
+
+ActiveAdmin 4 builds its stylesheet with Tailwind, which only emits classes it
+finds in scanned sources. Add the gem's views to your Tailwind entrypoint (or
+config) so the picker and the "Table columns" page keep their layout:
+
+```css
+@source "<path to the installed gem>/app/views/**/*.{arb,erb,html,rb}";
+```
+
+If a rake task generates your ActiveAdmin Tailwind entrypoint, resolve the path
+with `Gem.loaded_specs['activeadmin_configurable_columns'].full_gem_path`.
+
+## How it works
+
+- `ActiveadminConfigurableColumns::Dsl` is mixed into `ActiveAdmin::ResourceDSL`;
+  `configurable_columns do ... end` builds a `Registry` of `Column`s, stores it on
+  the resource, and adds the sidebar section.
+- `ActiveadminConfigurableColumns::TableRenderer` is mixed into
+  `ActiveAdmin::Views::IndexAsTable::IndexTableFor`; `configurable_columns` inside
+  `index` looks up the current admin's saved keys and emits the matching columns.
+- The "Table columns" page is a regular `ActiveAdmin.register_page`, loaded
+  through ActiveAdmin's own load paths; its update action also serves the
+  sidebar forms.
+- Rendering an index whose resource never declared its columns raises
+  `ActiveadminConfigurableColumns::NotDeclared` with a hint, rather than an
+  empty table.
+
+## Development
+
+```sh
+bundle install
+bundle exec rspec
+```
+
+The test suite is standalone: it boots a dummy Rails application
+(`spec/dummy`) with an in-memory sqlite database and a real ActiveAdmin
+registration, and exercises the gem's migration on every run.
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](LICENSE.txt).

data/app/models/activeadmin_configurable_columns/preference.rb

@@ -0,0 +1,47 @@
+module ActiveadminConfigurableColumns
+  # One row per admin per ActiveAdmin index table, holding the columns that
+  # admin chose to see there. The available columns themselves are declared in
+  # the ActiveAdmin registration with the `configurable_columns` DSL.
+  #
+  # `admin` is polymorphic and its id column is a string, so any current-user
+  # model works, whatever its class and primary key type (integer, uuid, ...).
+  class Preference < ::ActiveRecord::Base
+    self.table_name = 'activeadmin_configurable_columns_preferences'
+
+    belongs_to :admin, polymorphic: true
+
+    # Stored as JSON text rather than a database-specific json type, so the
+    # table works the same on every Active Record adapter. The array shape is
+    # enforced by the validation below, not by the coder, so a bad assignment
+    # surfaces as a validation error instead of a serialization exception.
+    serialize :visible_columns, coder: JSON
+
+    after_initialize { self.visible_columns ||= [] if has_attribute?(:visible_columns) }
+
+    validates :resource_key, presence: true,
+                             uniqueness: { scope: %i[admin_type admin_id], case_sensitive: false }
+    validate :visible_columns_must_be_an_array
+
+    # Returns the keys this admin picked for the table, or nil when they never
+    # saved anything (the caller then falls back to the declared defaults).
+    def self.visible_column_keys(admin, resource_key)
+      return nil if admin.blank?
+
+      find_by(admin: admin, resource_key: resource_key)&.visible_columns&.map(&:to_sym)
+    end
+
+    def self.store(admin:, resource_key:, keys:)
+      preference = find_or_initialize_by(admin: admin, resource_key: resource_key)
+      preference.update!(visible_columns: keys.map(&:to_s))
+      preference
+    end
+
+    private
+
+    def visible_columns_must_be_an_array
+      return if visible_columns.is_a?(Array)
+
+      errors.add(:visible_columns, :invalid)
+    end
+  end
+end

data/app/views/activeadmin_configurable_columns/_form.html.erb

@@ -0,0 +1,25 @@
+<%# Checkbox picker for one index table. Rendered both in the index sidebar and
+    on the "Table columns" page, so it always posts back to the same action. %>
+<% registry = resource.column_registry %>
+<% selected = ActiveadminConfigurableColumns.visible_columns(registry, current_active_admin_user).map(&:key) %>
+<% update_path = send(ActiveadminConfigurableColumns.route_name(active_admin_namespace, :update)) %>
+
+<%= form_with url: update_path, method: :patch, class: 'filters-form' do %>
+  <%= hidden_field_tag :resource_key, registry.resource_key, id: nil %>
+  <%# Keeps the parameter present when every box is unchecked, which restores the defaults. %>
+  <%= hidden_field_tag 'visible_columns[]', '', id: nil %>
+
+  <div class="flex flex-col gap-2 mb-4">
+    <% registry.columns.each do |column| %>
+      <% checkbox_id = "#{registry.resource_key}_column_#{column.key}" %>
+      <div class="flex items-center gap-2">
+        <%= check_box_tag 'visible_columns[]', column.key, selected.include?(column.key), id: checkbox_id %>
+        <%= label_tag checkbox_id, column.human_label(resource.resource_class), class: 'text-sm' %>
+      </div>
+    <% end %>
+  </div>
+
+  <div class="filters-form-buttons">
+    <%= submit_tag t('active_admin.table_columns.save'), class: 'filters-form-submit' %>
+  </div>
+<% end %>

data/app/views/activeadmin_configurable_columns/_page.html.erb

@@ -0,0 +1,16 @@
+<% if resources.empty? %>
+  <div class="panel">
+    <div class="panel-body"><%= t('active_admin.table_columns.empty') %></div>
+  </div>
+<% else %>
+  <div class="grid gap-6 md:grid-cols-2 xl:grid-cols-3">
+    <% resources.each do |resource| %>
+      <div class="panel">
+        <h3 class="panel-title"><%= resource.plural_resource_label %></h3>
+        <div class="panel-body">
+          <%= render 'activeadmin_configurable_columns/form', resource: resource %>
+        </div>
+      </div>
+    <% end %>
+  </div>
+<% end %>

data/app/views/activeadmin_configurable_columns/_sidebar.html.erb

@@ -0,0 +1,2 @@
+<h3 class="filters-form-title"><%= t('active_admin.sidebars.columns') %></h3>
+<%= render 'activeadmin_configurable_columns/form', resource: resource %>

data/config/locales/en.yml

@@ -0,0 +1,10 @@
+en:
+  active_admin:
+    sidebars:
+      columns: "Columns"
+    table_columns:
+      title: "Table columns"
+      save: "Save columns"
+      saved: "Columns saved"
+      empty: "No table has configurable columns yet."
+      unknown_resource: "Unknown table"

data/db/migrate/20260930000001_create_activeadmin_configurable_columns_preferences.rb

@@ -0,0 +1,18 @@
+class CreateActiveadminConfigurableColumnsPreferences < ActiveRecord::Migration[7.1]
+  def change
+    create_table :activeadmin_configurable_columns_preferences do |t|
+      # A string id fits every primary key type a current-user model may have.
+      t.string :admin_type, null: false
+      t.string :admin_id, null: false
+      t.string :resource_key, null: false
+      # JSON-serialized array of column keys; plain text so every adapter works.
+      t.text :visible_columns
+      t.timestamps
+    end
+
+    add_index :activeadmin_configurable_columns_preferences,
+              %i[admin_type admin_id resource_key],
+              unique: true,
+              name: 'index_aacc_preferences_on_admin_and_resource_key'
+  end
+end

data/lib/activeadmin_configurable_columns/admin/table_columns.rb

@@ -0,0 +1,37 @@
+# The "Table columns" page: a central place to review and change visible table
+# columns at once. The same form is rendered in the "Columns" sidebar of every
+# configurable index, and both post back to the page's update action.
+ActiveAdmin.register_page 'Table columns' do
+  menu ActiveadminConfigurableColumns.menu
+
+  content title: proc { I18n.t('active_admin.table_columns.title') } do
+    resources = ActiveadminConfigurableColumns.resources(active_admin_namespace).select do |resource|
+      authorized?(ActiveAdmin::Authorization::READ, resource.resource_class)
+    end
+
+    render 'activeadmin_configurable_columns/page', resources: resources
+  end
+
+  page_action :update, method: :patch do
+    page_path = send(ActiveadminConfigurableColumns.route_name(active_admin_namespace))
+    resource = ActiveadminConfigurableColumns.resource_for(active_admin_namespace, params[:resource_key])
+
+    if resource.nil?
+      redirect_back fallback_location: page_path,
+                    status: :see_other,
+                    alert: t('active_admin.table_columns.unknown_resource')
+    else
+      registry = resource.column_registry
+
+      ActiveadminConfigurableColumns.preference_store.store(
+        admin: current_active_admin_user,
+        resource_key: registry.resource_key,
+        keys: registry.selected_keys(params[:visible_columns])
+      )
+
+      redirect_back fallback_location: page_path,
+                    status: :see_other,
+                    notice: t('active_admin.table_columns.saved')
+    end
+  end
+end

data/lib/activeadmin_configurable_columns/column.rb

@@ -0,0 +1,49 @@
+module ActiveadminConfigurableColumns
+  # A single column an admin may show or hide. Mirrors the arguments of
+  # ActiveAdmin's `column` so a declaration reads the same as the index DSL it
+  # replaces.
+  class Column
+    attr_reader :key, :attribute, :label, :options, :block
+
+    def initialize(key, label: nil, default: true, attribute: nil, block: nil, **options)
+      @key = key.to_sym
+      @attribute = (attribute || key).to_sym
+      @label = label
+      @default = default
+      @options = options
+      @block = block
+    end
+
+    def default? = @default
+
+    # Emits the column into an ActiveAdmin index table.
+    def render_into(table)
+      args = []
+      args << label if label
+      args << attribute unless label && block
+      args << options
+
+      table.column(*args, &cell_renderer(table))
+    end
+
+    # ActiveAdmin renders a column block with a plain `block.call(resource)`
+    # (DisplayHelper#find_value), so the block runs with whatever `self` it captured
+    # where it was written. Written inside an `index` block that is the view, which is
+    # how view helpers resolve. Ours is written inside a `configurable_columns` block,
+    # evaluated against the Builder, so it has to be rebound to the table at render
+    # time -- otherwise a helper call in a column block raises NoMethodError.
+    def cell_renderer(table)
+      return nil unless block
+
+      proc { |resource| table.instance_exec(resource, &block) }
+    end
+
+    # Human name for the checkbox in the settings form.
+    def human_label(resource_class)
+      return label if label
+      return attribute.to_s.humanize unless resource_class.respond_to?(:human_attribute_name)
+
+      resource_class.human_attribute_name(attribute, default: attribute.to_s.humanize)
+    end
+  end
+end

data/lib/activeadmin_configurable_columns/dsl.rb

@@ -0,0 +1,36 @@
+module ActiveadminConfigurableColumns
+  # Mixed into ActiveAdmin::ResourceDSL. Declares the columns an admin may pick
+  # from, and adds the "Columns" sidebar section to the index page:
+  #
+  #   ActiveAdmin.register Product do
+  #     configurable_columns do
+  #       column :brand
+  #       column :qty, sortable: 'stock_items_quantity' { |p| p.total_quantity }
+  #       column :notes, default: false
+  #     end
+  #
+  #     index do
+  #       selectable_column
+  #       configurable_columns
+  #       actions
+  #     end
+  #   end
+  module Dsl
+    def configurable_columns(&block)
+      config.column_registry = Registry.build(config.resource_name.route_key, &block)
+      config.sidebar_sections << columns_sidebar_section
+    end
+
+    private
+
+    def columns_sidebar_section
+      ActiveAdmin::SidebarSection.new(
+        :columns,
+        only: :index,
+        priority: ActiveadminConfigurableColumns.sidebar_priority
+      ) do
+        render 'activeadmin_configurable_columns/sidebar', resource: active_admin_config
+      end
+    end
+  end
+end

data/lib/activeadmin_configurable_columns/engine.rb

@@ -0,0 +1,21 @@
+module ActiveadminConfigurableColumns
+  # Wires the library into the host application: autoloads the Preference model,
+  # adds the gem's views and locales, and teaches ActiveAdmin the DSL before the
+  # application's app/admin files load (ActiveAdmin loads them lazily, long after
+  # the initializers ran).
+  class Engine < ::Rails::Engine
+    engine_name 'activeadmin_configurable_columns'
+
+    initializer 'activeadmin_configurable_columns.active_admin' do
+      ActiveAdmin::Resource.include ResourceExtension
+      ActiveAdmin::ResourceDSL.include Dsl
+      ActiveAdmin::Views::IndexAsTable::IndexTableFor.include TableRenderer
+
+      # The "Table columns" page is a regular ActiveAdmin page registration, not
+      # a constant, so it lives outside the autoload paths and loads through
+      # ActiveAdmin's own load paths, together with the application's app/admin.
+      ActiveAdmin.application.load_paths <<
+        Engine.root.join('lib', 'activeadmin_configurable_columns', 'admin').to_s
+    end
+  end
+end

data/lib/activeadmin_configurable_columns/registry.rb

@@ -0,0 +1,46 @@
+module ActiveadminConfigurableColumns
+  # The columns declared for one ActiveAdmin resource, in declaration order.
+  class Registry
+    attr_reader :resource_key, :columns
+
+    def self.build(resource_key, &block)
+      builder = Builder.new
+      builder.instance_eval(&block)
+      new(resource_key, builder.columns)
+    end
+
+    def initialize(resource_key, columns)
+      @resource_key = resource_key.to_s
+      @columns = columns.freeze
+    end
+
+    def keys = columns.map(&:key)
+
+    def default_keys = columns.select(&:default?).map(&:key)
+
+    # Declared columns matching the given keys, in declaration order. Unknown or
+    # stale keys are dropped; a blank selection falls back to the defaults, so an
+    # admin can never end up with an empty table.
+    def columns_for(keys)
+      wanted = Array(keys).map(&:to_sym)
+      wanted = default_keys if (wanted & self.keys).empty?
+
+      columns.select { |column| wanted.include?(column.key) }
+    end
+
+    def selected_keys(keys) = columns_for(keys).map(&:key)
+
+    # Collects `column` declarations from a `configurable_columns` block.
+    class Builder
+      attr_reader :columns
+
+      def initialize
+        @columns = []
+      end
+
+      def column(key, **options, &block)
+        @columns << Column.new(key, block: block, **options)
+      end
+    end
+  end
+end

data/lib/activeadmin_configurable_columns/resource_extension.rb

@@ -0,0 +1,10 @@
+module ActiveadminConfigurableColumns
+  # Mixed into ActiveAdmin::Resource so every registered resource can carry the
+  # registry declared for it. Resources are rebuilt whenever app/admin is
+  # reloaded, so the registry never outlives the code that declared it.
+  module ResourceExtension
+    attr_accessor :column_registry
+
+    def configurable_columns? = !column_registry.nil?
+  end
+end

data/lib/activeadmin_configurable_columns/table_renderer.rb

@@ -0,0 +1,18 @@
+module ActiveadminConfigurableColumns
+  # Mixed into ActiveAdmin::Views::IndexAsTable::IndexTableFor, so that
+  # `configurable_columns` inside an `index` block renders the columns the
+  # current admin chose (falling back to the declared defaults).
+  module TableRenderer
+    def configurable_columns
+      registry = active_admin_config.column_registry
+
+      if registry.nil?
+        raise ActiveadminConfigurableColumns::NotDeclared, active_admin_config.resource_name.to_s
+      end
+
+      ActiveadminConfigurableColumns
+        .visible_columns(registry, helpers.current_active_admin_user)
+        .each { |column| column.render_into(self) }
+    end
+  end
+end

data/lib/activeadmin_configurable_columns/version.rb

@@ -0,0 +1,3 @@
+module ActiveadminConfigurableColumns
+  VERSION = '1.0.0'.freeze
+end

data/lib/activeadmin_configurable_columns.rb

@@ -0,0 +1,98 @@
+require 'active_admin'
+
+require_relative 'activeadmin_configurable_columns/version'
+
+# Per-admin index table columns for ActiveAdmin.
+#
+# ActiveAdmin has no built-in way to let each admin choose which columns of an
+# index table they see. This gem adds one, built on ActiveAdmin's own extension
+# points:
+#
+#   * ResourceDSL   -- `configurable_columns` declares the available columns
+#   * IndexTableFor -- `configurable_columns` renders the chosen ones
+#   * SidebarSection -- the picker next to every configurable index table
+#
+# The choice is stored per admin by the preference store, which defaults to the
+# bundled ActiveadminConfigurableColumns::Preference model.
+module ActiveadminConfigurableColumns
+  # ActiveAdmin renders the filters sidebar section with priority 10; the
+  # default puts the "Columns" picker right below it.
+  DEFAULT_SIDEBAR_PRIORITY = 20
+
+  # Raised when an index renders `configurable_columns` without a matching
+  # `configurable_columns do ... end` declaration.
+  class NotDeclared < StandardError
+    def initialize(resource_name)
+      super("#{resource_name} renders configurable_columns but never declares them. " \
+            'Add a `configurable_columns do ... end` block to its ActiveAdmin registration.')
+    end
+  end
+
+  class << self
+    def configure
+      yield self
+    end
+
+    # Where saved selections live. Any object answering
+    #
+    #   visible_column_keys(admin, resource_key) -> [Symbol] | nil   (nil = never saved)
+    #   store(admin:, resource_key:, keys:)                          (persists a selection)
+    #
+    # can be plugged in; the default is the bundled Preference model. Assigning
+    # nil restores that default.
+    attr_writer :preference_store
+
+    def preference_store = @preference_store || Preference
+
+    # Priority of the "Columns" sidebar section. Assigning nil restores the default.
+    attr_writer :sidebar_priority
+
+    def sidebar_priority = @sidebar_priority || DEFAULT_SIDEBAR_PRIORITY
+
+    # Options passed to `menu` for the "Table columns" page (assign false to keep
+    # the page out of the menu entirely). Assigning nil restores the default.
+    attr_writer :menu
+
+    def menu
+      return @menu unless @menu.nil?
+
+      { label: proc { I18n.t('active_admin.table_columns.title') } }
+    end
+
+    # The columns the given admin sees for this resource.
+    def visible_columns(registry, admin)
+      saved = preference_store.visible_column_keys(admin, registry.resource_key)
+
+      registry.columns_for(saved || registry.default_keys)
+    end
+
+    # Every resource of the namespace that declares configurable columns.
+    def resources(namespace)
+      namespace.resources.select do |resource|
+        resource.respond_to?(:configurable_columns?) && resource.configurable_columns?
+      end
+    end
+
+    def resource_for(namespace, resource_key)
+      resources(namespace).find { |resource| resource.column_registry.resource_key == resource_key.to_s }
+    end
+
+    # Name of a route helper for the "Table columns" page in the given namespace:
+    #
+    #   route_name(admin_namespace)           # => 'admin_table_columns_path'
+    #   route_name(admin_namespace, :update)  # => 'admin_table_columns_update_path'
+    #
+    # The namespace prefix is looked up rather than hardcoded, so the page works
+    # in any ActiveAdmin namespace, including the root one.
+    def route_name(namespace, action = nil)
+      [namespace.route_prefix, 'table_columns', action, 'path'].compact.join('_')
+    end
+  end
+end
+
+require_relative 'activeadmin_configurable_columns/column'
+require_relative 'activeadmin_configurable_columns/registry'
+require_relative 'activeadmin_configurable_columns/dsl'
+require_relative 'activeadmin_configurable_columns/resource_extension'
+require_relative 'activeadmin_configurable_columns/table_renderer'
+require_relative 'activeadmin_configurable_columns/engine'

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: activeadmin_configurable_columns
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kyryl Oliinyk
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activeadmin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta15
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta15
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: Lets every admin choose which columns of an ActiveAdmin index table they
+  see. Adds a `configurable_columns` DSL to declare the available columns, renders
+  a "Columns" picker in the index sidebar and on a central "Table columns" page, and
+  stores each admin's choice in the database.
+email:
+- kyryloliinyk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- app/models/activeadmin_configurable_columns/preference.rb
+- app/views/activeadmin_configurable_columns/_form.html.erb
+- app/views/activeadmin_configurable_columns/_page.html.erb
+- app/views/activeadmin_configurable_columns/_sidebar.html.erb
+- config/locales/en.yml
+- db/migrate/20260930000001_create_activeadmin_configurable_columns_preferences.rb
+- lib/activeadmin_configurable_columns.rb
+- lib/activeadmin_configurable_columns/admin/table_columns.rb
+- lib/activeadmin_configurable_columns/column.rb
+- lib/activeadmin_configurable_columns/dsl.rb
+- lib/activeadmin_configurable_columns/engine.rb
+- lib/activeadmin_configurable_columns/registry.rb
+- lib/activeadmin_configurable_columns/resource_extension.rb
+- lib/activeadmin_configurable_columns/table_renderer.rb
+- lib/activeadmin_configurable_columns/version.rb
+homepage: https://github.com/kyryloliinyk/activeadmin_configurable_columns
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/kyryloliinyk/activeadmin_configurable_columns
+  changelog_uri: https://github.com/kyryloliinyk/activeadmin_configurable_columns/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/kyryloliinyk/activeadmin_configurable_columns/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: Per-admin configurable index table columns for ActiveAdmin 4.
+test_files: []