rails_admin_next 1.2.1 → 2.0.0

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

@@ -73,6 +73,9 @@ module RailsAdminNext
       # show Gravatar in Navigation bar
       attr_accessor :show_gravatar
 
+      # show the "Made in Tokyo" footer under every admin page
+      attr_accessor :show_footer
+
       # accepts a hash of static links to be shown below the main navigation
       attr_accessor :navigation_static_links
       attr_accessor :navigation_static_label
@@ -171,21 +174,37 @@ module RailsAdminNext
       #     end
       #   end
       #
+      # The block form only gates entry: it runs before every action, but nothing checks
+      # individual records or scopes the list.
+      #
       # To use an authorization adapter, pass the name of the adapter. For example,
-      # to use with CanCanCan[https://github.com/CanCanCommunity/cancancan/], pass it like this.
+      # to use with Pundit[https://github.com/varvet/pundit], pass it like this.
+      #
+      # @example Pundit
+      #   RailsAdminNext.config do |config|
+      #     config.authorize_with :pundit
+      #   end
       #
-      # @example CanCanCan
+      # @example ActionPolicy
       #   RailsAdminNext.config do |config|
-      #     config.authorize_with :cancancan
+      #     config.authorize_with :action_policy
       #   end
       #
-      # See the wiki[https://github.com/railsadminteam/rails_admin/wiki] for more on authorization.
+      # A custom adapter is registered with
+      # RailsAdminNext.add_extension(key, mod, authorization: true) before it is named here.
+      # See docs/UPGRADING.md for the adapter contract.
       #
       # @see RailsAdminNext::Config::DEFAULT_AUTHORIZE
       def authorize_with(*args, &block)
         extension = args.shift
         if extension
-          klass = RailsAdminNext::AUTHORIZATION_ADAPTERS[extension]
+          klass = RailsAdminNext::AUTHORIZATION_ADAPTERS.fetch(extension) do
+            raise ArgumentError, "Unknown authorization adapter #{extension.inspect}. " \
+              "Registered adapters: #{RailsAdminNext::AUTHORIZATION_ADAPTERS.keys.map(&:inspect).join(", ")}. " \
+              "Register a custom adapter with RailsAdminNext.add_extension(key, mod, authorization: true) " \
+              "before this config block, or pass a block to authorize_with to gate admin entry only " \
+              "(no per-record checks or list scoping). See docs/UPGRADING.md."
+          end
           klass.setup if klass.respond_to? :setup
           @authorize = proc do
             @authorization_adapter = klass.new(*([self] + args).compact, &block)
@@ -249,7 +268,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 +291,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
@@ -355,6 +374,7 @@ module RailsAdminNext
         @registry = {}
         @navbar_css_classes = %w[navbar-dark bg-primary border-bottom]
         @show_gravatar = true
+        @show_footer = true
         @navigation_static_links = {}
         @navigation_static_label = nil
         @composite_keys_serializer = RailsAdminNext::Support::CompositeKeysSerializer
@@ -369,7 +389,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 +415,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/action_policy/authorization_adapter.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RailsAdminNext
+  module Extensions
+    module ActionPolicy
+      class AuthorizationAdapter
+        # ActionPolicy is referenced only inside methods, so hosts without the gem still boot.
+        def self.setup
+          include ::ActionPolicy::Behaviour
+
+          authorize :user, through: -> { @controller._current_user }
+        end
+
+        def initialize(controller)
+          @controller = controller
+        end
+
+        def authorize(action, abstract_model = nil, model_object = nil)
+          return unless action
+
+          record = model_object || abstract_model&.model
+          authorize!(record, to: rule_for(action), with: policy_class_for(record))
+          @controller.skip_verify_authorized! if @controller.respond_to?(:skip_verify_authorized!)
+        end
+
+        def authorized?(action, abstract_model = nil, model_object = nil)
+          return unless action
+
+          record = model_object || abstract_model&.model
+          allowed_to?(rule_for(action), record, with: policy_class_for(record))
+        end
+
+        def query(_action, abstract_model)
+          @controller.skip_verify_authorized_scoped! if @controller.respond_to?(:skip_verify_authorized_scoped!)
+          model = abstract_model.model
+          authorized_scope(model.all, type: :active_record_relation, with: ::ActionPolicy.lookup(model))
+        rescue ::ActionPolicy::NotFound, ::ActionPolicy::UnknownScopeType, ::ActionPolicy::UnknownNamedScope
+          abstract_model.model.none
+        end
+
+        def attributes_for(action, abstract_model)
+          record = abstract_model&.model
+          policy_for(record:, with: policy_class_for(record)).try(:attributes_for, action) || {}
+        end
+
+        private
+
+        def policy_class_for(record)
+          ::ActionPolicy.lookup(record, default: ::ApplicationPolicy)
+        end
+
+        # A Symbol, because ActionPolicy keys its rule aliases (new? -> create?) by Symbol and a
+        # String would silently skip them.
+        def rule_for(action)
+          action.to_s.end_with?("?") ? action.to_sym : :"#{action}?"
+        end
+      end
+    end
+  end
+end

