rails_admin_next 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 957743cf70d6fa24bb0cb1eaf74ca15b4a3b2996e0dca4f5dcee2d6428985d6b
-  data.tar.gz: a205770a7170c2b1ce7e04a85cd6422f6cda1d150da237df81795387af8cc18d
+  metadata.gz: 79af82d2ebf188875574650be98cd21e394a1a324b887cc45518d49f9fa3ec41
+  data.tar.gz: 3a1d0d3b539034bc59e0019b1d56ff5dd3420285ea91a73ab193533de5f26c53
 SHA512:
-  metadata.gz: ad848e8080f75c1e3d6b12c180dcb745bb4a3caea7791ee08d4fec1d97567836effacf01ea340a764b0febb4a52c345e793b3d1708d7496e9d1c2e3f6a167f6d
-  data.tar.gz: 37ec4a516104eb2ecc4d8924c758ad862b8fa091f32a0d460b0dfda2f8bc566a233fa61ea81d6cdbbfe49695b1d71eb0aed55f75c281001e9d86a73821fbe8a8
+  metadata.gz: c20bd5d419f98867c7f2528ccf8139e5e09618ee13d4d982457fc983905c41d79b60d04c46971021531ccbc9607ceaace4ddd99072242c6003187c8e656a09f5
+  data.tar.gz: 3c06806088cbb19f949301c5150eba329392eccde2ee96128c3fb9a8ac23b3639418d358d4074ea59f1995aa186a9a399e17b86374c280953fb526b2ff1deb48

data/app/assets/stylesheets/rails_admin/skin.css

@@ -430,6 +430,10 @@ body.rails_admin #filters_box {
     display: none;
   }
 }
+body.rails_admin .dashboard-statistics {
+  overflow-x: auto;
+  overscroll-behavior: contain;
+}
 body.rails_admin #sidescroll {
   margin-bottom: 20px;
   overflow-x: auto;

data/app/controllers/rails_admin_next/main_controller.rb

@@ -8,19 +8,35 @@ module RailsAdminNext
 
     before_action :check_for_cancel
 
+    helper_method :list_scopes
+
     def bulk_action
       get_model
       process(params[:bulk_action]) if params[:bulk_action].in?(RailsAdminNext::Config::Actions.all(:bulkable, controller: self, abstract_model: @abstract_model).collect(&:route_fragment))
     end
 
-    def list_entries(model_config = @model_config, auth_scope_key = :index, additional_scope = get_association_scope_from_params, pagination = !(params[:associated_collection] || params[:all] || params[:bulk_ids]))
+    def list_entries(model_config = @model_config, auth_scope_key = :index, additional_scope = nil, pagination = !(params[:all] || params[:bulk_ids]))
       scope = model_config.scope
       auth_scope = @authorization_adapter&.query(auth_scope_key, model_config.abstract_model)
       scope = scope.merge(auth_scope) if auth_scope
+      tab = list_scope if model_config == @model_config
+      if tab
+        scope = scope.public_send(tab)
+        scope = within_authorized(scope, auth_scope) if auth_scope
+      end
       scope = scope.instance_eval(&additional_scope) if additional_scope
       get_collection(model_config, scope, pagination)
     end
 
+    # The association scope chains after get_collection, which only works on an unpaginated relation.
+    def association_entries(model_config, collection_scope)
+      scope = model_config.scope
+      auth_scope = @authorization_adapter&.query(:index, model_config.abstract_model)
+      scope = scope.merge(auth_scope) if auth_scope
+      scope = get_collection(model_config, scope, false)
+      collection_scope ? scope.instance_eval(&collection_scope) : scope
+    end
+
     private
 
     def action_missing(name, *_args)
@@ -78,9 +94,7 @@ module RailsAdminNext
     end
 
     def get_sort_hash(model_config)
-      field = model_config.list.fields.detect { |f| f.name.to_s == params[:sort] }
-      # If no sort param, default to the `sort_by` specified in the list config
-      field ||= model_config.list.possible_fields.detect { |f| f.name == model_config.list.sort_by.try(:to_sym) }
+      field = sort_field(model_config)
 
       column =
         if field.nil? || field.sortable == false # use default sort, asked field does not exist or is not sortable
@@ -93,6 +107,12 @@ module RailsAdminNext
       {sort: column, sort_reverse: (params[:sort_reverse] == (field&.sort_reverse&.to_s || "true"))}
     end
 
+    def sort_field(model_config)
+      field = model_config.list.fields.detect { |f| f.name.to_s == params[:sort] }
+      # If no sort param, default to the `sort_by` specified in the list config
+      field || model_config.list.possible_fields.detect { |f| f.name == model_config.list.sort_by.try(:to_sym) }
+    end
+
     def redirect_to_on_success
       notice = I18n.t("admin.flash.successful", name: @model_config.label, action: I18n.t("admin.actions.#{@action.key}.done"))
       if params[:_add_another]
@@ -178,7 +198,8 @@ module RailsAdminNext
 
     def get_collection(model_config, scope, pagination)
       section = (@action.key == :export) ? model_config.export : model_config.list
-      eager_loads = section.fields.flat_map(&:eager_load_values)
+      # The sort comes from the list, so export must also load the association a list sort orders by.
+      eager_loads = (section.fields + Array(sort_field(model_config))).flat_map(&:eager_load_values).uniq
       options = {}
       options = options.merge(page: (params[:page] || 1).to_i, per: params[:per] || model_config.list.items_per_page) if pagination
       options = options.merge(include: eager_loads) unless eager_loads.blank?
@@ -189,14 +210,39 @@ module RailsAdminNext
       model_config.abstract_model.all(options, scope)
     end
 
+    def list_scopes
+      @_list_scopes ||= @model_config.list.with(controller: self, view: view_context, object: @abstract_model.model.new).scopes
+    end
+
+    # A row-value IN: `where(primary_key => relation)` renders an empty condition for composite keys.
+    def within_authorized(scope, auth_scope)
+      key = Array(scope.primary_key).map { scope.arel_table[it] }
+      scope.where(Arel::Nodes::In.new(Arel::Nodes::Grouping.new(key), auth_scope.reselect(*key).arel.ast))
+    end
+
+    def list_scope
+      return if params[:compact]
+
+      if list_scopes.empty? || params[:scope].blank?
+        list_scopes.first
+      elsif list_scopes.collect(&:to_s).include?(params[:scope])
+        params[:scope].to_sym
+      end
+    end
+
     def get_association_scope_from_params
       return nil unless params[:associated_collection].present?
 
       source_abstract_model = RailsAdminNext::AbstractModel.new(to_model_name(params[:source_abstract_model]))
       source_model_config = source_abstract_model.config
