activeadmin 3.2.4 → 4.0.0.beta1

data/app/controllers/active_admin/resource_controller.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+require "active_admin/collection_decorator"
+
+module ActiveAdmin
+  # All Resources Controller inherits from this controller.
+  # It implements actions and helpers for resources.
+  class ResourceController < BaseController
+    respond_to :html, :xml, :json
+    respond_to :csv, only: :index
+
+    before_action :restrict_download_format_access!, only: [:index, :show]
+
+    include ResourceController::ActionBuilder
+    include ResourceController::Decorators
+    include ResourceController::DataAccess
+    include ResourceController::PolymorphicRoutes
+    include ResourceController::Scoping
+    include ResourceController::Streaming
+    extend ResourceClassMethods
+
+    def self.active_admin_config=(config)
+      if @active_admin_config = config
+        defaults resource_class: config.resource_class,
+                 route_prefix: config.route_prefix,
+                 instance_name: config.resource_name.singular
+      end
+    end
+
+    # Inherited Resources uses the `self.inherited(base)` hook to add
+    # in `self.resource_class`. To override it, we need to install
+    # our resource_class method each time we're inherited from.
+    def self.inherited(base)
+      super(base)
+      base.override_resource_class_methods!
+    end
+
+    private
+
+    def page_presenter
+      case params[:action].to_sym
+      when :index
+        active_admin_config.get_page_presenter(params[:action], params[:as])
+      when :new, :edit
+        active_admin_config.get_page_presenter(:form)
+      end || super
+    end
+
+    def default_page_presenter
+      case params[:action].to_sym
+      when :index
+        PagePresenter.new(as: :table)
+      when :new, :edit
+        PagePresenter.new
+      end || super
+    end
+
+    def page_title
+      if page_presenter[:title]
+        case params[:action].to_sym
+        when :index
+          case page_presenter[:title]
+          when Symbol, Proc
+            instance_exec(&page_presenter[:title])
+          else
+            page_presenter[:title]
+          end
+        else
+          helpers.render_or_call_method_or_proc_on(resource, page_presenter[:title])
+        end
+      else
+        default_page_title
+      end
+    end
+
+    def default_page_title
+      case params[:action].to_sym
+      when :index
+        active_admin_config.plural_resource_label
+      when :show
+        helpers.display_name(resource)
+      when :new, :edit, :create, :update
+        normalized_action = params[:action]
+        normalized_action = 'new' if normalized_action == 'create'
+        normalized_action = 'edit' if normalized_action == 'update'
+
+        ActiveAdmin::Localizers.resource(active_admin_config).t("#{normalized_action}_model")
+      else
+        I18n.t("active_admin.#{params[:action]}", default: params[:action].to_s.titleize)
+      end
+    end
+
+    def restrict_download_format_access!
+      unless request.format.html?
+        presenter = active_admin_config.get_page_presenter(:index)
+        download_formats = (presenter || {}).fetch(:download_links, active_admin_config.namespace.download_links)
+        unless build_download_formats(download_formats).include?(request.format.symbol)
+          raise ActiveAdmin::AccessDenied.new(current_active_admin_user, :index)
+        end
+      end
+    end
+  end
+end

data/app/helpers/active_admin/auto_link_helper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module AutoLinkHelper
+    # Automatically links objects to their resource controllers. If
+    # the resource has not been registered, a string representation of
+    # the object is returned.
+    #
+    # The default content in the link is returned from ActiveAdmin::DisplayHelper#display_name
+    #
+    # You can pass in the content to display
+    #   eg: auto_link(@post, "My Link")
+    #
+    def auto_link(resource, content = display_name(resource), **html_options)
+      if url = auto_url_for(resource)
+        link_to content, url, html_options
+      else
+        content
+      end
+    end
+
+    # Like `auto_link`, except that it only returns a URL for the resource
+    def auto_url_for(resource)
+      config = active_admin_resource_for(resource.class)
+      return unless config
+
+      if config.controller.action_methods.include?("show") &&
+        authorized?(ActiveAdmin::Auth::READ, resource)
+        url_for config.route_instance_path resource, url_options
+      elsif config.controller.action_methods.include?("edit") &&
+        authorized?(ActiveAdmin::Auth::EDIT, resource)
+        url_for config.route_edit_instance_path resource, url_options
+      end
+    end
+
+    def new_action_authorized?(resource_or_class)
+      controller.action_methods.include?("new") && authorized?(ActiveAdmin::Auth::NEW, resource_or_class)
+    end
+
+    def show_action_authorized?(resource_or_class)
+      controller.action_methods.include?("show") && authorized?(ActiveAdmin::Auth::READ, resource_or_class)
+    end
+
+    def edit_action_authorized?(resource_or_class)
+      controller.action_methods.include?("edit") && authorized?(ActiveAdmin::Auth::EDIT, resource_or_class)
+    end
+
+    def destroy_action_authorized?(resource_or_class)
+      controller.action_methods.include?("destroy") && authorized?(ActiveAdmin::Auth::DESTROY, resource_or_class)
+    end
+
+    def auto_logout_link_path
+      render_or_call_method_or_proc_on(self, active_admin_namespace.logout_link_path)
+    end
+
+    private
+
+    # Returns the ActiveAdmin::Resource instance for a class
+    # While `active_admin_namespace` is a helper method, this method seems
+    # to exist to otherwise resolve failed component specs using mock_action_view.
+    def active_admin_resource_for(klass)
+      if respond_to? :active_admin_namespace
+        active_admin_namespace.resource_for klass
+      end
+    end
+  end
+end