data/lib/rails_admin_next/extensions/action_policy.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/extensions/action_policy/authorization_adapter"
+
+RailsAdminNext.add_extension(:action_policy, RailsAdminNext::Extensions::ActionPolicy, authorization: true)

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/extensions/pundit/authorization_adapter.rb

@@ -46,7 +46,7 @@ module RailsAdminNext
         def query(_action, abstract_model)
           @controller.send(:policy_scope, abstract_model.model.all)
         rescue ::Pundit::NotDefinedError
-          abstract_model.model.none
+          host_policy_scope? ? abstract_model.model.none : model_scope(abstract_model.model)
         end
 
         # This is called in the new/create actions to determine the initial attributes for new
@@ -65,6 +65,22 @@ module RailsAdminNext
           ::ApplicationPolicy.new(@controller.send(:pundit_user), record)
         end
 
+        # action_policy defines ActiveRecord::Relation#policy_class as nil, which hides every
+        # Scope from Pundit's relation lookup when both gems are bundled; the model still finds it.
+        # A host override of policy_scope (e.g. namespacing) chose its own Scope, so it is never
+        # swapped for the model's.
+        def host_policy_scope?
+          @controller.method(:policy_scope).owner != (defined?(::Pundit::Authorization) ? ::Pundit::Authorization : ::Pundit)
+        end
+
+        def model_scope(model)
+          scope_class = ::Pundit::PolicyFinder.new(model).scope
+          return model.none unless scope_class
+
+          @controller.instance_variable_set(:@_pundit_policy_scoped, true)
+          scope_class.new(@controller.send(:pundit_user), model.all).resolve
+        end
+
         def action_for_pundit(action)
           (action[-1, 1] == "?") ? action : "#{action}?"
         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

@@ -5,9 +5,9 @@ module RailsAdminNext
     # Releases are cut by publishing a Release-Drafter draft: the gem-push workflow stamps
     # 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
+    MAJOR = 2
+    MINOR = 0
+    PATCH = 0
     PRE = nil
 
     class << self

data/lib/rails_admin_next.rb

@@ -6,8 +6,8 @@ require "rails_admin_next/config"
 require "rails_admin_next/config/const_load_suppressor"
 require "rails_admin_next/icons"
 require "rails_admin_next/extension"
-require "rails_admin_next/extensions/cancancan"
 require "rails_admin_next/extensions/pundit"
+require "rails_admin_next/extensions/action_policy"
 require "rails_admin_next/extensions/paper_trail"
 require "rails_admin_next/support/csv_converter"
 require "rails_admin_next/support/hash_helper"
@@ -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/skills/rails-admin-next/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: rails-admin-next
-description: Configure or extend the rails_admin_next admin in a host Rails app (models, fields, custom actions and field types, CanCanCan/Pundit authorization, PaperTrail history, theming, CSP). Use instead of upstream RailsAdmin knowledge, which is wrong for this fork.
+description: Configure or extend the rails_admin_next admin in a host Rails app (models, fields, custom actions and field types, Pundit, ActionPolicy or custom-adapter authorization, PaperTrail history, theming, CSP). Use instead of upstream RailsAdmin knowledge, which is wrong for this fork.
 ---
 
 # rails_admin_next
@@ -35,7 +35,7 @@ Renamed (write the new form):
 
 Not renamed (leave as is):
 
-- The authorization subject is still `:rails_admin`. CanCanCan abilities grant `can :access, :rails_admin`. Never rewrite it to `:rails_admin_next`, which fails authorization.
+- The authorization subject is still `:rails_admin`. A custom adapter that keeps CanCanCan grants `can :access, :rails_admin`. Never rewrite it to `:rails_admin_next`, which fails authorization.
 - Action authorization keys (`:dashboard`, `:index`, `:show`, `:new`, `:edit`, `:export`, `:destroy`, `:history`, `:show_in_app`).
 - The `admin.*` I18n namespace.
 
@@ -75,9 +75,10 @@ Icons take logical names, never Font Awesome classes: `link_icon :show_in_app` o
 
 ## Authorization and history
 
-- `config.authorize_with :cancancan` uses the app's `Ability`. Keep the `:rails_admin` subject (see Naming).
+- Pundit and ActionPolicy are the built-in adapters. `RailsAdminNext.add_extension(key, mod, authorization: true)` registers a custom one before the config block names its key; copy `<gem>/lib/rails_admin_next/extensions/pundit/authorization_adapter.rb` as the template. An unregistered key raises `ArgumentError` at boot.
 - `config.authorize_with :pundit` calls the record's policy with `<action>?` methods (`index?`, `edit?`, `dashboard?`) and scopes lists with `policy_scope`.