-      source_object = source_abstract_model.get(params[:source_object_id])
       action = params[:current_action].in?(%w[create update]) ? params[:current_action] : "edit"
-      @association = source_model_config.send(action).fields.detect { |f| f.name == params[:associated_collection].to_sym }.with(controller: self, object: source_object)
+      field = source_model_config.send(action).fields.detect { |f| f.name == params[:associated_collection].to_sym }
+      # The picker's params are client-supplied; a field that doesn't target this model would run its scope and labels on the wrong records.
+      # Polymorphic pickers never send associated_collection, and their collection ignores the listed records.
+      return nil unless field&.association? && !field.polymorphic? && field.associated_model_config == @model_config
+
+      source_object = source_abstract_model.get(params[:source_object_id])
+      @association = field.with(controller: self, object: source_object)
       @association.associated_collection_scope
     end
   end

data/app/helpers/rails_admin_next/form_builder.rb

@@ -4,6 +4,10 @@ module RailsAdminNext
   class FormBuilder < ::ActionView::Helpers::FormBuilder
     include ::RailsAdminNext::ApplicationHelper
 
+    # Bounds the nested form of an association that can reach itself. Counting repeats of
+    # one association, rather than depth, leaves chains of distinct models uncapped.
+    MAX_NESTED_FORM_RECURSION = 3
+
     def generate(options = {})
       without_field_error_proc_added_div do
         options.reverse_merge!(
@@ -78,8 +82,10 @@ module RailsAdminNext
 
     # Wraps one nested-attributes subform (rendered by native `fields_for`) for
     # the nested-form Stimulus controller: a `.fields` container, an optional
-    # `_destroy` hidden field + remove button (gated on `allow_destroy`, always
-    # present in the blank <template>), then the recursively generated fields.
+    # `_destroy` hidden field (gated on `allow_destroy`, always present in the blank
+    # <template>), a remove button, then the recursively generated fields. A saved
+    # record is removable only under `allow_destroy`; an unsaved one always is, so a
+    # row added before a failed save can still be taken back.
     def nested_field_set(nested_form, field, allow_destroy:)
       @template.content_tag(:div, class: "fields tab-pane active", data: {"nested-form-target": "subform"}) do
         contents = []
@@ -88,8 +94,8 @@ module RailsAdminNext
         # persisted subform from a brand-new one. Suppress the auto-id in the
         # partials with `include_id: false` so it is not rendered twice.
         contents << nested_form.hidden_field(:id) if nested_form.object.persisted?
-        if allow_destroy
-          contents << nested_form.hidden_field(:_destroy, data: {"nested-form-target": "destroy"})
+        contents << nested_form.hidden_field(:_destroy, data: {"nested-form-target": "destroy"}) if allow_destroy
+        if allow_destroy || nested_form.object.new_record?
           contents << @template.content_tag(:button, RailsAdminNext::Icons.svg(:trash).html_safe, type: "button", class: "btn btn-danger remove_nested_fields", data: {action: "nested-form#remove"})
         end
         contents << nested_form.generate(action: :nested, model_config: field.associated_model_config, nested_in: field)
@@ -97,6 +103,19 @@ module RailsAdminNext
       end
     end
 
+    # Whether this association's subforms, its blank <template> and its add control render
+    # here. Saved records can form a cycle too, so the bound covers them as well.
+    def nested_within_bound?(field)
+      @object_name.to_s.scan("[#{field.name}_attributes]").size < MAX_NESTED_FORM_RECURSION
+    end
+
+    # The child index the <template> carries until a row is added. Tagged by depth, not by
+    # association name alone: the add control replaces every occurrence in the template,
+    # nested templates included, and a name-tagged token can be a prefix of a nested one's.
+    def nested_placeholder(field)
+      "new_#{@object_name.to_s.scan("_attributes]").size + 1}_#{field.name}"
+    end
+
     def object_infos
       model_config = RailsAdminNext.config(object)
       model_label = model_config.label

data/app/helpers/rails_admin_next/main_helper.rb

@@ -29,7 +29,7 @@ module RailsAdminNext
       return @ordered_filters if @ordered_filters.present?
 
       @index = 0
-      @ordered_filters = (params[:f].try(:permit!).try(:to_h) || @model_config.list.filters).each_with_object({}) do |filter, memo|
+      @ordered_filters = (filters_from_params || @model_config.list.filters).each_with_object({}) do |filter, memo|
         field_name = filter.is_a?(Array) ? filter.first : filter
         (filter.is_a?(Array) ? filter.last : {(@index += 1) => {"v" => ""}}).each do |index, filter_hash|
           if filter_hash["disabled"].blank?
@@ -41,6 +41,17 @@ module RailsAdminNext
       end.to_a.sort_by(&:first)
     end
 
+    # Only the field => index => filter shape the filter box submits, for fields that
+    # are filterable; hand-written or stale params are dropped rather than raising.
+    def filters_from_params
+      return unless params[:f].respond_to?(:permit!)
+
+      names = filterable_fields.map { it.name.to_s }
+      params[:f].permit!.to_h.filter_map do |name, filters_dump|
+        [name, filters_dump.select { |_index, filter| filter.is_a?(Hash) }] if names.include?(name) && filters_dump.is_a?(Hash)
+      end.to_h
+    end
+
     def ordered_filter_options
       if ordered_filters
         @ordered_filter_options ||= ordered_filters.map do |duplet|

data/app/views/layouts/rails_admin_next/_head.html.erb

@@ -1,7 +1,7 @@
 <%# locals: () -%>
 <meta content="IE=edge" http-equiv="X-UA-Compatible">
 <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
-<meta content="width=device-width, initial-scale=1" name="viewport; charset=utf-8">
+<meta content="width=device-width, initial-scale=1" name="viewport">
 <meta content="NONE,NOARCHIVE" name="robots">
 <meta content="false" name="turbo-prefetch">
 <%= csrf_meta_tag %>

data/app/views/layouts/rails_admin_next/_navigation.html.erb

@@ -7,7 +7,7 @@
     </small>
   </a>
   <button class="navbar-toggler" type="button" data-collapse-target="trigger" data-action="collapse#toggle" aria-expanded="false" aria-controls="secondary-navigation">
-    <span class="sr-only">
+    <span class="visually-hidden">
       <%= t('admin.toggle_navigation') %>
     </span>
     <span class="navbar-toggler-icon"></span>

