rails_admin_next 1.0.0

data/lib/rails_admin_next/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsAdminNext
+  class Version
+    MAJOR = 1
+    MINOR = 0
+    PATCH = 0
+    PRE = nil
+
+    class << self
+      # @return [String]
+      def to_s
+        [MAJOR, MINOR, PATCH, PRE].compact.join(".")
+      end
+    end
+  end
+end

data/lib/rails_admin_next.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "rails_admin_next/engine"
+require "rails_admin_next/abstract_model"
+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/paper_trail"
+require "rails_admin_next/support/csv_converter"
+require "rails_admin_next/support/hash_helper"
+require "rails_admin_next/support/paginated_collection"
+require "yaml"
+
+module RailsAdminNext
+  extend RailsAdminNext::Config::ConstLoadSuppressor
+
+  # Setup RailsAdminNext
+  #
+  # Given the first argument is a model class, a model class name
+  # or an abstract model object proxies to model configuration method.
+  #
+  # If only a block is passed it is stored to initializer stack to be evaluated
+  # on first request in production mode and on each request in development. If
+  # initialization has already occurred (in other words RailsAdminNext.setup has
+  # been called) the block will be added to stack and evaluated at once.
+  #
+  # Otherwise returns RailsAdminNext::Config class.
+  #
+  # @see RailsAdminNext::Config
+  def self.config(entity = nil, &)
+    if entity
+      RailsAdminNext::Config.model(entity, &)
+    elsif block_given?
+      RailsAdminNext::Config::ConstLoadSuppressor.suppressing { yield(RailsAdminNext::Config) }
+    else
+      RailsAdminNext::Config
+    end
+  end
+
+  # Deprecator for RailsAdminNext's own configuration options. Rails 8.1 made the class-level
+  # ActiveSupport::Deprecation.warn private, so deprecations go through an instance deprecator.
+  # Intentionally left unregistered, so a deprecated-but-removed option warns rather than raising
+  # even in a host whose deprecation behavior is :raise — upgrading must never blow up at boot.
+  def self.deprecator
+    @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
+  end
+
+  def self.yaml_dump(object)
+    YAML.dump(object)
+  end
+end

data/lib/tasks/rails_admin.rake

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+namespace :rails_admin do
+  desc "Install rails_admin_next"
+  task :install do
+    system "rails g rails_admin_next:install"
+  end
+
+  desc "CI env for GitHub Actions"
+  task :prepare_ci_env do
+    adapter = ENV["CI_DB_ADAPTER"] || "sqlite3"
+    database = ((adapter == "sqlite3") ? "db/development.sqlite3" : "ci_rails_admin_next")
+    username =
+      case adapter
+      when "postgresql"
+        "postgres"
+      when "mysql2"
+        "root"
+      else
+        ""
+      end
+
+    configuration = {
+      "test" => {
+        "adapter" => adapter,
+        "database" => database,
+        "username" => username,
+        "password" => ((adapter == "postgresql") ? "postgres" : ""),
+        "host" => "127.0.0.1",
+        "encoding" => "utf8",
+        "pool" => 5,
+        "timeout" => 5000
+      }
+    }
+
+    filename = Rails.root.join("config/database.yml")
+
+    File.write(filename, configuration.to_yaml)
+  end
+end

data/src/rails_admin/application.js

@@ -0,0 +1,15 @@
+import { Application } from "@hotwired/stimulus";
+
+// RailsAdminNext runs its OWN Stimulus application, separate from any Stimulus app the
+// host may run for its own UI. Controllers are registered against this instance
+// (see ./controllers/index.js) so the engine never reaches into — or depends on —
+// the host's controllers/ directory.
+const application = Application.start();
+application.warnings = false;
+application.debug = false;
+
+// Expose for debugging and host extension under the engine namespace.
+window.RailsAdminNext = window.RailsAdminNext || {};
+window.RailsAdminNext.application = application;
+
+export { application };

data/src/rails_admin/base.js

@@ -0,0 +1,12 @@
+import "@hotwired/turbo-rails";
+
+// RailsAdminNext's own Stimulus application + controllers.
+import "rails_admin/application";
+import "rails_admin/controllers";
+
+// Vanilla, jQuery-free document-level page interactions.
+import "rails_admin/interactions";
+
+// Owns rails_admin.dom_ready. Imported last so every listener registered above
+// is in place before the first dispatch fires.
+import "rails_admin/dom-ready";

data/src/rails_admin/controllers/alert_controller.js