-- `config.authorize_with do ... end` runs a custom block as a before filter.
+- `config.authorize_with :action_policy` checks the same `<action>?` rules with `allowed_to?` and scopes lists with the policy's default `relation_scope`. `new?` resolves to `create?` and undefined rules to `manage?`. A model with no policy is checked against `ApplicationPolicy`, and one with no default relation scope lists nothing.
+- `config.authorize_with do ... end` runs a custom block as a before filter. It gates admin entry only: no per-record checks or list scoping.
 - `config.authenticate_with do ... end` and `config.current_user_method do ... end` wire in the app's authentication, such as Devise or Warden.
 - `config.audit_with :paper_trail` turns on the history action. Read the "History / audit table" section of `<gem>/docs/UPGRADING.md` first.
 

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: 2.0.0
 platform: ruby
 authors:
 - Daniel López Prat
@@ -285,8 +285,8 @@ files:
 - lib/rails_admin_next/config/sections/update.rb
 - lib/rails_admin_next/engine.rb
 - lib/rails_admin_next/extension.rb
-- lib/rails_admin_next/extensions/cancancan.rb
-- lib/rails_admin_next/extensions/cancancan/authorization_adapter.rb
+- lib/rails_admin_next/extensions/action_policy.rb
+- lib/rails_admin_next/extensions/action_policy/authorization_adapter.rb
 - lib/rails_admin_next/extensions/controller_extension.rb
 - lib/rails_admin_next/extensions/paper_trail.rb
 - lib/rails_admin_next/extensions/paper_trail/auditing_adapter.rb

data/lib/rails_admin_next/extensions/cancancan/authorization_adapter.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module RailsAdminNext
-  module Extensions
-    module CanCanCan
-      # This adapter is for the CanCanCan[https://github.com/CanCanCommunity/cancancan] authorization library.
-      class AuthorizationAdapter
-        module ControllerExtension
-          def current_ability
-            # use _current_user instead of default current_user so it works with
-            # whatever current user method is defined with RailsAdminNext
-            @current_ability ||= ability_class.new(_current_user)
-          end
-        end
-
-        include RailsAdminNext::Config::Configurable
-
-        def self.setup
-          RailsAdminNext::Extensions::ControllerExtension.include ControllerExtension
-        end
-
-        # See the +authorize_with+ config method for where the initialization happens.
-        def initialize(controller, ability = nil, &block)
-          @controller = controller
-          ability_class { ability } if ability
-          instance_eval(&block) if block
-
-          adapter = self
-          ControllerExtension.define_method(:ability_class) do
-            adapter.ability_class
-          end
-          @controller.current_ability.authorize! :access, :rails_admin
-        end
-
-        register_instance_option :ability_class do
-          Ability
-        end
-
-        # This method is called in every controller action and should raise an exception
-        # when the authorization fails. The first argument is the name of the controller
-        # action as a symbol (:create, :bulk_delete, etc.). The second argument is the
-        # AbstractModel instance that applies. The third argument is the actual model
-        # instance if it is available.
-        def authorize(action, abstract_model = nil, model_object = nil)
-          return unless action
-
-          action, subject = resolve_action_and_subject(action, abstract_model, model_object)
-          @controller.current_ability.authorize!(action, subject)
-        end
-
-        # This method is called primarily from the view to determine whether the given user
-        # has access to perform the action on a given model. It should return true when authorized.
-        # This takes the same arguments as +authorize+. The difference is that this will
-        # return a boolean whereas +authorize+ will raise an exception when not authorized.
-        def authorized?(action, abstract_model = nil, model_object = nil)
-          return unless action
-
-          action, subject = resolve_action_and_subject(action, abstract_model, model_object)
-          @controller.current_ability.can?(action, subject)
-        end
-
-        # This is called when needing to scope a database query. It is called within the list
-        # and bulk_delete/destroy actions and should return a scope which limits the records
-        # to those which the user can perform the given action on.
-        def query(action, abstract_model)
-          abstract_model.model.accessible_by(@controller.current_ability, action)
-        end
-
-        # This is called in the new/create actions to determine the initial attributes for new
-        # records. It should return a hash of attributes which match what the user
-        # is authorized to create.
-        def attributes_for(action, abstract_model)
-          @controller.current_ability.attributes_for(action, abstract_model&.model)
-        end
-
-        private
-
-        def resolve_action_and_subject(action, abstract_model, model_object)
-          subject = model_object || abstract_model&.model
-          if subject
-            [action, subject]
-          else
-            # For :dashboard compatibility
-            [:read, action]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rails_admin_next/extensions/cancancan.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-require "rails_admin_next/extensions/cancancan/authorization_adapter"
-
-RailsAdminNext.add_extension(:cancancan, RailsAdminNext::Extensions::CanCanCan, authorization: true)