data/app/views/rails_admin_next/main/_form_nested_many.html.erb

@@ -3,18 +3,23 @@
   associated_model = field.associated_model_config.abstract_model
   add_label = rails_admin_icon(:new) + " " + wording_for(:link, :new, associated_model)
   allow_destroy = field.nested_form && field.nested_form[:allow_destroy]
-  placeholder = "new_#{field.name}"
+  placeholder = form.nested_placeholder(field)
+  template = form.nested_within_bound?(field)
 -%>
 <div class="controls col-sm-10" data-controller="nested-form" data-nested-form-placeholder-value="<%= placeholder %>">
   <div class="tab-content" data-nested-form-target="container">
-    <%= form.fields_for field.name, nil, include_id: false do |nested_form| %>
-      <%= form.nested_field_set nested_form, field, allow_destroy: allow_destroy %>
+    <% if template %>
+      <%= form.fields_for field.name, nil, include_id: false do |nested_form| %>
+        <%= form.nested_field_set nested_form, field, allow_destroy: allow_destroy %>
+      <% end %>
     <% end %>
   </div>
-  <% if field.inline_add %>
+  <% if field.inline_add && template %>
     <button type="button" class="btn btn-info add_nested_fields" data-action="nested-form#add"><%= add_label %></button>
   <% end %>
   <%= form.errors_for(field) %>
   <%= form.help_for(field) %>
+  <% if template %>
   <template data-nested-form-target="template"><%= form.fields_for field.name, associated_model.model.new, child_index: placeholder, include_id: false do |nested_form| %><%= form.nested_field_set nested_form, field, allow_destroy: true %><% end %></template>
+  <% end %>
 </div>

data/app/views/rails_admin_next/main/_form_nested_one.html.erb

@@ -3,17 +3,22 @@
   associated_model = field.associated_model_config.abstract_model
   add_label = rails_admin_icon(:new) + " " + wording_for(:link, :new, associated_model)
   allow_destroy = field.nested_form && field.nested_form[:allow_destroy]
+  template = form.nested_within_bound?(field)
 -%>
 <div class="controls col-sm-10" data-controller="nested-form" data-nested-form-singular-value="true">
   <div class="tab-content" data-nested-form-target="container">
-    <%= form.fields_for field.name, nil, include_id: false do |nested_form| %>
-      <%= form.nested_field_set nested_form, field, allow_destroy: allow_destroy %>
+    <% if template %>
+      <%= form.fields_for field.name, nil, include_id: false do |nested_form| %>
+        <%= form.nested_field_set nested_form, field, allow_destroy: allow_destroy %>
+      <% end %>
     <% end %>
   </div>
-  <% if field.inline_add %>
+  <% if field.inline_add && template %>
     <button type="button" class="btn btn-info add_nested_fields" data-action="nested-form#add"><%= add_label %></button>
   <% end %>
   <%= form.errors_for(field) %>
   <%= form.help_for(field) %>
+  <% if template %>
   <template data-nested-form-target="template"><%= form.fields_for field.name, associated_model.model.new, include_id: false do |nested_form| %><%= form.nested_field_set nested_form, field, allow_destroy: true %><% end %></template>
+  <% end %>
 </div>

data/app/views/rails_admin_next/main/bulk_delete.html.erb

@@ -4,7 +4,7 @@
 <ul>
   <%= render partial: "delete_notice", collection: @objects %>
 </ul>
-<%= form_tag bulk_delete_path(model_name: @abstract_model.to_param, bulk_ids: @objects.map(&:id)), method: :delete do %>
+<%= form_tag bulk_delete_path(model_name: @abstract_model.to_param, bulk_ids: @objects.map(&:id), scope: params[:scope].presence), method: :delete do %>
   <div class="form-actions">
     <input name="return_to" type="<%= :hidden %>" value="<%= (params[:return_to].presence || request.referer) %>" />
     <button class="btn btn-danger" data-disable-with="<%= t("admin.form.confirmation") %>" data-turbo-confirm="<%= t("admin.form.bulk_delete") %>" type="submit">

data/app/views/rails_admin_next/main/dashboard.html.erb

@@ -1,56 +1,58 @@
 <% if @abstract_models %>
-  <table class="table table-condensed table-striped table-hover">
-    <thead>
-      <tr>
-        <th class="shrink model-name">
-          <%= t "admin.table_headers.model_name" %>
-        </th>
-        <th class="shrink last-created">
-          <%= t "admin.table_headers.last_created" %>
-        </th>
-        <th class="records">
-          <%= t "admin.table_headers.records" %>
-        </th>
-        <th class="shrink controls"></th>
-      </tr>
-    </thead>
-    <tbody class="table-group-divider">
-      <% @abstract_models.each do |abstract_model| %>
-        <% if authorized? :index, abstract_model %>
-          <% index_path = index_path(model_name: abstract_model.to_param) %>
-          <% row_class = "#{cycle("odd", "even")}#{" link" if index_path} #{abstract_model.param_key}_links" %>
-          <tr class="<%= row_class %>" data-link="<%= index_path %>">
-            <% last_created = @most_recent_created[abstract_model.model.name] %>
-            <% active = last_created.try(:today?) %>
-            <td>
-              <span class="show">
-                <%= link_to abstract_model.config.label_plural, index_path %>
-              </span>
-            </td>
-            <td>
-              <% if last_created %>
-                <%= t "admin.misc.time_ago", time: time_ago_in_words(last_created), default: "#{time_ago_in_words(last_created)} #{t("admin.misc.ago")}" %>
-              <% end %>
-            </td>
-            <td>
-              <% count = @count[abstract_model.model.name] %>
-              <% percent = count > 0 ? (@max <= 1 ? count : ((Math.log(count+1) * 100.0) / Math.log(@max+1)).to_i) : -1 %>
-              <div class="progress" style="margin-bottom:0px">
-                <div class="bg-<%= get_indicator(percent) %> progress-bar<%= ' progress-bar-striped progress-bar-animated' if active %>" style="width:<%= [2.0, percent].max.to_i %>%">
-                  <%= @count[abstract_model.model.name] %>
+  <div class="dashboard-statistics">
+    <table class="table table-condensed table-striped table-hover">
+      <thead>
+        <tr>
+          <th class="shrink model-name">
+            <%= t "admin.table_headers.model_name" %>
+          </th>
+          <th class="shrink last-created">
+            <%= t "admin.table_headers.last_created" %>
+          </th>
+          <th class="records">
+            <%= t "admin.table_headers.records" %>
+          </th>
+          <th class="shrink controls"></th>
+        </tr>
+      </thead>
+      <tbody class="table-group-divider">
+        <% @abstract_models.each do |abstract_model| %>
+          <% if authorized? :index, abstract_model %>
+            <% index_path = index_path(model_name: abstract_model.to_param) %>
+            <% row_class = "#{cycle("odd", "even")}#{" link" if index_path} #{abstract_model.param_key}_links" %>
+            <tr class="<%= row_class %>" data-link="<%= index_path %>">
+              <% last_created = @most_recent_created[abstract_model.model.name] %>
+              <% active = last_created.try(:today?) %>
+              <td>
+                <span class="show">
+                  <%= link_to abstract_model.config.label_plural, index_path %>
+                </span>
+              </td>
+              <td>
+                <% if last_created %>
+                  <%= t "admin.misc.time_ago", time: time_ago_in_words(last_created), default: "#{time_ago_in_words(last_created)} #{t("admin.misc.ago")}" %>
+                <% end %>
+              </td>
+              <td>
+                <% count = @count[abstract_model.model.name] %>
+                <% percent = count > 0 ? (@max <= 1 ? count : ((Math.log(count+1) * 100.0) / Math.log(@max+1)).to_i) : -1 %>
+                <div class="progress" style="margin-bottom:0px">
+                  <div class="bg-<%= get_indicator(percent) %> progress-bar<%= ' progress-bar-striped progress-bar-animated' if active %>" style="width:<%= [2.0, percent].max.to_i %>%">
+                    <%= @count[abstract_model.model.name] %>
+                  </div>
                 </div>