data/app/helpers/active_admin/breadcrumb_helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module BreadcrumbHelper
+    ID_FORMAT_REGEXP = /\A(\d+|[a-f0-9]{24}|(?:[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}))\z/.freeze
+
+    # Returns an array of links to use in a breadcrumb
+    def build_breadcrumb_links(path = request.path, html_options = {})
+      config = active_admin_config.breadcrumb
+      if config.is_a?(Proc)
+        instance_exec(controller, &config)
+      elsif config.present?
+        default_breadcrumb_links(path, html_options)
+      end
+    end
+
+    def default_breadcrumb_links(path, html_options = {})
+      # remove leading "/" and split up the URL
+      # and remove last since it's used as the page title
+      parts = path.split("/").select(&:present?)[0..-2]
+
+      parts.each_with_index.map do |part, index|
+        # 1. try using `display_name` if we can locate a DB object
+        # 2. try using the model name translation
+        # 3. default to calling `titlecase` on the URL fragment
+        if ID_FORMAT_REGEXP.match?(part) && parts[index - 1]
+          parent = active_admin_config.belongs_to_config.try :target
+          config = parent && parent.resource_name.route_key == parts[index - 1] ? parent : active_admin_config
+          name = display_name config.find_resource part
+        end
+        name ||= I18n.t "activerecord.models.#{part.singularize}", count: 2.1, default: part.titlecase
+
+        # Don't create a link if the resource's show action is disabled
+        if !config || config.defined_actions.include?(:show)
+          link_to name, "/" + parts[0..index].join("/"), html_options
+        else
+          name
+        end
+      end
+    end
+  end
+end

data/app/helpers/active_admin/display_helper.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module DisplayHelper
+    DISPLAY_NAME_FALLBACK = -> {
+      klass = self.class
+      name = if klass.respond_to?(:model_name)
+               if klass.respond_to?(:primary_key)
+                 "#{klass.model_name.human} ##{send(klass.primary_key)}"
+               else
+                 klass.model_name.human
+               end
+             elsif klass.respond_to?(:primary_key)
+               " ##{send(klass.primary_key)}"
+             end
+      name.present? ? name : to_s
+    }
+
+    def DISPLAY_NAME_FALLBACK.inspect
+      "DISPLAY_NAME_FALLBACK"
+    end
+
+    # Attempts to call any known display name methods on the resource.
+    # See the setting in `application.rb` for the list of methods and their priority.
+    def display_name(resource)
+      unless resource.nil?
+        result = render_in_context(resource, display_name_method_for(resource))
+        if result.to_s&.strip&.present?
+          ERB::Util.html_escape(result)
+        else
+          ERB::Util.html_escape(render_in_context(resource, DISPLAY_NAME_FALLBACK))
+        end
+      end
+    end
+
+    def format_attribute(resource, attr)
+      value = find_value resource, attr
+
+      if value.is_a?(Arbre::Element)
+        value
+      elsif boolean_attr?(resource, attr, value)
+        Arbre::Context.new { status_tag value }
+      else
+        pretty_format value
+      end
+    end
+
+    # Attempts to create a human-readable string for any object
+    def pretty_format(object)
+      case object
+      when String, Numeric, Symbol, Arbre::Element
+        object.to_s
+      when Date, Time
+        I18n.localize object, format: active_admin_application.localize_format
+      when Array
+        format_collection(object)
+      else
+        if defined?(::ActiveRecord) && object.is_a?(ActiveRecord::Base) ||
+            defined?(::Mongoid) && object.class.include?(Mongoid::Document)
+          auto_link object
+        elsif defined?(::ActiveRecord) && object.is_a?(ActiveRecord::Relation)
+          format_collection(object)
+        else
+          display_name object
+        end
+      end
+    end
+
+    private
+
+    # Looks up and caches the first available display name method.
+    # To prevent conflicts, we exclude any methods that happen to be associations.
+    # If no methods are available and we're about to use the Kernel's `to_s`, provide our own.
+    def display_name_method_for(resource)
+      @@display_name_methods_cache ||= {}
+      @@display_name_methods_cache[resource.class] ||= begin
+        methods = active_admin_application.display_name_methods - association_methods_for(resource)
+        method = methods.detect { |method| resource.respond_to? method }
+
+        if method != :to_s || resource.method(method).source_location
+          method
+        else
+          DISPLAY_NAME_FALLBACK
+        end
+      end
+    end
+
+    def association_methods_for(resource)
+      return [] unless resource.class.respond_to? :reflect_on_all_associations
+      resource.class.reflect_on_all_associations.map(&:name)
+    end
+
+    def find_value(resource, attr)
+      if attr.is_a? Proc
+        attr.call resource
+      elsif resource.respond_to? attr
+        resource.public_send attr
+      elsif resource.respond_to? :[]
+        resource[attr]
+      end
+    end
+
+    def format_collection(collection)
+      safe_join(collection.map { |item| pretty_format(item) }, ", ")
+    end
+
+    def boolean_attr?(resource, attr, value)
+      case value
+      when TrueClass, FalseClass
+        true
+      else
+        if resource.class.respond_to? :columns_hash
+          column = resource.class.columns_hash[attr.to_s] and column.type == :boolean
+        end
+      end
+    end
+  end
+end

