active_scaffold_config_list 3.6.3 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50364f3882bef87059e8b9355d09cd218d237f6a5a4932fd647117c655d64e11
-  data.tar.gz: e7bcab07d7f032be6174a2cd3ea8295cd1f6ec6a1742f0ad567bc1b4ec0cc950
+  metadata.gz: 2065069db537dffc9b14bbdb46247225138c88b5e521998810333f7d602978ba
+  data.tar.gz: 19471cbf086ad1f9ab84f5acf6bcbd3d1c336496f84a13838985f1ae26b72722
 SHA512:
-  metadata.gz: 114309cc4df41633688338ad1495ab848e056b1b8698a9f2046ed4bd76e54bb20a61850affec8c4cc46453e23c0d98a7119eac463a6c9d8e46b2847687be0f65
-  data.tar.gz: 94b48977865381533466595356b71cfe4c16b5aff4c4ae499a0d22c2a6480c57d6a206b66c3dcb2b61ad11d410f80c7e2aacc3928eec741a6e1b2e575ee3d523
+  metadata.gz: 5b14bcf01e3afabb7935cffa6142f159a5dd08d1d90c432976ced5d0d82612ea29315bff85e7e3eb25f4d429b7a25ecb38c11fb217c5ec4e6fa1e5c1b16be759
+  data.tar.gz: 495a02db21bb2ab03905f15287b31b7582ac1a02a89d14fdfda287550ca6ef69de2dddd28a55efa162c80026150ed91acb5628ddb88899dd9202f0d29f443d50

data/README.md

@@ -16,12 +16,13 @@ Overview
 ========
 
 A plugin for Active Scaffold that provides the ability to choose the column to show in the scaffold list at run-time.
+Also, it adds the ability to define named views with other set of columns to choose between the default list view and
+the named views.
 
 You have the option of defining a default set of columns for the controller. For example:
 ```rb
 config.config_list.default_columns = [:name, :project, :amount]
 ```
-If this is not defined then active_scaffold_config.list.columns is used.
 
 This is useful when you want the option to look at a potentially large number of columns but be able to 
 easily reset back to something that fits on the screen without horizontal scrolling.
@@ -30,24 +31,61 @@ The available columns in the configure action are the columns defined in `list.c
 `config_list.default_columns` is not defined, then it will default to `list.columns`, and the users only will be able
 to remove some columns, they won't be able to add other columns.
 
-The configuration data will be saved on the session. It can be saved on the DB defining a method on the user model
-(the one returned by current_user method) to return a record for current controller, or empty record if user has no
-list configuration, and setting config_list to use that method.
+The configuration data will be saved in the session.
+
+## Named Views
+
+It's possible to define named views, with a set of columns, so users can switch between default view and other defined views. Adding a view is done with `add_view` method, and passing a name (symbol or string) and an array of columns:
 
 ```rb
-conf.config_list.save_to_user = :config_list_for
+conf.config_list.add_view :simple, [:number, :status]
 ```
 
-It can be changed globally for the app in `ActiveScaffold.defaults` in an initializer, such as:
+Although it's possible to use a block too, to change other view settings, such as label, sorting and security method. If the label is set, it can be a string, or a symbol to be localized, and the name is used in the URL parameters. When using a block, the columns can be defined in the view instead of the `add_view` call:
 
 ```rb
-ActiveScaffold.defaults do |config|
-  config.config_list.save_to_user
+conf.config_list.add_view :simple do |view|
+  view.label = 'Number and Status'
+  view.columns = [:number, :status]
+  view.sorting = {number: :desc}
+  view.security_method = :simple_view_authorized?
+end
+```
+
+The columns defined in the view are not required to be in the `conf.list.columns`, so it's possible to add views including columns that are not available in the normal config list.
+
+The security method is a controller method used to check if the view is available for the user, it must return true when the view is allowed:
+
+```rb
+def simple_view_authorized?
+  current_user.is_admin?
 end
 ```
 
-The model storing list configuration must have a config_list text column storing the columns list, and config_list_sort
-serialized text column. For example:
+When a named view is selected, the configure action link is not rendered.
+
+The view selector is displayed in the title header, and it's rendered as a menu of links, displaying the selected view, and the list of available views on hover. The selector can be changed to a list of radio buttons or select field with `conf.config_list.named_views_selector`,per controller, or it can be changed globally in `ActiveScaffold.defaults`:
+
+```rb
+conf.config_list.named_views_selector = :radio  # use radio buttons
+conf.config_list.named_views_selector = :select # use select field
+conf.config_list.named_views_selector = :links  # use a menu of links (default)
+```
+
+The position of the views selector can be changed with `conf.config_list.named_views_position`, setting it to `:center` (default, between the title and actions), `:left` (next to the title) or `:right` (at the right of the actions). Although the position of the `div.config-list-views` doesn't change, it just adds a class (center, right or left) and use CSS of flexbox layout to change the position (changing `flex-grow` and `order`). It can be changed per controller or globally in `ActiveScaffold.defaults`:
+
+```rb
+conf.config_list.named_views_position = :center
+conf.config_list.named_views_position = :left
+conf.config_list.named_views_position = :right
+```
+
+## Saving to DB
+
+The configuration data can be saved on the DB. Define a model to store the list configuration, it must have a config_list
+text column storing the columns list, and config_list_sort serialized text column, a foreign key for the user and a column
+saving the controller name or ID. Also, if using saving named views feature, it must have a column to store the view name,
+and a column to store the slug if global views are enabled. For example:
 
 ```rb
 # == Schema Information
@@ -61,6 +99,8 @@ serialized text column. For example:
 #  updated_at          :datetime         not null
 #  controller_id       :string(255)
 #  user_id             :bigint
+#  view_name           :string
+#  slug                :string
 #
 # Indexes
 #