-              </div>
-            </td>
-            <td class="links">
-              <ul class="nav d-inline list-inline">
-                <%= menu_for :collection, abstract_model, nil, true %>
-              </ul>
-            </td>
-          </tr>
+              </td>
+              <td class="links">
+                <ul class="nav d-inline list-inline">
+                  <%= menu_for :collection, abstract_model, nil, true %>
+                </ul>
+              </td>
+            </tr>
+          <% end %>
         <% end %>
-      <% end %>
-    </tbody>
-  </table>
+      </tbody>
+    </table>
+  </div>
 <% end %>
 <% if @history && authorized?(:history_index) %>
   <div class="block" id="block-tables">

data/app/views/rails_admin_next/main/index.html.erb

@@ -82,9 +82,9 @@
       </div>
     </div>
   <% end %>
-  <% unless @model_config.list.scopes.empty? %>
+  <% unless list_scopes.empty? %>
     <ul class="nav nav-tabs" id="scope_selector">
-      <% @model_config.list.scopes.each_with_index do |scope, index| %>
+      <% list_scopes.each_with_index do |scope, index| %>
         <% scope = '_all' if scope.nil? %>
         <li class="nav-item">
           <a href="<%= index_path(params.merge(scope: scope, page: nil)) %>" class="nav-link <%= 'active' if scope.to_s == params[:scope] || (params[:scope].blank? && index == 0) %>">
@@ -96,6 +96,7 @@
   <% end %>
   <%= form_tag bulk_action_path(model_name: @abstract_model.to_param), method: :post, id: "bulk_form", class: ["form", "mb-3"] do %>
     <%= hidden_field_tag :bulk_action %>
+    <%= hidden_field_tag :scope, params[:scope] if params[:scope].present? %>
     <% if description.present? %>
       <p>
         <strong>

data/docs/UPGRADING.md

@@ -398,6 +398,19 @@ end
 
 Note the block: a bare `inverse_of nil` reads the option rather than setting it.
 
+## Nested forms that can reach themselves stop at three levels
+
+A nested form for an association that leads back to its own model, such as a self-referential
+`has_many :children` with `accepts_nested_attributes_for`, used to render without end and fail
+with `SystemStackError`, as did saved records that point back at each other. It now nests the
+same association at most three times along one chain; past that, the association's rows, blank
+template and add control are left out of the form, so a deeper tree is edited from a lower
+record. Chains of distinct associations are not capped.
+
+The blank row's child-index placeholder is tagged by depth, `new_<depth>_<association>` (for
+example `new_1_comments`), rather than `new_<association>`. Host JavaScript that looked for the
+old token in a nested form's `<template>` needs the new one.
+
 ## The show action answers HTML by default
 
 `show` used to declare its JSON format before its HTML one, so a request carrying no
@@ -431,6 +444,16 @@ ignored.
 
 If a client relied on a column the section doesn't show, add that field to the section.
 
+## Malformed filter params are ignored
+
+The index page used to answer a hand-written or stale `f[...]` query string with a 500: a
+filter that wasn't the `field => index => {o:, v:}` shape the filter box submits, one naming
+a field that isn't filterable (`is not currently filterable`), or a value the field couldn't
+parse, such as an impossible date or malformed JSON. Such a filter is now dropped and the
+rest of the list renders. A value that fails to parse counts as no value, so a bookmarked
+link to a field that has since stopped being filterable lists every record rather than
+erroring.
+
 ## Pundit: a model with no policy Scope lists nothing
 
 A model whose policy defines no `Scope` used to list every record. It now lists none: the