data/app/helpers/active_admin/form_helper.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module FormHelper
+    RESERVED_PARAMS = %w(controller action commit utf8).freeze
+
+    def active_admin_form_for(resource, options = {}, &block)
+      Arbre::Context.new({}, self) do
+        active_admin_form_for resource, options, &block
+      end.content
+    end
+
+    def hidden_field_tags_for(params, options = {})
+      fields_for_params(params.to_unsafe_hash, options).map do |kv|
+        k, v = kv.first
+        hidden_field_tag k, v, id: sanitize_to_id("hidden_active_admin_#{k}")
+      end.join("\n").html_safe
+    end
+
+    # Flatten a params Hash to an array of fields.
+    #
+    # @param params [Hash]
+    # @param options [Hash] :namespace and :except
+    #
+    # @return [Array] of [Hash] with one element.
+    #
+    # @example
+    #   fields_for_params(scope: "all", users: ["greg"])
+    #     => [ {"scope" => "all"} , {"users[]" => "greg"} ]
+    #
+    def fields_for_params(params, options = {})
+      namespace = options[:namespace]
+      except = Array.wrap(options[:except]).map &:to_s
+
+      params.flat_map do |k, v|
+        next if namespace.nil? && RESERVED_PARAMS.include?(k.to_s)
+        next if except.include?(k.to_s)
+
+        if namespace
+          k = "#{namespace}[#{k}]"
+        end
+
+        case v
+        when String, TrueClass, FalseClass
+          { k => v }
+        when Symbol
+          { k => v.to_s }
+        when Hash
+          fields_for_params(v, namespace: k)
+        when Array
+          v.map do |v|
+            { "#{k}[]" => v }
+          end
+        when nil
+          { k => "" }
+        else
+          raise TypeError, "Cannot convert #{v.class} value: #{v.inspect}"
+        end
+      end.compact
+    end
+
+    # Helper method to render a filter form
+    def active_admin_filters_form_for(search, filters, options = {})
+      defaults = { builder: ActiveAdmin::Filters::FormBuilder, url: collection_path, html: { class: "filters-form" } }
+      required = { html: { method: :get }, as: :q }
+      options = defaults.deep_merge(options).deep_merge(required)
+
+      form_for search, options do |f|
+        f.template.concat hidden_field_tags_for(params, except: except_hidden_fields)
+
+        filters.each do |attribute, opts|
+          next if opts.key?(:if) && !call_method_or_proc_on(self, opts[:if])
+          next if opts.key?(:unless) && call_method_or_proc_on(self, opts[:unless])
+
+          filter_opts = opts.except(:if, :unless)
+          filter_opts[:input_html] = instance_exec(&filter_opts[:input_html]) if filter_opts[:input_html].is_a?(Proc)
+
+          f.filter attribute, filter_opts
+        end
+
+        buttons = content_tag :div, class: "filters-form-buttons" do
+          f.submit(I18n.t("active_admin.filters.buttons.filter"), class: "filters-form-submit") +
+            link_to(I18n.t("active_admin.filters.buttons.clear"), collection_path, class: "filters-form-clear")
+        end
+
+        f.template.concat buttons
+      end
+    end
+
+    private
+
+    def except_hidden_fields
+      [:q, :page]
+    end
+  end
+end