@@ -0,0 +1,28 @@
+import { Controller } from "@hotwired/stimulus";
+
+const FOCUSABLE =
+  'a[href], button:not([disabled]), input:not([disabled]), select:not([disabled]), textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
+
+// Dismissible flash alert. Replaces Bootstrap's data-bs-dismiss="alert".
+// Removing an alert with the keyboard would otherwise drop focus to <body>, so
+// on dismiss focus returns to the nearest focusable element preceding the alert
+// (falling back to the first focusable element on the page).
+export default class extends Controller {
+  dismiss() {
+    const target = this.#focusReturnTarget();
+    this.element.remove();
+    target?.focus();
+  }
+
+  #focusReturnTarget() {
+    const focusable = Array.from(document.querySelectorAll(FOCUSABLE)).filter(
+      (el) => !this.element.contains(el) && el.offsetParent !== null
+    );
+    const preceding = focusable.filter(
+      (el) =>
+        this.element.compareDocumentPosition(el) &
+        Node.DOCUMENT_POSITION_PRECEDING
+    );
+    return preceding.at(-1) || focusable[0] || null;
+  }
+}

data/src/rails_admin/controllers/collapse_controller.js

@@ -0,0 +1,16 @@
+import { Controller } from "@hotwired/stimulus";
+
+// Responsive navbar toggler (WAI-ARIA disclosure): the hamburger toggles
+// `aria-expanded` and the region's Bootstrap `.collapse`/`.show` classes
+// (`.collapse:not(.show)` is hidden; `.navbar-expand-md` forces the region
+// visible above the breakpoint). The sidebar groups use native <details>, but a
+// <details> navbar can't be force-expanded at the md breakpoint, so the navbar
+// stays class-driven.
+export default class extends Controller {
+  static targets = ["trigger", "region"];
+
+  toggle() {
+    const expanded = this.regionTarget.classList.toggle("show");
+    this.triggerTarget.setAttribute("aria-expanded", String(expanded));
+  }
+}

data/src/rails_admin/controllers/dropdown_controller.js

@@ -0,0 +1,110 @@
+import { Controller } from "@hotwired/stimulus";
+
+const ITEM = ".dropdown-item";
+
+// Menu button (WAI-ARIA APG) on a native popover. The toggle is a
+// <button popovertarget> and the menu carries popover="auto", so the platform
+// owns the top layer, click-to-toggle, and outside-click/Escape light
+// dismissal (do NOT reimplement those). The controller lives on the toggle;
+// its menu is the next sibling (`.dropdown-menu`), so the menu items stay out
+// of Stimulus's action-parsing scope — important because the bulk-action
+// items carry their own `data-action` attribute read by interactions.js.
+//
+// What is left for JS:
+//   - ArrowDown/ArrowUp on the closed toggle open the menu onto its
+//     first/last item; opening any other way focuses the first item.
+//   - ArrowUp/Down/Home/End rove focus between items; Tab closes.
+//   - an item click closes the menu (clicks inside a popover don't dismiss).
+//   - aria-expanded on the toggle syncs from the menu's popover toggle event,
+//     and focus returns to the toggle when a light dismissal dropped it on
+//     <body> (Escape restores it natively; an outside click on a
+//     non-focusable target does not).
+export default class extends Controller {
+  #focusOnOpen = "first";
+  #onToggle;
+  #onMenuKeydown;
+  #onMenuClick;
+
+  connect() {
+    this.element.setAttribute("aria-haspopup", "true");
+    // Also resets a stale value restored from the Turbo page cache (popovers
+    // are snapshotted closed, but the attribute travels as-is).
+    this.element.setAttribute("aria-expanded", "false");
+    this.#onToggle = this.#toggled.bind(this);
+    this.#onMenuKeydown = this.#menuKeydown.bind(this);
+    this.#onMenuClick = this.#menuClick.bind(this);
+    this.#menu.addEventListener("toggle", this.#onToggle);
+    this.#menu.addEventListener("keydown", this.#onMenuKeydown);
+    this.#menu.addEventListener("click", this.#onMenuClick);
+  }
+
+  disconnect() {
+    this.#menu?.removeEventListener("toggle", this.#onToggle);
+    this.#menu?.removeEventListener("keydown", this.#onMenuKeydown);
+    this.#menu?.removeEventListener("click", this.#onMenuClick);
+  }
+
+  // Enter, Space and click toggle natively via [popovertarget]; the arrows
+  // open with an explicit landing item.
+  onKeydown(event) {
+    if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
+    event.preventDefault();
+    if (this.#menu.matches(":popover-open")) return;
+    this.#focusOnOpen = event.key === "ArrowUp" ? "last" : "first";
+    this.#menu.showPopover();
+  }
+
+  get #menu() {
+    return this.element.nextElementSibling;
+  }
+
+  get #items() {
+    return Array.from(this.#menu.querySelectorAll(ITEM));
+  }
+
+  // Popover toggle events fire for every show/hide path — the toggle button,
+  // light dismissal, hidePopover(), even a <dialog> claiming the top layer.
+  #toggled(event) {
+    const open = event.newState === "open";
+    this.element.setAttribute("aria-expanded", String(open));
+    if (open) {
+      const items = this.#items;
+      (this.#focusOnOpen === "last" ? items.at(-1) : items[0])?.focus();
+      this.#focusOnOpen = "first";
+    } else if (document.activeElement === document.body) {
+      this.element.focus();
+    }
+  }
+
+  #menuKeydown(event) {
+    const items = this.#items;
+    const current = items.indexOf(document.activeElement);
+    switch (event.key) {
+      case "ArrowDown":
+        event.preventDefault();
+        items[(current + 1) % items.length]?.focus();
+        break;
+      case "ArrowUp":
+        event.preventDefault();
+        items[(current - 1 + items.length) % items.length]?.focus();
+        break;
+      case "Home":
+        event.preventDefault();
+        items[0]?.focus();
+        break;
+      case "End":
+        event.preventDefault();
+        items.at(-1)?.focus();
+        break;
+      case "Tab":
+        // hidePopover() restores focus to the toggle first, so the default
+        // Tab then moves on from there — the APG menu-button behavior.
+        this.#menu.hidePopover();
+        break;
+    }
+  }
+
+  #menuClick(event) {
+    if (event.target.closest(ITEM)) this.#menu.hidePopover();
+  }
+}