@@ -73,16 +113,125 @@ class ListConfiguration < ApplicationRecord
 end
 ```
 
-Then in the User model, define the association, and the method returning the config list for the requested controller.
-The method has 2 arguments, `controller_id` and `controller_name`, so only need to save one of them, depending if user
-configuration must be shared on different conditions for embedded controllers, and each parent for nested controllers,
-or save unique configurations. The `controller_id` argument will be different in embedded controllers, nested controllers
-and regular controllers, as it will use `active_scaffold_session_storage_key`, and the controller_name will be the same
-always.
+Then in your user model call `has_config_lists 'ModelName'` to define the `has_many` association to the model storing
+the list configuration. The method `has_config_lists` requires a model name, and a hash of options:
+
+* association_name: defaults to `list_configurations`
+* association_options: the options for the `has_many` association, for example, `dependent`, `as` if the model has a
+polymorphic association because it's used by different user models, foreign_key, and any other option accepted by
+`has_many`.
+* controller_column: the column storing the controller name or ID.
+* controller_matcher: :controller_id, :controller_name, or a proc. If you want to match the controller column with the
+controller name or controller ID (see below for the difference between controller name and ID).
+* view_name_column: the name for the column storing the view name (see Saving Named Views)
+* slug_column: the name of the column storing the slug for the view (see Global Views)
+
+```rb
+class User < ApplicationRecord
+  has_config_lists 'ListConfiguration', association_options: {dependent: :delete_all}
+end
+```
+
+Finally, set the setting `config_list.save_to_user` to `:config_list_for` in the controllers using config_list.
+
+```rb
+conf.config_list.save_to_user = :config_list_for
+```
+
+It can be changed globally for the app in `ActiveScaffold.defaults` in an initializer, such as:
+
+```rb
+ActiveScaffold.defaults do |config|
+  config.config_list.save_to_user = :config_list_for
+end
+```
+
+There are 2 ways to store the list configuration for a controller. Saving the controller name or the controller ID.
+If the user configuration must be shared on different conditions for embedded controllers, and each parent for nested
+controllers, or save unique configurations. The controller ID argument will be different in embedded controllers,
+nested controllers and regular controllers, as it will use `active_scaffold_session_storage_key`, and the controller
+name will always be the same.
+
+## Saving Named Views
+
+It's possible to save the list configuration with a name, and change between default view, named views defined in the
+config and user named views. Config list will have a field to set the name, when no name is set, it's saved as a normal
+config list, overriding the default view.
+
+When a user named view is selected, configure will open the form with that view's settings. If the name is changed, a
+checkbox will show up that allows renaming the current view. Submitting the form without checking that checkbox will
+create a new named view, and will rename the current view if the checkbox is selected. In this case, it isn't possible
+to override the default view, clearing the view's name won't be allowed.
+
+Also, when an user named view is selected, the config list form will have a delete link instead of the reset link.
+
+![screenshot](./images/config-named-view.png)
+
+Enabling this feature requires enabling saving views to the DB, with `conf.config_list.save_to_user`, as it will use
+the same method to get the named view, and set another method in `conf.config_list.named_views_method`. Both options
+can be set per controller, or globally in `ActiveScaffold.defaults`. Set `named_views_method` to `:config_list_views`.
+
+## Global Views
+
+It's possible to define global views, so they are available to all users. It's enabled with `conf.config_list.global_views`, and requires to use `save_to_user` and `named_views_method` too, as they work as saved named views.
+
+When configuring the list, a global view checkbox will show up when the view name is set, but the global checkbox can be
+changed only if a new view is going to be created (the name of the view is changed, and rename is unchecked). Otherwise,
+global view will be disabled, showing if the view is global or not, but can't be changed until the name is edited.
+
+The user association in ListConfiguration must be set as optional, as global views will be saved without the user
+foreign key.
+
+```rb
+class ListConfiguration < ApplicationRecord
+  belongs_to :user, optional: true
+  serialize :config_list_sorting, JSON
+end
+```
+
+These views require having a name, then when a name is typed, a global view checkbox will show up. It requires another
+column in the list configuration model, `slug`, as there may be a name collision, and it's hard to prevent, because
+it's weird to forbid creating a global view with a name, because some other user already used it for a private view.
+The slug will be built prefixing the view name with `user-` or `global-` by default.
+
+If you want to change how slugs are built globally, you can define a method in ApplicationController, and configure it
+with `conf.config_list.slug_builder` in `ActiveScaffold.defaults`. It's a global setting only, can't be set per controller.
+To customize slug builder in a controller, define `config_list_slug` in the controller. The `config_list_slug` method,
+and the slug builder method, will get the view name and global_view boolean, and must return the slug. It's called when
+saving a view. Changing how slugs are generated can break the default `config_list_for` method if the slug for user views
+doesn't start with `user-`.
+
+If you want to override a global view with a private view having the same name, so user don't see 2 options with the same
+name in the views selector, override `config_list_views` in your user model, after calling `has_config_lists`, and get
+uniq views by name:
+
+```rb
+def config_list_views(*)
+  super.uniq { |(name, _)| name }
+end
+```
+
+Also, it's possible to override it to change the name of the views, appending an indicator for user views or global views
+when the name is not unique.
+
+## Custom model methods
+
+It's possible to write custom code in the user model, instead of using `has_config_lists`. Although it's more
+complicated, especially if global views feature is enabled.
+
+Define the `has_many` association in the user model, and the method or methods configured in `save_to_user` and
+`named_views_method`.
+
+The method configured in `save_to_user` must return the record storing the list configuration for the requested
+controller. The method has 2 arguments, `controller_id` and `controller_name`, so only need to save one of them.
 
 ```rb
-class User < ActiveRecord::Base
-  has_many :list_configurations
+ActiveScaffold.defaults do |config|
+  config.config_list.save_to_user = :config_list_for
+end
+
+class User < ApplicationRecord
+  has_many :list_configurations, dependent: :delete_all
   def config_list_for(controller_id, controller_name)
     # Use controller_id to allow having different columns on different nested or embedded conditions
     list_configurations.where(controller_id: controller_id).first_or_initialize