data/app/helpers/active_admin/index_helper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module IndexHelper
+    def scope_name(scope)
+      case scope.name
+      when Proc then
+        self.instance_exec(&scope.name).to_s
+      else
+        scope.name.to_s
+      end
+    end
+
+    def batch_actions_to_display
+      @batch_actions_to_display ||= begin
+        if active_admin_config && active_admin_config.batch_actions.any?
+          active_admin_config.batch_actions.select do |batch_action|
+            call_method_or_proc_on(self, batch_action.display_if_block)
+          end
+        else
+          []
+        end
+      end
+    end
+
+    # 1. removes `select` and `order` to prevent invalid SQL
+    # 2. correctly handles the Hash returned when `group by` is used
+    def collection_size(c = collection)
+      return c.count if c.is_a?(Array)
+      return c.length if c.limit_value
+
+      c = c.except :select, :order
+
+      c.group_values.present? ? c.count.count : c.count
+    end
+
+    def collection_empty?(c = collection)
+      collection_size(c) == 0
+    end
+  end
+end

data/app/helpers/active_admin/layout_helper.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module ActiveAdmin
+  module LayoutHelper
+    # Returns the current Active Admin application instance
+    def active_admin_application
+      ActiveAdmin.application
+    end
+
+    def set_page_title(title)
+      @page_title = title
+    end
+
+    def site_title
+      # Prioritize namespace and account for Devise views where namespace is not available
+      namespace = active_admin_namespace if respond_to?(:active_admin_namespace)
+      (namespace || active_admin_application).site_title(self)
+    end
+
+    def html_head_site_title(separator: "-")
+      "#{@page_title || page_title} #{separator} #{site_title}"
+    end
+
+    def action_items_for_action
+      @action_items_for_action ||= begin
+        if active_admin_config && active_admin_config.action_items?
+          active_admin_config.action_items_for(params[:action], self)
+        else
+          []
+        end
+      end
+    end
+
+    def sidebar_sections_for_action
+      @sidebar_sections_for_action ||= begin
+        if active_admin_config && active_admin_config.sidebar_sections?
+          active_admin_config.sidebar_sections_for(params[:action], self)
+        else
+          []
+        end
+      end
+    end
+
+    def skip_sidebar!
+      @skip_sidebar = true
+    end
+
+    def skip_sidebar?
+      @skip_sidebar == true
+    end
+
+    def flash_messages
+      @flash_messages ||= flash.to_hash.except(*active_admin_application.flash_keys_to_except)
+    end
+
+    def url_for_comments(*args)
+      parts = []
+      parts << active_admin_namespace.name unless active_admin_namespace.root?
+      parts << active_admin_namespace.comments_registration_name.underscore
+      parts << "path"
+      send parts.join("_"), *args
+    end
+  end
+end

data/app/javascript/active_admin/features/batch_actions.js