data/src/rails_admin/controllers/feedback_controller.js

@@ -0,0 +1,73 @@
+import { Controller } from "@hotwired/stimulus";
+
+const BUSY_CLASS = "rails_admin-submitting";
+
+// Shared UX-feedback for Turbo-driven forms. Wired onto every admin form by
+// RailsAdminNext::MainHelper#rails_admin_form_for as:
+//
+//   data-controller="feedback"
+//   data-action="turbo:submit-start->feedback#start turbo:submit-end->feedback#end"
+//
+// `start` disables the form's submit controls and marks the form busy; `end`
+// reverses both symmetrically. Turbo fires `turbo:submit-end` on success AND on a
+// 422 validation failure, so the form never gets stuck disabled. State is driven
+// entirely by the Turbo submit lifecycle — there are no fixed timeouts.
+//
+// On connect it also flags every errored field `aria-invalid="true"` and moves
+// focus to the first one, so a 422 re-render (which Turbo renders in place,
+// re-running connect) lands the cursor on the field that needs fixing —
+// including fields inside nested subforms.
+export default class extends Controller {
+  connect() {
+    // A back/forward-cache restore can replay a snapshot captured mid-submit;
+    // start every connection from a clean, non-busy state.
+    this.#reset();
+    this.#flagInvalidFields();
+  }
+
+  start() {
+    this.element.setAttribute("aria-busy", "true");
+    this.element.classList.add(BUSY_CLASS);
+    this.#submitControls.forEach((control) => {
+      control.disabled = true;
+      this.#disabledControls.add(control);
+    });
+  }
+
+  end() {
+    this.#reset();
+  }
+
+  // RailsAdminNext marks an errored field's wrapper `.control-group.error`; expose
+  // that on the inputs themselves as `aria-invalid` and focus the first. Focus
+  // is only taken from a freshly rendered page (activeElement is the body), so
+  // a user already typing somewhere is never interrupted.
+  #flagInvalidFields() {
+    const invalid = this.element.querySelectorAll(
+      ".control-group.error input:not([type='hidden']), .control-group.error select, .control-group.error textarea"
+    );
+    invalid.forEach((field) => field.setAttribute("aria-invalid", "true"));
+
+    const focusable = document.activeElement;
+    if (invalid[0] && (!focusable || focusable === document.body)) {
+      invalid[0].focus();
+    }
+  }
+
+  #reset() {
+    this.element.removeAttribute("aria-busy");
+    this.element.classList.remove(BUSY_CLASS);
+    this.#disabledControls.forEach((control) => {
+      control.disabled = false;
+    });
+    this.#disabledControls.clear();
+  }
+
+  get #submitControls() {
+    return this.element.querySelectorAll(
+      'input[type="submit"], button[type="submit"], button:not([type])'
+    );
+  }
+
+  #disabledControls = new Set();
+}