@@ -91,3 +240,55 @@ class User < ActiveRecord::Base
   end
 end
 ```
+
+When `named_views_method` is set, the method in `save_to_user` must accept options with double splat (or keyword
+arguments `view_name` and `attributes`), and it's responsible to look for a named view for the user using view_name,
+and return a new model when none is found. Also, it's responsible to set the view_name from opts[:attributes] (or
+`attributes` keyword arg) in the right column. It can use the same model explained before. When selecting the default
+view, and saving it, the keyword arguments will be nil.
+
+```rb
+  def config_list_for(controller_id, controller_name, **opts)
+    list_configurations.where(controller_id: controller_name, view_name: opts[:view_name]).first_or_initialize.tap do |r|
+      r.view_name == opts[:attributes][:view_name] if opts[:attributes]
+    end
+  end
+```
+
+The method in `named_views_method` must return an array with the saved named views for the user, and each item will be an array with the label and name in URL parameter (for example, `view_name` and `slug` columns), or just a string to use for both label and name. This method will receive `controller_id` and `controller_name` arguments, just like the method in `save_to_user`.
+
+```rb
+ActiveScaffold.defaults do |config|
+  config.config_list.named_views_method = :config_list_views
+end
+
+class User < ApplicationRecord
+  def config_list_views(controller_id, controller_name)
+    list_configurations.where(controller_id: controller_name).where.not(view_name: nil).pluck(:view_name)
+  end
+end
+```
+
+When using global views, the method configured in `save_to_user` will get another keyword argument, `slug`, instead of `view_name`, and must use this one to find the view. The `attributes` keyword argument will have `slug` key and
+`view_name` key. When the provided slug is for a global view, and no view is found, it shouldn't set the user id, but
+when there is no slug, or the slug is for an user view, the user id should be set:
+
+```rb
+def config_list_for(controller_id, controller_name, slug: nil, attributes: nil)
+  query = list_configurations
+  query = ListConfiguration.where(user_id: nil).or(list_configurations) unless slug.to_s.start_with?('user-')
+  query.where(controller_id: controller_name, slug: slug).first_or_initialize.tap do |record|
+    record.attributes = attributes if attributes
+  end
+end
+```
+
+And the method configured in `named_views_method` should return the view name and the slug, so user see the view name, and slug is used in the URL:
+
+```rb
+def config_list_views(controller_id, controller_name)
+  list_configurations.or(ListConfiguration.where(user_id: nil)).where.not(slug: nil).pluck(:view_name, :slug)
+end
+```
+
+It's possible to user other column names than `view_name` and `slug`, just ensure the values are set from `attributes[:view_name]` and `attributes[:slug]`, and use the right column names in the queries.

data/app/assets/javascripts/active_scaffold_config_list.js

@@ -0,0 +1,41 @@
+jQuery(document).ready(function () {
+    jQuery(document).on('change', '.config-list-views[data-remote]', function () {
+        jQuery(this).closest('form').submit();
+    });
+    jQuery(document).on('ajax:success', '.config-list-views', function () {
+        var form = jQuery(this), link = form.parent().find('.actions [data-action="show_config_list"]'),
+            href = new URL(link.attr('href'), window.location.origin);
+        href.searchParams.set('config_list_view', form.find('select,input[checked]').val());
+        link.attr('href', href.toString());
+    });
+    jQuery(document).on('input', '.show_config_list-view [name="config_list_view_name"]', function () {
+        var field = jQuery(this),
+            rename = field.parent().find('.rename-view'),
+            global = field.parent().find('.global-view'),
+            global_hidden = global.find('input[type=hidden]'),
+            global_cb = global.find('input[type=checkbox]'),
+            rename_cb = rename.find('input[type=checkbox]');
+        if (field.val().trim()) global.show();
+        else global.hide();
+        if (field.val() !== field.attr('value')) {
+            rename.show();
+            global_hidden.prop('disabled', rename_cb.length ? !rename_cb.prop('checked') : true);
+            global_cb.prop('disabled', rename_cb.length ? rename_cb.prop('checked') : false);
+        } else {
+            rename.hide();
+            rename_cb.prop('checked', false);
+            global_hidden.prop('disabled', false);
+            global_cb.prop('disabled', true);
+            global_cb.prop('checked', global_hidden.val() === '1');
+        }
+    });
+    jQuery(document).on('change', '.show_config_list-view .rename-view input[type=checkbox]', function () {
+        var rename_cb = jQuery(this),
+            global = rename_cb.closest('.form-element').find('.global-view'),
+            global_hidden = global.find('input[type=hidden]'),
+            global_cb = global.find('input[type=checkbox]');
+        global_hidden.prop('disabled', !rename_cb.prop('checked'));
+        global_cb.prop('disabled', rename_cb.prop('checked'));
+        if (global_cb.prop('disabled')) global_cb.prop('checked', global_hidden.val() === '1');
+    });
+});

data/app/assets/stylesheets/active_scaffold_config_list.scss

@@ -0,0 +1,66 @@
+.active-scaffold-header {
+  display: flex;
+  justify-content: space-between;
+
+  > .actions {
+    order: 1;
+  }
+
+  > h2 {
+    flex-grow: 1;
+    &:has(~ .config-list-views.left) {
+      flex-grow: 0;
+    }
+  }
+
+  > .config-list-views {
+    &.left {
+      flex-grow: 1;
+      margin-left: 1em;
+    }
+    &.right {
+      order: 2
+    }
+    display: flex;
+    gap: 10px;
+
+    input[type=radio] {
+      margin-right: 5px;
+    }
+
+    &:has(.views) {
+      position: relative;
+      > .selected-view, a {
+        display: block;
+        padding: 8px 12px;
+        white-space: nowrap;
+        text-decoration: none;
+        color: #333;
+      }
+      .selected a {
+        color: #06c;
+      }
+      a:hover {
+        text-decoration: underline;
+      }
+
+      > .views {
+        list-style: none;
+        padding: 0;
+        margin: 0;
+        border: 1px solid #ccc;
+        display: none;
+        background: white;
+      }
+      &:hover {
+        > .views {
+          display: block;
+          position: absolute;
+          top: 0;
+          left: 0;
+          z-index: 1;
+        }
+      }
+    }
+  }
+}

data/app/views/active_scaffold_overrides/_list_header.html.erb

@@ -0,0 +1,2 @@
+<%= render :super %>
+<%= render 'named_views' if config_list_named_views? %>

data/app/views/active_scaffold_overrides/_named_views.html.erb

@@ -0,0 +1,14 @@
+<%
+  attributes = {class: "config-list-views #{active_scaffold_config.config_list.named_views_position}"}
+  if active_scaffold_config.config_list.named_views_selector == :links
+    method = :content_tag
+    arg = :div
+  else
+    method = :form_tag
+    arg = params_for(action: :index, config_list_view: nil)
+    attributes.merge! remote: true, method: :get
+  end
+%>
+<%= send(method, arg, attributes) do %>
+  <%= active_scaffold_named_view_selector %>
+<% end %>

data/app/views/active_scaffold_overrides/_show_config_list_form.html.erb

@@ -1,16 +1,16 @@
-<% url_options = params_for(action: :index, escape: false, config_list: nil) -%>
+<% url_options = params_for(action: :config_list) -%>
 <%=
 options = {id: element_form_id(action: :config_list),
            class: "as_form config_list",
            remote: request.xhr?,
-           method: :get,
+           method: :post,
            'data-loading' => true}
 form_tag url_options, options %>
   <h4><%= active_scaffold_config.config_list.label -%></h4>
   <%= render 'show_config_list_form_body' %>
   <p class="form-footer">
     <%= submit_tag as_(:config_list), class: "submit" %>
-    <%= link_to as_(:reset), url_for(url_options.merge(config_list: '')), class: 'as_cancel', remote: true, data: {refresh: true} %>
+    <%= link_to as_(params[:config_list_view].present? ? :delete : :reset), url_for(url_options.merge(config_list: '')), class: 'as_cancel', remote: true, data: {refresh: true, method: :post} %>
     <%= loading_indicator_tag(action: :config_list) %>
   </p>
 </form>

data/app/views/active_scaffold_overrides/_show_config_list_form_body.html.erb

@@ -3,15 +3,18 @@
   <li class="form-element">
     <dl><dt><label><%= as_ :columns %></label></dt>
     <dd>
-      <%= active_scaffold_check_all_buttons(nil, {}, ui_options: {}) if respond_to? :active_scaffold_check_all_buttons %>
-      <ul class="<%= active_scaffold_config.config_list.draggable ? 'checkbox-list draggable-lists' : 'sortable-container' %>" id="<%= element_form_id(action: :config_list) %>-columns">
-<% config_list_columns.each do |label, column| %>
-      <li class="sortable">
-        <%= check_box_tag 'config_list[]', column.to_s, (config_list_params.nil? ? true : config_list_params.include?(column)), {id: nil}%>
-        <label><%= label %></label>
-      </li>
-<% end %>
-    </ul></dd></dl>
+      <%= active_scaffold_checkbox_list(
+            nil,
+            config_list_columns,
+            config_list_params || config_list_columns.map(&:last),
+            {
+              name: 'config_list',
+              id: "#{element_form_id(action: :config_list)}-columns",
+              class: ('sortable-container' unless active_scaffold_config.config_list.draggable)
+            },
+            ui_options: {draggable_lists: active_scaffold_config.config_list.draggable, item_options: {class: 'sortable'}}
+          ) %>
+    </dd></dl>
   </li>
   <% end %>
   <% if config_list_sorting? %>
@@ -30,4 +33,26 @@
     </ol></dd></dl>
   </li>
   <% end %>
+
+  <% if config_list_save_named_views? %>
+    <li class="form-element">
+      <dl><dt><label><%= as_ :view_name %></label></dt>
+        <dd>
+          <%= text_field_tag "config_list_view_name", @config_list_view_name.to_s, active_scaffold_input_text_options.merge(required: @config_list_view_name.present?) %>
+          <% if @config_list_view_name.present? %>
+            <label class="rename-view" style="display: none;">
+              <input type="checkbox" name="config_list_old_view_name" value="<%= params[:config_list_view] %>" />
+              <%= as_ :rename_view, view_name: @config_list_view_name %>
+            </label>
+          <% end %>
+          <% if config_list_global_views? %>
+            <%= content_tag :label, class: 'global-view', style: ('display: none;' if @config_list_view_name.blank?) do %>
+              <%= hidden_field_tag 'global_view', @global_view ? '1' : '' %>
+              <%= check_box_tag 'global_view', '1', @global_view, id: nil, disabled: true %>
+              <%= as_ :global_view %>
+            <% end %>
+          <% end %>
+        </dd></dl>
+    </li>
+  <% end %>
 </ol>

data/config/locales/de.yml

@@ -5,4 +5,8 @@ de:
     config_list_model: "Konfiguriere Spalten für %{model}"
     columns: Columns
     default_sorting: Default Sorting
+    default_view: Default
     desc: desc
+    global_view: Global view
+    rename_view: 'Rename the view "%{view_name}"'
+    view_name: View Name

data/config/locales/en.yml

@@ -5,4 +5,8 @@ en:
     config_list_model: "Configure Columns for %{model}"
     columns: Columns
     default_sorting: Default Sorting
+    default_view: Default
     desc: desc
+    global_view: Global view
+    rename_view: 'Rename the view "%{view_name}"'
+    view_name: View Name

data/config/locales/es.yml

@@ -5,4 +5,8 @@ es:
     config_list_model: "Configurar columnas de %{model}"
     columns: Columnas
     default_sorting: Orden por defecto
+    default_view: Por defecto
     desc: desc
+    global_view: Vista global
+    rename_view: 'Renombrar la vista "%{view_name}"'
+    view_name: Nombre de vista

data/config/locales/fr.yml

@@ -5,4 +5,8 @@ fr:
     config_list_model: "Configurer les colonnes pour %{model}"
     columns: Columns
     default_sorting: Default Sorting
+    default_view: Default
     desc: desc
+    global_view: Global view
+    rename_view: 'Rename the view "%{view_name}"'
+    view_name: View Name

data/config/locales/hu.yml

@@ -5,4 +5,8 @@ hu:
     config_list_model: "Configure Columns for %{model}"
     columns: Columns
     default_sorting: Default Sorting
+    default_view: Default
     desc: desc
+    global_view: Global view
+    rename_view: 'Rename the view "%{view_name}"'
+    view_name: View Name

data/config/locales/ja.yml

@@ -5,4 +5,8 @@ ja:
     config_list_model: "Configure Columns for %{model}"
     columns: Columns
     default_sorting: Default Sorting
+    default_view: Default
     desc: desc
+    global_view: Global view
+    rename_view: 'Rename the view "%{view_name}"'
+    view_name: View Name

data/config/locales/ru.yml

@@ -5,4 +5,8 @@ ru:
     config_list_model: "%{model}: настройки списка"
     columns: Columns
     default_sorting: Default Sorting
+    default_view: Default
     desc: desc
+    global_view: Global view
+    rename_view: 'Rename the view "%{view_name}"'
+    view_name: View Name

data/lib/active_scaffold/actions/config_list.rb

@@ -2,22 +2,58 @@ module ActiveScaffold::Actions
   module ConfigList
     
     def self.included(base)
-      base.before_action :store_config_list_params, :set_default_sorting, only: [:index]
-      base.helper_method :config_list_params, :config_list_sorting
+      base.before_action :set_default_sorting, :change_view, only: [:index]
+      base.before_action :config_list_authorized_filter, only: [:show_config_list, :config_list]
+      base.helper_method :config_list_params, :config_list_sorting, :config_list_named_views
     end
 
     def show_config_list
-      respond_to do |type|
-        type.html do
-          render(action: 'show_config_list_form', layout: true)
-        end
-        type.js do
-          render(partial: 'show_config_list_form', layout: false)
-        end
+      config_list_record
+      @config_list_view_name = find_view_name(params[:config_list_view])
+      if @config_list_view_name.present?
+        @global_view = config_list_slug(@config_list_view_name, true) == params[:config_list_view]
       end
+      respond_to_action(:show_config_list, config_list_formats)
+    end
+
+    def config_list
+      do_config_list
+      respond_to_action(:config_list, config_list_formats)
     end
     
     protected
+
+    def change_view
+      active_scaffold_config.list.refresh_with_header = true if params[:config_list_view]
+    end
+
+    def config_list_formats
+      [:html, :js]
+    end
+
+    def show_config_list_respond_to_html
+      render(action: 'show_config_list_form', layout: true)
+    end
+
+    def show_config_list_respond_to_js
+      render(partial: 'show_config_list_form', layout: false)
+    end
+
+    def config_list_respond_to_html
+      redirect_to action: :index, config_list_view: params[:config_list_view_name]
+    end
+
+    def do_refresh_list
+      set_default_sorting
+      super
+    end
+
+    def config_list_respond_to_js
+      do_refresh_list
+      active_scaffold_config.list.refresh_with_header = true
+      list_url = params_for(action: :index, config_list_view: params[:config_list_view].presence)
+      render partial: 'refresh_list', locals: {history_url: url_for(list_url)}, formats: [:js]
+    end
     
     def set_default_sorting
       if (params['sort_direction'] && params['sort_direction'] == 'reset') || (active_scaffold_config.list.user['sort'].blank? && params['sort'].blank?)
@@ -25,15 +61,13 @@ module ActiveScaffold::Actions
       end
     end
 
-    def store_config_list_params
-      if params[:config_list]
-        config_list = params.delete :config_list
-        case config_list
-        when String
-          delete_config_list_params
-        when Array
-          save_config_list_params(config_list, config_list_sorting_params)
-        end
+    def do_config_list
+      config_list = params.delete :config_list
+      case config_list
+      when String
+        delete_config_list_params(params.delete(:config_list_view).presence)
+      when Array
+        save_config_list_params(config_list, config_list_sorting_params, params.delete(:config_list_view_name).presence, params.delete(:config_list_old_view_name))
       end
     end
     
@@ -70,9 +104,13 @@ module ActiveScaffold::Actions
       @active_scaffold_current_user ||= send(self.class.active_scaffold_config.class.security.current_user_method)
     end
 
-    def delete_config_list_params
-      if active_scaffold_config.config_list.save_to_user && active_scaffold_current_user
-        active_scaffold_current_user.send(active_scaffold_config.config_list.save_to_user, config_list_session_storage_key, config_list_controller_name).destroy
+    def delete_config_list_params(view_name)
+      record = config_list_record(view_name)
+      if record
+        if record.destroy && view_name.present?
+          config_list_record(reload: true)
+          return
+        end
       else
         config_list_session_storage['config_list'] = nil
         config_list_session_storage['config_list_sorting'] = nil
@@ -82,12 +120,17 @@ module ActiveScaffold::Actions
       @config_list_sorting = nil
     end
 
-    def save_config_list_params(config_list, config_list_sorting)
-      if active_scaffold_config.config_list.save_to_user && active_scaffold_current_user
-        record = active_scaffold_current_user.send(active_scaffold_config.config_list.save_to_user, config_list_session_storage_key, config_list_controller_name)
-        record.config_list = config_list.join(',')
+    def save_config_list_params(config_list, config_list_sorting, view_name, old_view_name)
+      if view_name.present?
+        assign = {view_name: view_name}
+        assign[:slug] = config_list_slug(view_name, params.delete(:global_view).present?) if active_scaffold_config.config_list.global_views
+      end
+      record = config_list_record(old_view_name || assign&.dig(:slug) || view_name, assign: assign)
+
+      if record
+        record.config_list = config_list.select(&:present?).join(',')
         record.config_list_sorting = config_list_sorting if record.respond_to? :config_list_sorting
-        record.save
+        params[:config_list_view] = assign&.dig(:slug) || view_name if record.save
       else
         config_list_session_storage['config_list'] = config_list.map(&:to_sym)
         config_list_session_storage['config_list_sorting'] = config_list_sorting
@@ -111,14 +154,52 @@ module ActiveScaffold::Actions
       end
     end
 
-    def config_list_record
-      return @config_list_record if defined? @config_list_record
+    def config_list_record(view_name = params[:config_list_view], reload: false, assign: nil)
+      return @config_list_record if !reload && defined?(@config_list_record)
       @config_list_record =
         if active_scaffold_config.config_list.save_to_user && active_scaffold_current_user
-          active_scaffold_current_user.send(active_scaffold_config.config_list.save_to_user, config_list_session_storage_key, config_list_controller_name)
+          if view_name.present?
+            options = {attributes: assign}
+            options[active_scaffold_config.config_list.global_views ? :slug : :view_name] = view_name
+          end
+          active_scaffold_current_user.send(
+            active_scaffold_config.config_list.save_to_user,
+            config_list_session_storage_key,
+            config_list_controller_name,
+            **options
+          )
         end
     end
 
+    def find_view_name(slug)
+      return unless slug.present?
+
+      config_list_named_views.find do |view_name, view_slug|
+        break view_name if slug == (view_slug || view_name)
+      end
+    end
+
+    def config_list_slug(view_name, global_view)
+      return view_name unless active_scaffold_config.config_list.global_views
+
+      if ActiveScaffold::Config::ConfigList.slug_builder
+        send(ActiveScaffold::Config::ConfigList.slug_builder, view_name, global_view)
+      elsif global_view
+        "global-#{view_name}"
+      else
+        "user-#{view_name}"
+      end
+    end
+
+    def config_list_named_views
+      @config_list_named_views ||=
+        active_scaffold_current_user.send(
+          active_scaffold_config.config_list.named_views_method,
+          config_list_session_storage_key,
+          config_list_controller_name
+        ).compact
+    end
+
     def config_list_params
       unless defined? @config_list_params
         @config_list_params =
@@ -139,7 +220,9 @@ module ActiveScaffold::Actions
     def config_list_sorting
       unless defined? @config_list_sorting
         @config_list_sorting =
-          if config_list_record
+          if named_view
+            named_view.sorting
+          elsif config_list_record
             config_list_record.config_list_sorting if config_list_record.respond_to? :config_list_sorting
           else
             config_list_session_storage['config_list_sorting']
@@ -149,7 +232,7 @@ module ActiveScaffold::Actions
     end
 
     def list_columns
-      @list_columns ||= begin
+      @list_columns ||= named_view_columns || begin
         columns = super
         if config_list_params.present?
           config_list = config_list_params.each.with_index.to_h
@@ -164,7 +247,24 @@ module ActiveScaffold::Actions
     # The default security delegates to ActiveRecordPermissions.
     # You may override the method to customize.
     def config_list_authorized?
-      authorized_for?(action: :read)
+      named_view.nil? && authorized_for?(action: :read)
+    end
+
+    def named_view
+      return unless params[:config_list_view].present?
+
+      @named_view ||= active_scaffold_config.config_list.named_views.find { |v| v.name == params[:config_list_view] }
+    end
+
+    def named_view_columns
+      return unless named_view
+
+      raise ActiveScaffold::ActionNotAllowed if named_view.security_method && !send(named_view.security_method)
+      named_view.columns.visible_columns(flatten: true)
+    end
+
+    def config_list_authorized_filter
+      raise ActiveScaffold::ActionNotAllowed unless config_list_authorized?
     end
   end
 end

data/lib/active_scaffold/config/config_list.rb

@@ -5,7 +5,12 @@ module ActiveScaffold::Config
       super
       @link = self.class.link.clone unless self.class.link.nil?
       @save_to_user = self.class.save_to_user
+      @named_views_method = self.class.named_views_method
       @draggable = self.class.draggable
+      @named_views_position = self.class.named_views_position
+      @named_views_selector = self.class.named_views_selector
+      @global_views = self.class.global_views
+      @named_views = []
     end
 
     # global level configuration
@@ -26,6 +31,29 @@ module ActiveScaffold::Config
     # configures the method in user model to save list configuration for every controller
     cattr_accessor :save_to_user
 
+    # configures the method in user model to return the named views saved for the user,
+    # setting it enables saving the views, but requires to set a method in save_to_user
+    cattr_accessor :named_views_method
+
+    # the position to place the named views selector, :left (next to the title),
+    # :right or :center (default, before the actions and filters)
+    cattr_accessor :named_views_position
+    @@named_views_position = :center
+
+    # the type of selector for named views, :links, :select or :radio
+    cattr_accessor :named_views_selector
+    @@named_views_selector = :links
+
+    # if saving global views is allowed, or named views are always saved for the current user only
+    cattr_accessor :global_views
+
+    # Configures the method to convert a view name to slug, used only when global views are enabled
+    # Slugs are needed when global views are enabled, to ensure the name in the params is unique
+    # although a user view has the same name as a global view
+    # By default is generated with the prefixes global- and user-, but a different method can be setup here
+    # so it can be defined in ApplicationController
+    cattr_accessor :slug_builder
+
     # enable draggable lists to select displayed columns (enabled by default)
     cattr_accessor :draggable
     self.draggable = true
@@ -44,6 +72,23 @@ module ActiveScaffold::Config
     # configures the method in user model to save list configuration for every controller
     attr_accessor :save_to_user
 
+    # configures the method in user model to return the named views saved for the user,
+    # setting it enables saving the views, but requires to set a method in save_to_user
+    attr_accessor :named_views_method
+
+    # the position to place the named views selector, :left (next to the title),
+    # :right or :center (default, before the actions and filters)
+    attr_accessor :named_views_position
+
+    # the type of selector for named views, :links, :select or :radio
+    attr_accessor :named_views_selector
+
+    # if saving global views is allowed, or named views are always saved for the current user only
+    attr_accessor :global_views
+
+    # generic named views
+    attr_reader :named_views
+
     # enable draggable lists to select displayed columns
     attr_accessor :draggable
 
@@ -52,12 +97,24 @@ module ActiveScaffold::Config
       columns.exclude :created_on, :created_at, :updated_on, :updated_at, :as_marked
       columns.exclude *@core.columns.select{|c| c.association.try(:polymorphic?)}.map(&:name)
     end
-    
+
     # the ActionLink for this action
     attr_accessor :link
 
+    def add_view(name, columns = nil, &)
+      raise ArgumentError, "view '#{name}' already exists" if @named_views.find { |v| v.name == name }
+      view = ::ActiveScaffold::DataStructures::NamedView.new(name, self)
+      view.columns = columns if columns
+      yield view if block_given?
+      raise ArgumentError, "no columns defined for view '#{name}'" if view.columns.empty?
+
+      @named_views << view
+      view
+    end
+
     UserSettings.class_eval do
-      user_attr :default_columns, :save_to_user, :draggable
+      user_attr :default_columns, :save_to_user, :named_views_method, :draggable,
+                :named_views_position, :named_views_selector, :global_views
 
       def label
         @conf.label(core: core)

data/lib/active_scaffold/data_structures/named_view.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveScaffold::DataStructures
+  class NamedView
+    # the internal name of the view
+    attr_reader :name
+
+    # the label displayed to the user, if it's a symbol will be translated with as_
+    attr_writer :label
+
+    # the method used to check permissions, if returns true, the list view is allowed
+    attr_accessor :security_method
+
+    # the columns in the named view
+    attr_reader :columns
+
+    # default sorting used with this view instead of default
+    attr_accessor :sorting
+
+    def initialize(name, action)
+      @name = name.to_s
+      @action = action
+      @label = name
+    end
+
+    # the label displayed to the user
+    def label
+      case @label
+      when Symbol
+        ActiveScaffold::Registry.cache(:translations, @label) { as_(@label) }
+      else
+        @label
+      end
+    end
+
+    def columns=(columns)
+      @columns = ActionColumns.new(columns).tap { |cols| cols.action = @action }
+    end
+  end
+end

data/lib/active_scaffold/helpers/config_list_helpers.rb

@@ -9,6 +9,22 @@ module ActiveScaffold
         true
       end
 
+      def config_list_save_named_views?
+        active_scaffold_config.config_list.named_views_method.present?
+      end
+
+      def config_list_named_views?
+        return unless active_scaffold_config.actions.include? :config_list
+
+        config_list_save_named_views? || active_scaffold_config.config_list.named_views.present?
+      end
+
+      def config_list_global_views?
+        return unless active_scaffold_config.actions.include? :config_list
+
+        config_list_save_named_views? && active_scaffold_config.config_list.global_views
+      end
+
       def config_list_columns
         columns =
           if config_list_params.is_a?(Array)
@@ -19,6 +35,57 @@ module ActiveScaffold
           end
         columns.map { |c| [column_heading_label(c), c.name] }
       end
+
+      def user_named_views
+        return [] unless config_list_save_named_views?
+        config_list_named_views
+      end
+
+      def named_views_from_config
+        active_scaffold_config.config_list.named_views.filter_map do |view|
+          next if view.security_method && !controller.send(view.security_method)
+          [view.label, view.name]
+        end
+      end
+
+      def active_scaffold_named_view_selector
+        named_views = user_named_views + named_views_from_config
+        return unless named_views.any?
+
+        named_views.unshift [as_(:default_view), '']
+        html = config_list_view_options(named_views, params[:config_list_view].to_s)
+        if active_scaffold_config.config_list.named_views_selector == :select
+          html = select_tag('config_list_view', html, id: nil)
+        end
+        html
+      end
+
+      def config_list_view_options(named_views, selected)
+        case active_scaffold_config.config_list.named_views_selector
+        when :links
+          url = url_for(params_for(action: :index, config_list_view: '--VIEW--'))
+          view = nil
+          links = named_views.map do |(label, name)|
+            name ||= label
+            link = link_to(label, url.sub('--VIEW--', ERB::Util.unwrapped_html_escape(name)), remote: true)
+            view = label if name == selected
+            content_tag :li, link, class: ('selected' if name == selected)
+          end
+          content_tag(:div, view || as_(:default_view), class: 'selected-view') + content_tag(:ul, safe_join(links), class: 'views')
+
+        when :select
+          options_for_select(named_views, selected)
+
+        when :radio
+          buttons = named_views.map do |(label, name)|
+            name ||= label
+            content_tag(:label) do
+              radio_button_tag('config_list_view', name, name == selected, id: nil) + label
+            end
+          end
+          safe_join(buttons)
+        end
+      end
     end
   end
 end

data/lib/active_scaffold_config_list/config_listable.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ActiveScaffoldConfigList
+  # app/models/concerns/config_listable.rb
+  module ConfigListable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def has_config_lists(model_name,
+                           association_name: :list_configurations,
+                           association_options: {},
+                           view_name_column: :view_name,
+                           slug_column: :slug,
+                           controller_column: :controller_id,
+                           controller_matcher: :controller_name)
+        # Define the association
+        class_eval do
+          has_many association_name, class_name: model_name, **association_options
+        end
+
+        model_class = model_name.to_s.classify.constantize
+        view_name_column = nil unless model_class.column_names.include?(view_name_column.to_s)
+        slug_column = nil unless model_class.column_names.include?(slug_column.to_s)
+
+        self.config_list_settings = {
+          association_name: association_name,
+          model_name: model_name,
+          view_name_column: view_name_column,
+          slug_column: slug_column,
+          controller_column: controller_column,
+          model_class: model_class,
+          foreign_key: reflect_on_association(association_name).foreign_key,
+          controller_matcher: controller_matcher
+        }.freeze
+
+        # Include instance methods
+        include ConfigListable::InstanceMethods unless included_modules.include?(ConfigListable::InstanceMethods)
+      end
+    end
+
+    included do
+      class_attribute :config_list_settings, instance_writer: false, default: nil
+    end
+
+    module InstanceMethods
+      def config_list_for(controller_id, controller_name, view_name: nil, slug: nil, attributes: nil)
+        settings = self.class.config_list_settings
+        query = list_configurations_query(controller_id, controller_name, user_views: slug.nil? || slug.to_s.start_with?('user-'))
+
+        if slug
+          query = query.where(settings[:slug_column] => slug)
+        elsif view_name
+          query = query.where(settings[:view_name_column] => view_name)
+        else
+          column = settings[:slug_column] || settings[:view_name_column]
+          query = query.where(column => nil) if column
+        end
+
+        query.first_or_initialize.tap do |record|
+          record.attributes = map_attribute_names(attributes, settings) if attributes
+        end
+      end
+
+      def config_list_views(controller_id, controller_name)
+        settings = self.class.config_list_settings
+        list_configurations_query(controller_id, controller_name)
+          .where.not(settings[:view_name_column] => nil)
+          .pluck([settings[:view_name_column], settings[:slug_column]].compact)
+      end
+
+      private
+
+      def determine_controller_value(controller_id, controller_name, settings)
+        matcher = settings[:controller_matcher]
+
+        case matcher
+        when :controller_id
+          {settings[:controller_column] => controller_id}
+        else
+          # Default to controller_id if matcher is a callable
+          if matcher.respond_to?(:call)
+            matcher.call(controller_id, controller_name)
+          else
+            # Fallback to controller_name
+            {settings[:controller_column] => controller_name}
+          end
+        end
+      end
+
+      def list_configurations_query(controller_id, controller_name, user_views: false)
+        settings = self.class.config_list_settings
+        query = send(settings[:association_name])
+        # Add the OR condition if user_views is false
+        query = settings[:model_class].where(settings[:foreign_key] => nil).or(query) unless user_views
+        query.where(determine_controller_value(controller_id, controller_name, settings))
+      end
+
+      def map_attribute_names(attributes, settings)
+        return attributes unless attributes.is_a?(Hash)
+
+        attributes.symbolize_keys.transform_keys do |key|
+          case key
+          when :view_name then settings[:view_name_column]
+          when :slug then settings[:slug_column]
+          else
+            key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_scaffold_config_list/engine.rb

@@ -1,8 +1,10 @@
+require 'active_scaffold_config_list/config_listable'
 module ActiveScaffoldConfigList
   class Engine < ::Rails::Engine
     initializer 'active_scaffold_config_list.routes' do
       ActiveSupport.on_load :active_scaffold_routing do
         self::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection][:show_config_list] = :get
+        self::ACTIVE_SCAFFOLD_CORE_ROUTING[:collection][:config_list] = :post
       end
     end
 
@@ -11,5 +13,11 @@ module ActiveScaffoldConfigList
         ActionView::Base.send :include, ActiveScaffold::Helpers::ConfigListHelpers
       end
     end
+
+    initializer 'active_scaffold_config_list.active_record' do |app|
+      ActiveSupport.on_load :active_record do
+        include ActiveScaffoldConfigList::ConfigListable
+      end
+    end
   end
 end

data/lib/active_scaffold_config_list/version.rb

@@ -1,8 +1,8 @@
 module ActiveScaffoldConfigList
   module Version
-    MAJOR = 3
-    MINOR = 6
-    PATCH = 3
+    MAJOR = 4
+    MINOR = 0
+    PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/lib/active_scaffold_config_list.rb

@@ -10,8 +10,14 @@ module ActiveScaffold
     ActiveScaffold.autoload_subdir('config', self, File.dirname(__FILE__))
   end
 
+  module DataStructures
+    ActiveScaffold.autoload_subdir('data_structures', self, File.dirname(__FILE__))
+  end
+
   module Helpers
     ActiveScaffold.autoload_subdir('helpers', self, File.dirname(__FILE__))
   end
 end
-ActiveSupport.run_load_hooks(:active_scaffold_config_list)
+ActiveSupport.run_load_hooks(:active_scaffold_config_list)
+ActiveScaffold.stylesheets << 'active_scaffold_config_list'
+ActiveScaffold.javascripts << 'active_scaffold_config_list'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_scaffold_config_list
 version: !ruby/object:Gem::Version
-  version: 3.6.3
+  version: 4.0.0
 platform: ruby
 authors:
 - Sergio Cambra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-02 00:00:00.000000000 Z
+date: 2026-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_scaffold
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.7.1
+        version: 4.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.7.1
+        version: 4.2.0
 - !ruby/object:Gem::Dependency
   name: active_scaffold_sortable
   requirement: !ruby/object:Gem::Requirement
@@ -47,6 +47,10 @@ extra_rdoc_files:
 files:
 - LICENSE.txt
 - README.md
+- app/assets/javascripts/active_scaffold_config_list.js
+- app/assets/stylesheets/active_scaffold_config_list.scss
+- app/views/active_scaffold_overrides/_list_header.html.erb
+- app/views/active_scaffold_overrides/_named_views.html.erb
 - app/views/active_scaffold_overrides/_show_config_list_form.html.erb
 - app/views/active_scaffold_overrides/_show_config_list_form_body.html.erb
 - app/views/active_scaffold_overrides/show_config_list_form.html.erb
@@ -59,8 +63,10 @@ files:
 - config/locales/ru.yml
 - lib/active_scaffold/actions/config_list.rb
 - lib/active_scaffold/config/config_list.rb
+- lib/active_scaffold/data_structures/named_view.rb
 - lib/active_scaffold/helpers/config_list_helpers.rb
 - lib/active_scaffold_config_list.rb
+- lib/active_scaffold_config_list/config_listable.rb
 - lib/active_scaffold_config_list/engine.rb
 - lib/active_scaffold_config_list/version.rb
 homepage: http://activescaffold.com