@@ -0,0 +1,89 @@
+import Rails from '@rails/ujs';
+
+const batchActionClick = function(event) {
+  event.preventDefault()
+  let batchAction = document.getElementById("batch_action")
+  if (batchAction) {
+    batchAction.value = this.dataset.action
+  }
+}
+
+const batchActionConfirmComplete = function(event) {
+  event.preventDefault()
+  if (event.detail[0] === true) {
+    let batchAction = document.getElementById("batch_action")
+    if (batchAction) {
+      batchAction.value = this.dataset.action
+    }
+    let form = document.getElementById("collection_selection")
+    if (form) {
+      form.submit()
+    }
+  }
+}
+
+const batchActionFormSubmit = function(event) {
+  event.preventDefault();
+  let json = JSON.stringify(Object.fromEntries(new FormData(this).entries()));
+  let inputsField = document.getElementById('batch_action_inputs')
+  let form = document.getElementById("collection_selection")
+  if (json && inputsField && form) {
+    inputsField.value = json
+    form.submit()
+  }
+}
+
+Rails.delegate(document, "[data-batch-action-item]", "confirm:complete", batchActionConfirmComplete)
+Rails.delegate(document, "[data-batch-action-item]", "click", batchActionClick)
+Rails.delegate(document, "form[data-batch-action-form]", "submit", batchActionFormSubmit)
+
+const disableDropdown = function(condition) {
+  const button = document.querySelector(".batch-actions-dropdown-toggle")
+  if (button) {
+    button.disabled = condition
+  }
+}
+
+const toggleAllChange = function(event) {
+  const checkboxes = document.querySelectorAll(".batch-actions-resource-selection")
+  for (const checkbox of checkboxes) {
+    checkbox.checked = this.checked
+  }
+
+  const rows = document.querySelectorAll(".paginated-collection tbody tr")
+  for (const row of rows) {
+    row.classList.toggle("selected", this.checked);
+  }
+
+  disableDropdown(!this.checked)
+}
+
+Rails.delegate(document, ".batch-actions-toggle-all", "change", toggleAllChange)
+
+const toggleCheckboxChange = function(event) {
+  const numChecked = document.querySelectorAll(".batch-actions-resource-selection:checked").length;
+  const allChecked = numChecked === document.querySelectorAll(".batch-actions-resource-selection").length;
+  const someChecked = (numChecked > 0) && (numChecked < document.querySelectorAll(".batch-actions-resource-selection").length);
+
+  const toggleAll = document.querySelector(".batch-actions-toggle-all")
+  if (toggleAll) {
+    toggleAll.checked = allChecked
+    toggleAll.indeterminate = someChecked
+  }
+
+  disableDropdown(numChecked === 0)
+}
+
+Rails.delegate(document, ".batch-actions-resource-selection", "change", toggleCheckboxChange)
+
+const tableRowClick = function(event) {
+  const type = event.target.type;
+  if (typeof type === "undefined" || (type !== "checkbox" && type !== "button" && type !== "")) {
+    const checkbox = event.target.closest("tr").querySelector("input[type=checkbox]")
+    if (checkbox) {
+      checkbox.click()
+    }
+  }
+}
+
+Rails.delegate(document, ".paginated-collection tbody td", "click", tableRowClick)

data/app/javascript/active_admin/features/dark_mode_toggle.js

@@ -0,0 +1,37 @@
+import Rails from '@rails/ujs';
+
+const THEME_KEY = "theme";
+const darkModeMedia = window.matchMedia('(prefers-color-scheme: dark)');
+
+const setTheme = () => {
+  // On page load or when changing themes, best to add inline in `head` to avoid FOUC
+  if (localStorage.getItem(THEME_KEY) === 'dark' || (!(THEME_KEY in localStorage) && darkModeMedia.matches)) {
+    document.documentElement.classList.add('dark');
+  } else {
+    document.documentElement.classList.remove('dark');
+  }
+}
+
+// Detect when user changes their system level preference to set theme.
+darkModeMedia.addEventListener("change", setTheme);
+
+// When the page loads, set theme. By default, uses the system preference.
+document.addEventListener("DOMContentLoaded", setTheme);
+
+// If user deletes the Local Storage key, then re-apply theme.
+window.addEventListener("storage", (event) => {
+  if (event.key === THEME_KEY) {
+    setTheme()
+  }
+});
+
+const toggleTheme = () => {
+  if (localStorage.getItem(THEME_KEY) === 'dark' || (!(THEME_KEY in localStorage) && darkModeMedia.matches)) {
+    localStorage.setItem(THEME_KEY, 'light');
+  } else {
+    localStorage.setItem(THEME_KEY, 'dark');
+  }
+  setTheme();
+};
+
+Rails.delegate(document, ".dark-mode-toggle", "click", toggleTheme);

data/app/javascript/active_admin/features/filters.js

@@ -0,0 +1,34 @@
+import Rails from '@rails/ujs';
+import { nextSibling } from 'active_admin/utils/dom'
+
+const disableEmptyFields = function(event) {
+  Array.from(this.querySelectorAll("input, select, textarea"))
+    .filter((el) => el.value === "")
+    .forEach((el) => el.disabled = true)
+};
+
+Rails.delegate(document, ".filters-form", "submit", disableEmptyFields)
+
+const setSearchType = function(event) {
+  const input = nextSibling(this, "input")
+  if (input) {
+    input.name = `q[${this.value}]`
+  }
+};
+
+Rails.delegate(document, ".filters-form-field [data-search-methods]", "change", setSearchType)
+
+const clearFiltersForm = function(event) {
+  event.preventDefault()
+
+  const regex = /^(q\[|page|utf8|commit)/
+  const params = new URLSearchParams(window.location.search)
+
+  Array.from(params.keys())
+    .filter(k => k.match(regex))
+    .forEach(k => params.delete(k))
+
+  window.location.search = params.toString()
+}
+
+Rails.delegate(document, ".filters-form-clear", "click", clearFiltersForm)