@@ -450,6 +473,105 @@ end
 ```
 
 CanCanCan hosts are unaffected.
+
+## An `:enum` field with no option source offers no options
+
+An `:enum` field takes its options from `enum_method`, which defaults to `<name>_enum` on the
+model class or the record. When neither defines it, the field used to call `<name>` itself and
+treat the record's current value as the option list: the index filter crashed, and the form
+offered that value instead of choices. It now offers no options.
+
+If a field's own method returns its option list, name it explicitly:
+
+```ruby
+field :colors, :enum do
+  enum_method :colors
+end
+```
+
+## A redeclared field keeps its `visible` block
+
+Declaring a field again in the same section used to discard a `visible { ... }` block set by an
+earlier declaration and show the field to everyone. The block now survives:
+
+```ruby
+field :salary do
+  visible { bindings[:view].current_user.admin? }
+end
+field :salary # still hidden from non-admins
+```
+
+If a field you hide conditionally started showing for everyone after a later `field` call, it is
+hidden again. A field hidden with a plain `visible false` is still shown again by a later
+declaration, as before.
+
+## Serialized fields load only plain YAML
+
+A `serialized` field (the default for a `store` or `serialize` attribute) now shows its value
+as plain YAML, without `!ruby/...` class tags, and loads the submitted YAML with only `Symbol`,
+`Date` and `Time` permitted. A store's `HashWithIndifferentAccess` comes back as a plain `Hash`,
+which the store wraps again on assignment. YAML naming any other class is rejected.
+
+The `safe_yaml` gem is no longer consulted, even when the host bundles it.
+`RailsAdminNext.yaml_load` and `RailsAdminNext.yaml_dump` are deprecated: call
+`YAML.safe_load` and `YAML.dump` directly.
+
+## `config.model "::Order"` configures `Order`
+
+A model named as a string or symbol with a leading `::` used to register a second, separate
+entry: its block never reached `Order`, and `Order` appeared twice in the navigation. The `::`
+is now dropped, so the block applies to `Order`. If such a block was silently doing nothing,
+check that what it configures is what you want before upgrading. `included_models` and
+`excluded_models` drop a leading `::` the same way.
+
+## Scope tabs apply to export and bulk delete
+
+The tab selected on a list (`list { scopes [...] }`) now also narrows export and bulk
+delete: "Export found" streams only the tab's records, and bulk delete lists and destroys
+only the tab's records, whatever ids are submitted. The bulk form and the confirmation
+form carry `scope` so the tab survives the round trip.
+
+A tabbed collection stays inside the authorization scope, so a tab that drops conditions,
+such as `unscoped`, cannot list, export or delete records the user may not see. It still
+drops the model's own configured `scope`. The authorization scope is built on the model's
+`default_scope`, so an `unscoped` tab no longer reaches records `default_scope` hides: a
+soft-delete "trash" tab built on `unscoped` comes up empty. Give such a tab a scope the
+authorization relation also reaches.
+
+The `scopes` block is now evaluated with `bindings[:controller]`, `bindings[:view]` and
+`bindings[:object]`, so tabs can depend on the current user:
+
+```ruby
+config.model "Order" do
+  list do
+    scopes { bindings[:controller].current_user.admin? ? [nil, :refunded] : [nil] }
+  end
+end
+```
+
+`list_entries` keeps its four positional arguments, but applies a tab only for the page's
+own model, its `additional_scope` defaults to `nil`, and it no longer reads the
+`associated_collection` picker params. Custom actions that listed picker records through
+it should call `association_entries(model_config, collection_scope)` instead.
+
+## `associated_collection_scope` runs after the list sort
+
+Association pickers apply `associated_collection_scope` after the picked model's list sort,
+so a `reorder` in it now decides the order. A plain `order` adds a secondary sort key after
+the list sort. Build on the relation the proc receives: returning a fresh relation discards
+the authorization scope, the picker's search query, sort and eager loads as well. Pickers
+never apply the picked model's scope tabs.
+
+## CSV export follows the list sort
+
+CSV export used to walk records with `find_each`, which discards the list sort, so every file
+came out in primary-key ascending order. It now writes rows in the order the list shows them:
+the sort the export request carries, or the list's default sort. For most models that default is
+the primary key descending, so an export with no sort chosen is now newest first.
+
+Rows are read in batches of 1000 instead of loading every record up front. An export with no
+matching records now contains the header row instead of an empty line.
+
 ## Removed: options deprecated before RailsAdmin 3.0
 
 These six were deprecated upstream between 2019-07 and 2022-01 and had no effect for
@@ -493,3 +615,7 @@ These are intentionally gone — migrate off them before upgrading:
 
 The gem owns **no** history table. Auditing remains host/PaperTrail territory, so there is
 no gem migration to run — your existing `rails_admin_histories` table (if any) is unaffected.
+
+A record's history page now honours its column sort, and with no sort it lists newest
+first, like the model history page. It used to list a record's versions oldest first
+whatever the sort.

data/lib/rails_admin_next/abstract_model.rb

@@ -118,8 +118,16 @@ module RailsAdminNext
       extend Adapters::ActiveRecord
     end
 
+    # A value the field can't parse (an impossible date, malformed JSON or YAML) is
+    # treated as no value, element by element in an array. Only parse errors are
+    # rescued, so a bug in a custom parse_value still raises. Date::Error is an
+    # ArgumentError.
     def parse_field_value(field, value)
-      value.is_a?(Array) ? value.map { |v| field.parse_value(v) } : field.parse_value(value)
+      return value.map { |v| parse_field_value(field, v) } if value.is_a?(Array)
+
+      field.parse_value(value)
+    rescue ArgumentError, JSON::ParserError, Psych::Exception
+      nil
     end
 
     class StatementBuilder
@@ -242,7 +250,7 @@ module RailsAdminNext
         end
 
         def today
-          [Date.today, Date.today]
+          [Date.current, Date.current]
         end
 
         def yesterday
@@ -250,7 +258,7 @@ module RailsAdminNext
         end
 
         def this_week
-          [Date.today.beginning_of_week, Date.today.end_of_week]
+          [Date.current.beginning_of_week, Date.current.end_of_week]
         end
 
         def last_week
@@ -259,7 +267,7 @@ module RailsAdminNext
         end
 
         def between
-          [@value[1], @value[2]]
+          [Array.wrap(@value)[1], Array.wrap(@value)[2]]
         end
 
         def default

data/lib/rails_admin_next/adapters/active_record.rb

@@ -182,7 +182,10 @@ module RailsAdminNext
 
         def add(field, value, operator)
           field.searchable_columns.flatten.each do |column_infos|
-            statement, value1, value2 = StatementBuilder.new(quote(column_infos[:column]), column_infos[:type], value, operator, @scope.connection.adapter_name).to_statement
+            attribute_type = attribute_type(field, column_infos[:column])
+            statement, value1, value2 = StatementBuilder.new(quote(column_infos[:column]), column_infos[:type], value, operator, @scope.connection.adapter_name, column_type: attribute_type&.type).to_statement
+            statement, value1, value2 = "(1 = 0)" if out_of_range?(attribute_type, [value1, value2])
+
             @statements << statement if statement.present?
             @values << value1 unless value1.nil?
             @values << value2 unless value2.nil?
@@ -202,6 +205,29 @@ module RailsAdminNext
           "#{@scope.connection.quote_table_name(table)}.#{@scope.connection.quote_column_name(name)}"
         end
 
+        # The column's own attribute type, resolved from the field's model or, for an
+        # association, the associated model. Nil for a column on any other table.
+        def attribute_type(field, column)
+          table, name = column.split(".")
+          return unless name
+
+          models = [field.abstract_model]
+          models.concat(Array.wrap(field.associated_model_config).map(&:abstract_model)) if field.association?
+          models.map(&:model).detect { it.table_name == table }&.type_for_attribute(name)
+        end
+
+        # A number too wide for the column (an int4 searched with a 10-digit term) makes
+        # PostgreSQL reject the whole query. No row can hold it, so the column matches
+        # nothing instead: a search still matches the other columns, a filter matches none.
+        def out_of_range?(attribute_type, values)
+          return false unless attribute_type
+
+          values.grep(Integer).each { attribute_type.serialize(it) }
+          false
+        rescue ActiveModel::RangeError
+          true
+        end
+
         def build
           scope = @scope.where(@statements.join(" OR "), *@values)
           scope = scope.references(*@tables.uniq) if @tables.any?
@@ -225,11 +251,20 @@ module RailsAdminNext
 
       # filters example => {"string_field"=>{"0055"=>{"o"=>"like", "v"=>"test_value"}}, ...}
       # "0055" is the filter index, no use here. o is the operator, v the value
+      # Hand-written or stale params can have any shape, so anything that isn't
+      # field => index => filter with a scalar (or flat array) value, or names no
+      # filterable field, is skipped.
       def filter_scope(scope, filters, fields = config.list.fields.select(&:filterable?))
+        return scope unless filters.respond_to?(:each_pair)
+
         filters.each_pair do |field_name, filters_dump|
+          field = fields.detect { |f| f.name.to_s == field_name }
+          next unless field && filters_dump.respond_to?(:each_value)
+
           filters_dump.each_value do |filter_dump|
+            next unless filter_dump.respond_to?(:each_pair) && filter_value?(filter_dump[:v])
+
             wb = WhereBuilder.new(scope)
-            field = fields.detect { |f| f.name.to_s == field_name }
             value = parse_field_value(field, filter_dump[:v])
 
             wb.add(field, value, filter_dump[:o] || RailsAdminNext::Config.default_search_operator)
@@ -240,14 +275,19 @@ module RailsAdminNext
         scope
       end
 
+      def filter_value?(value)
+        Array.wrap(value).none? { it.is_a?(Array) || it.respond_to?(:each_pair) }
+      end
+
       def build_statement(column, type, value, operator)
         StatementBuilder.new(column, type, value, operator, model.connection.adapter_name).to_statement
       end
 
       class StatementBuilder < RailsAdminNext::AbstractModel::StatementBuilder
-        def initialize(column, type, value, operator, adapter_name)
+        def initialize(column, type, value, operator, adapter_name, column_type: nil)
           super(column, type, value, operator)
           @adapter_name = adapter_name
+          @column_type = column_type
         end
 
         protected
@@ -260,6 +300,9 @@ module RailsAdminNext
             uuid_unary_operators
           when :integer, :decimal, :float
             numeric_unary_operators
+          when :enum
+            # Only a string column can hold '' (and an integer one rejects the comparison).
+            %i[string text citext].include?(@column_type) ? generic_unary_operators : enum_unary_operators
           else
             generic_unary_operators
           end
@@ -288,6 +331,7 @@ module RailsAdminNext
         end
         alias_method :numeric_unary_operators, :boolean_unary_operators
         alias_method :uuid_unary_operators, :boolean_unary_operators
+        alias_method :enum_unary_operators, :boolean_unary_operators
 
         def range_filter(min, max)
           if min && max && min == max

data/lib/rails_admin_next/config/actions/bulk_delete.rb

@@ -20,7 +20,7 @@ module RailsAdminNext
               @objects = list_entries(@model_config, :destroy)
 
               if @objects.blank?
-                flash[:error] = t("admin.flash.error", name: pluralize(0, @model_config.label), action: t("admin.actions.delete.done"))
+                flash[:error] = t("admin.flash.error", name: pluralize(0, @model_config.label, plural: @model_config.label_plural), action: t("admin.actions.delete.done"))
                 redirect_to index_path
               else
                 render @action.template_name
@@ -49,10 +49,10 @@ module RailsAdminNext
               end
 
               if destroyed.nil?
-                flash[:error] = t("admin.flash.error", name: pluralize(0, @model_config.label), action: t("admin.actions.delete.done"))
+                flash[:error] = t("admin.flash.error", name: pluralize(0, @model_config.label, plural: @model_config.label_plural), action: t("admin.actions.delete.done"))
               else
-                flash[:success] = t("admin.flash.successful", name: pluralize(destroyed.count, @model_config.label), action: t("admin.actions.delete.done")) unless destroyed.empty?
-                flash[:error] = t("admin.flash.error", name: pluralize(not_destroyed.count, @model_config.label), action: t("admin.actions.delete.done")) unless not_destroyed.empty?
+                flash[:success] = t("admin.flash.successful", name: pluralize(destroyed.count, @model_config.label, plural: @model_config.label_plural), action: t("admin.actions.delete.done")) unless destroyed.empty?
+                flash[:error] = t("admin.flash.error", name: pluralize(not_destroyed.count, @model_config.label, plural: @model_config.label_plural), action: t("admin.actions.delete.done")) unless not_destroyed.empty?
               end
               redirect_to back_or_index
             end

data/lib/rails_admin_next/config/actions/index.rb

@@ -30,26 +30,10 @@ module RailsAdminNext
 
         register_instance_option :controller do
           proc do
-            # Resolve the active list scope (the scope tabs) and fold it into the
-            # relation *before* pagination. The paginated collection is a resolved
-            # page, not a chainable relation, so a named scope can no longer be
-            # appended afterwards.
             unless @objects
-              scopes = @model_config.list.scopes
-              list_scope =
-                if scopes.empty? || params[:scope].blank?
-                  scopes.first
-                elsif scopes.collect(&:to_s).include?(params[:scope])
-                  params[:scope].to_sym
-                end
-
-              additional_scope = get_association_scope_from_params
-              if list_scope
-                base_scope = additional_scope
-                additional_scope = proc { (base_scope ? instance_eval(&base_scope) : self).send(list_scope) }
-              end
-
-              @objects = list_entries(@model_config, :index, additional_scope)
+              # @association is set only when the picker guard accepts associated_collection; otherwise list normally.
+              association_scope = get_association_scope_from_params
+              @objects = @association ? association_entries(@model_config, association_scope) : list_entries
             end
 
             respond_to do |format|

data/lib/rails_admin_next/config/actions.rb

@@ -49,12 +49,8 @@ module RailsAdminNext
 
         def add_action(key, parent_class, parent, &)
           a = "RailsAdminNext::Config::Actions::#{parent_class.to_s.camelize}".constantize.new
-          a.instance_eval(%(
-            #{parent} true
-            def key
-              :#{key}
-            end
-          ), __FILE__, __LINE__ - 5)
+          a.send(parent, true)
+          a.define_singleton_method(:key) { key.to_sym }
           add_action_custom_key(a, &)
         end
 
@@ -68,12 +64,9 @@ module RailsAdminNext
             name = klass.to_s.demodulize.underscore.to_sym
           end
 
-          instance_eval %{
-            def #{name}(&block)
-              action = #{klass}.new
-              add_action_custom_key(action, &block)
-            end
-          }, __FILE__, __LINE__ - 5
+          define_singleton_method(name) do |&block|
+            add_action_custom_key(klass.new, &block)
+          end
         end
 
         private

data/lib/rails_admin_next/config/fields/association.rb

@@ -137,7 +137,7 @@ module RailsAdminNext
 
         # Returns collection of all selectable records
         def collection(scope = nil)
-          (scope || bindings[:controller].list_entries(associated_model_config, :index, associated_collection_scope, false))
+          (scope || bindings[:controller].association_entries(associated_model_config, associated_collection_scope))
             .map { |o| [o.send(associated_object_label_method), format_key(o.send(associated_primary_key)).to_s] }
         end
 

data/lib/rails_admin_next/config/fields/types/enum.rb

@@ -21,11 +21,17 @@ module RailsAdminNext
           end
 
           register_instance_option :enum_method do
-            @enum_method ||= (bindings[:object].class.respond_to?("#{name}_enum") || (bindings[:object] || abstract_model.model.new).respond_to?("#{name}_enum")) ? "#{name}_enum" : name
+            @enum_method ||= begin
+              method_name = "#{name}_enum"
+              method_name if (bindings[:object]&.class || abstract_model.model).respond_to?(method_name) ||
+                (bindings[:object] || abstract_model.model.new).respond_to?(method_name)
+            end
           end
 
           register_instance_option :enum do
-            if abstract_model.model.respond_to?(enum_method)
+            if enum_method.nil?
+              []
+            elsif abstract_model.model.respond_to?(enum_method)
               abstract_model.model.send(enum_method)
             else
               (bindings[:object] || abstract_model.model.new).send(enum_method)

data/lib/rails_admin_next/config/fields/types/serialized.rb

@@ -10,17 +10,32 @@ module RailsAdminNext
           # Register field type for the type loader
           RailsAdminNext::Config::Fields::Types.register(self)
 
+          # The YAML is admin-supplied, so loading permits no class beyond the scalars a
+          # plain value needs. Dumping strips Hash/Array subclasses (a store's
+          # HashWithIndifferentAccess) so what the form shows can be loaded back.
+          PERMITTED_CLASSES = [::Date, ::Symbol, ::Time].freeze
+
           register_instance_option :formatted_value do
-            RailsAdminNext.yaml_dump(value) unless value.nil?
+            YAML.dump(plain(value)) unless value.nil?
           end
 
           def parse_value(value)
-            value.present? ? (RailsAdminNext.yaml_load(value) || nil) : nil
+            value.present? ? (YAML.safe_load(value, permitted_classes: PERMITTED_CLASSES) || nil) : nil
           end
 
           def parse_input(params)
             params[name] = parse_value(params[name]) if params[name].is_a?(::String)
           end
+
+          private
+
+          def plain(object)
+            case object
+            when Hash then object.to_h { |key, value| [plain(key), plain(value)] }
+            when Array then object.map { plain(it) }
+            else object
+            end
+          end
         end
       end
     end

data/lib/rails_admin_next/config/fields/types/timestamp.rb

@@ -9,6 +9,7 @@ module RailsAdminNext
         class Timestamp < RailsAdminNext::Config::Fields::Types::Datetime
           # Register field type for the type loader
           RailsAdminNext::Config::Fields::Types.register(self)
+          RailsAdminNext::Config::Fields::Types.register(:timestamptz, self)
         end
       end
     end

data/lib/rails_admin_next/config/has_fields.rb

@@ -10,7 +10,7 @@ module RailsAdminNext
 
         # some fields are hidden by default (belongs_to keys, has_many associations in list views.)
         # unhide them if config specifically defines them
-        field.show if field && !field.instance_variable_get("@#{field.name}_registered").is_a?(Proc)
+        field.show if field && !field.instance_variable_get(:@visible_registered).is_a?(Proc)
         # Specify field as virtual if type is not specifically set and field was not
         # found in default stack
         if field.nil? && type.nil?

data/lib/rails_admin_next/config.rb

@@ -249,7 +249,7 @@ module RailsAdminNext
 
       # pool of all found model names from the whole application
       def models_pool
-        (viable_models - excluded_models.collect(&:to_s)).uniq.sort
+        (viable_models - excluded_models.collect { it.to_s.delete_prefix("::") }).uniq.sort
       end
 
       # Loads a model configuration instance from the registry or registers
@@ -272,7 +272,7 @@ module RailsAdminNext
           when Class, ConstLoadSuppressor::ConstProxy
             entity.name.to_sym
           when String, Symbol
-            entity.to_sym
+            entity.to_s.delete_prefix("::").to_sym
           else
             entity.class.name.to_sym
           end
@@ -369,7 +369,7 @@ module RailsAdminNext
       #
       # @see RailsAdminNext::Config.registry
       def reset_model(model)
-        key = model.is_a?(Class) ? model.name.to_sym : model.to_sym
+        key = model.is_a?(Class) ? model.name.to_sym : model.to_s.delete_prefix("::").to_sym
         @registry.delete(key)
       end
 
@@ -395,7 +395,7 @@ module RailsAdminNext
       private
 
       def viable_models
-        included_models.collect(&:to_s).presence || begin
+        included_models.collect { it.to_s.delete_prefix("::") }.presence || begin
           @@system_models ||= # memoization for tests
             ([Rails.application] + Rails::Engine.subclasses.collect(&:instance)).flat_map do |app|
               (app.paths["app/models"].to_a + app.config.eager_load_paths).collect do |load_path|

data/lib/rails_admin_next/extensions/paper_trail/auditing_adapter.rb

@@ -143,7 +143,7 @@ module RailsAdminNext
 
           versions = object.nil? ? versions_for_model(model) : object.public_send(model.model.versions_association_name)
           versions = versions.where("event LIKE ?", "%#{query}%") if query.present?
-          versions = versions.order(sort)
+          versions = versions.reorder(sort)
 
           paginate_versions(versions, all, (page.presence || 1).to_i, per_page.to_i)
         end

data/lib/rails_admin_next/support/composite_keys_serializer.rb

@@ -3,12 +3,18 @@
 module RailsAdminNext
   module Support
     module CompositeKeysSerializer
+      # "_" joins the keys, so it is escaped as "~" plus its hex byte. "~" is escaped too so the
+      # escape cannot be forged, and both are URL-unreserved. Every other value serializes as-is,
+      # keeping existing links valid.
+      ESCAPED = /[_~]/
+      ESCAPE = /~(5F|7E)/
+
       def self.serialize(keys)
-        keys.map { |key| key&.to_s&.gsub("_", "__") }.join("_")
+        keys.map { |key| key&.to_s&.gsub(ESCAPED) { format("~%02X", it.ord) } }.join("_")
       end
 
       def self.deserialize(string)
-        string.split("_").map { |key| key&.gsub("__", "_") }
+        string.split("_").map { |key| key.gsub(ESCAPE) { $1.hex.chr } }
       end
     end
   end

data/lib/rails_admin_next/support/csv_converter.rb

@@ -4,14 +4,17 @@ require "csv"
 
 module RailsAdminNext
   class CSVConverter
+    BATCH_SIZE = 1000
+
     def initialize(objects = [], schema = nil)
       @fields = []
       @associations = []
       schema ||= {}
 
-      return if (@objects = objects).blank?
+      @objects = objects
+      @model = objects.is_a?(ActiveRecord::Relation) ? objects.klass : objects.first&.class
+      return unless @model
 
-      @model = objects.dup.first.class
       @abstract_model = RailsAdminNext::AbstractModel.new(@model)
       @model_config = @abstract_model.config
       @methods = [(schema[:only] || []) + (schema[:methods] || [])].flatten.compact
@@ -63,17 +66,54 @@ module RailsAdminNext
 
     def generate_csv_string(options)
       generator_options = (options[:generator] || {}).symbolize_keys.delete_if { |_, value| value.blank? }
-      method = @objects.respond_to?(:find_each) ? :find_each : :each
-
       CSV.generate(**generator_options) do |csv|
         csv << generate_csv_header unless options[:skip_header]
 
-        @objects.send(method) do |object|
+        each_object do |object|
           csv << generate_csv_row(object)
         end
       end
     end
 
+    def each_object(&)
+      return @objects.each(&) unless @objects.is_a?(ActiveRecord::Relation)
+      # Batching sets its own limit and offset, which would drop the relation's.
+      return @objects.each(&) if @objects.limit_value || @objects.offset_value
+
+      if (direction = primary_key_direction)
+        @objects.unscope(:order).find_each(order: direction, batch_size: BATCH_SIZE, &)
+      else
+        each_in_offset_batches(&)
+      end
+    end
+
+    # sort_scope writes the list sort as a single "<table>.<column> <direction>" string.
+    def primary_key_direction
+      primary_key = @model.primary_key
+      return unless primary_key.is_a?(String)
+
+      orders = @objects.order_values
+      return :asc if orders.empty?
+      return unless orders.one? && orders.first.is_a?(String)
+
+      table = Regexp.escape(@model.table_name)
+      column = Regexp.escape(primary_key)
+      orders.first[/\A(?:\W?#{table}\W?\.)?\W?#{column}\W? (asc|desc)\z/i, 1]&.downcase&.to_sym
+    end
+
+    # The primary-key tie-break makes the order total, so rows that tie on the sort
+    # column cannot shift between batches. A short batch is not the last one: sorting
+    # on an eager-loaded has-many column returns fewer records than the limit.
+    def each_in_offset_batches(&)
+      ordered = @objects.order(Array(@model.primary_key).index_with(:asc))
+      0.step(by: BATCH_SIZE) do |offset|
+        batch = ordered.limit(BATCH_SIZE).offset(offset).to_a
+        break if batch.empty?
+
+        batch.each(&)
+      end
+    end
+
     def generate_csv_header
       @fields.collect do |field|
         ::I18n.t("admin.export.csv.header_for_root_methods", name: field.label, model: @abstract_model.pretty_name)

data/lib/rails_admin_next/version.rb

@@ -6,8 +6,8 @@ module RailsAdminNext
     # the tag's version over these constants at build time, so the in-repo values are only
     # the floor a local `gem build` produces.
     MAJOR = 1
-    MINOR = 2
-    PATCH = 1
+    MINOR = 3
+    PATCH = 0
     PRE = nil
 
     class << self

data/lib/rails_admin_next.rb

@@ -49,25 +49,13 @@ module RailsAdminNext
     @deprecator ||= ActiveSupport::Deprecation.new(RailsAdminNext::Version.to_s, "RailsAdminNext")
   end
 
-  # Backwards-compatible with safe_yaml/load when SafeYAML isn't available.
-  # Evaluates available YAML loaders at boot and creates appropriate method,
-  # so no conditionals are required at runtime.
-  begin
-    require "safe_yaml/load"
-    def self.yaml_load(yaml)
-      SafeYAML.load(yaml)
-    end
-  rescue LoadError
-    if YAML.respond_to?(:safe_load)
-      def self.yaml_load(yaml)
-        YAML.safe_load(yaml)
-      end
-    else
-      raise LoadError.new "Safe-loading of YAML is not available. Please install 'safe_yaml' or install Psych 2.0+"
-    end
+  def self.yaml_load(yaml)
+    deprecator.warn("RailsAdminNext.yaml_load is deprecated and will be removed. Call YAML.safe_load directly.")
+    YAML.safe_load(yaml)
   end
 
   def self.yaml_dump(object)
+    deprecator.warn("RailsAdminNext.yaml_dump is deprecated and will be removed. Call YAML.dump directly.")
     YAML.dump(object)
   end
 end

data/src/rails_admin/controllers/nested_form_controller.js

@@ -7,7 +7,7 @@ import { Controller } from "@hotwired/stimulus";
 //
 //   - add: clones a blank subform from the <template>. For a has_many
 //     association the template carries a child-index placeholder
-//     (e.g. "new_nested_field_tests") which is swapped for a unique value so
+//     (e.g. "new_1_nested_field_tests") which is swapped for a unique value so
 //     each new row submits under its own index; has_one/belongs_to subforms
 //     have no placeholder. Focus then moves to the first visible field.
 //   - remove on an unsaved subform deletes it from the DOM.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_admin_next
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Daniel López Prat