activeadmin 1.3.0 → 2.13.1

data/lib/active_admin/dynamic_settings_node.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require "active_admin/dynamic_setting"
+require "active_admin/settings_node"
+
+module ActiveAdmin
+
+  class DynamicSettingsNode < SettingsNode
+    class << self
+      def register(name, value, type = nil)
+        class_attribute "#{name}_setting"
+        add_reader(name)
+        add_writer(name, type)
+        send "#{name}=", value
+      end
+
+      def add_reader(name)
+        define_singleton_method(name) do |*args|
+          send("#{name}_setting").value(*args)
+        end
+      end
+
+      def add_writer(name, type)
+        define_singleton_method("#{name}=") do |value|
+          send("#{name}_setting=", DynamicSetting.build(value, type))
+        end
+      end
+    end
+  end
+end

data/lib/active_admin/engine.rb

@@ -1,16 +1,25 @@
+# frozen_string_literal: true
 module ActiveAdmin
   class Engine < ::Rails::Engine
+    # Set default values for app_path and load_paths before running initializers
+    initializer "active_admin.load_app_path", before: :load_config_initializers do |app|
+      ActiveAdmin::Application.setting :app_path, app.root
+      ActiveAdmin::Application.setting :load_paths, [File.expand_path("app/admin", app.root)]
+    end
+
     initializer "active_admin.precompile", group: :all do |app|
-      ActiveAdmin.application.stylesheets.each do |path, _|
-        app.config.assets.precompile << path
-      end
-      ActiveAdmin.application.javascripts.each do |path|
-        app.config.assets.precompile << path
+      unless ActiveAdmin.application.use_webpacker
+        ActiveAdmin.application.stylesheets.each do |path, _|
+          app.config.assets.precompile << path
+        end
+        ActiveAdmin.application.javascripts.each do |path|
+          app.config.assets.precompile << path
+        end
       end
     end
 
-    initializer 'active_admin.routes' do
-      require 'active_admin/helpers/routes/url_helpers'
+    initializer "active_admin.routes" do
+      require "active_admin/helpers/routes/url_helpers"
     end
   end
 end

data/lib/active_admin/error.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveAdmin
   # Exception class to raise when there is an authorized access
   # exception thrown. The exception has a few goodies that may
@@ -6,7 +7,9 @@ module ActiveAdmin
     attr_reader :user, :action, :subject
 
     def initialize(user, action, subject = nil)
-      @user, @action, @subject = user, action, subject
+      @user = user
+      @action = action
+      @subject = subject
 
       super()
     end
@@ -22,7 +25,7 @@ module ActiveAdmin
   class ErrorLoading < Error
     # Locates the most recent file and line from the caught exception's backtrace.
     def find_cause(folder, backtrace)
-      backtrace.grep(/\/(#{folder}\/.*\.rb):(\d+)/){ [$1, $2] }.first
+      backtrace.grep(/\/(#{folder}\/.*\.rb):(\d+)/) { [$1, $2] }.first
     end
   end
 
@@ -43,8 +46,6 @@ module ActiveAdmin
       raise new exception
     end
 
-    private
-
     def self.database_error_classes
       @classes ||= []
     end

data/lib/active_admin/filters/active.rb

@@ -1,4 +1,5 @@
-require 'active_admin/filters/active_filter'
+# frozen_string_literal: true
+require "active_admin/filters/active_filter"
 
 module ActiveAdmin
   module Filters

data/lib/active_admin/filters/active_filter.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveAdmin
   module Filters
 
@@ -26,9 +27,10 @@ module ActiveAdmin
       end
 
       def label
-        # TODO: to remind us to go back to the simpler str.downcase once we support ruby >= 2.4 only.
-        translated_predicate = predicate_name.mb_chars.downcase.to_s
-        if filter_label
+        translated_predicate = predicate_name.downcase
+        if filter_label && filter_label.is_a?(Proc)
+          "#{filter_label.call} #{translated_predicate}"
+        elsif filter_label
           "#{filter_label} #{translated_predicate}"
         elsif related_class
           "#{related_class_name} #{translated_predicate}"
@@ -38,8 +40,9 @@ module ActiveAdmin
       end
 
       def predicate_name
-        I18n.t("active_admin.filters.predicates.#{condition.predicate.name}",
-               default: ransack_predicate_name)
+        I18n.t(
+          "active_admin.filters.predicates.#{condition.predicate.name}",
+          default: ransack_predicate_name)
       end
 
       def html_options
@@ -65,7 +68,7 @@ module ActiveAdmin
       def filter_label
         return unless filter
 
-        filter[:label]
+        filter[:label] || I18n.t(name, scope: ["formtastic", "labels"], default: nil)
       end
 
       #@return Ransack::Nodes::Attribute
@@ -82,7 +85,7 @@ module ActiveAdmin
       end
 
       def find_class?
-        ['eq', 'in'].include? condition.predicate.arel_predicate
+        ["eq", "in"].include? condition.predicate.arel_predicate
       end
 
       # detect related class for Ransack::Nodes::Attribute
@@ -95,12 +98,12 @@ module ActiveAdmin
       end
 
       def filter
-        resource.filters[name.to_sym]
+        resource.filters[name.to_sym] || resource.filters[condition.key.to_sym]
       end
 
       def related_primary_key
         if predicate_association
-          predicate_association.active_record_primary_key
+          predicate_association.association_primary_key
         elsif related_class
           related_class.primary_key
         end
@@ -111,8 +114,6 @@ module ActiveAdmin
         @predicate_association
       end
 
-      private
-
       def find_predicate_association
         condition_attribute.klass.reflect_on_all_associations.
           reject { |r| r.options[:polymorphic] }. #skip polymorphic

data/lib/active_admin/filters/active_sidebar.rb

@@ -1,42 +1,20 @@
-require 'active_admin/filters/active'
+# frozen_string_literal: true
+require "active_admin/filters/active"
 
 module ActiveAdmin
   module Filters
     class ActiveSidebar < ActiveAdmin::SidebarSection
 
       def initialize
-        super I18n.t("active_admin.search_status.headline"), sidebar_options
+        super "search_status", sidebar_options
       end
 
       def block
-        -> do
-          active_filters = ActiveAdmin::Filters::Active.new(active_admin_config, assigns[:search])
-          span do
-            if current_scope
-              h4 I18n.t("active_admin.search_status.current_scope"), style: 'display: inline'
-              b scope_name(current_scope), class: 'current_scope_name', style: "display: inline"
-            end
-            div style: "margin-top: 10px" do
-              h4 I18n.t("active_admin.search_status.current_filters"), style: 'margin-bottom: 10px'
-              ul do
-                if active_filters.filters.blank?
-                  li I18n.t("active_admin.search_status.no_current_filters")
-                else
-                  active_filters.filters.each do |filter|
-                    li filter.html_options do
-                      span do
-                        text_node filter.label
-                      end
-                      b do
-                        text_node to_sentence(filter.values.map { |v| pretty_format(v) })
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
+        -> { active_filters_sidebar_content }
+      end
+
+      def title
+        I18n.t("active_admin.search_status.headline")
       end
 
       protected

data/lib/active_admin/filters/dsl.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveAdmin
   module Filters
     module DSL

data/lib/active_admin/filters/forms.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveAdmin
   module Filters
     # This form builder defines methods to build filter forms such
@@ -48,22 +49,25 @@ module ActiveAdmin
       def active_admin_filters_form_for(search, filters, options = {})
         defaults = { builder: ActiveAdmin::Filters::FormBuilder,
                      url: collection_path,
-                     html: {class: 'filter_form'} }
-        required = { html: {method: :get},
+                     html: { class: "filter_form" } }
+        required = { html: { method: :get },
                      as: :q }
-        options  = defaults.deep_merge(options).deep_merge(required)
+        options = defaults.deep_merge(options).deep_merge(required)
 
         form_for search, options do |f|
           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])
-            opts[:input_html] = instance_exec(&opts[:input_html]) if opts[:input_html].is_a?(Proc)
-            f.filter attribute, opts.except(:if, :unless)
+            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: "buttons" do
-            f.submit(I18n.t('active_admin.filters.buttons.filter')) +
-              link_to(I18n.t('active_admin.filters.buttons.clear'), '#', class: 'clear_filters_btn') +
+            f.submit(I18n.t("active_admin.filters.buttons.filter")) +
+              link_to(I18n.t("active_admin.filters.buttons.clear"), "#", class: "clear_filters_btn") +
               hidden_field_tags_for(params, except: except_hidden_fields)
           end
 

data/lib/active_admin/filters/formtastic_addons.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveAdmin
   module Filters
     module FormtasticAddons
@@ -37,7 +38,7 @@ module ActiveAdmin
       end
 
       def polymorphic_foreign_type?(method)
-        klass.reflect_on_all_associations.select{ |r| r.macro == :belongs_to && r.options[:polymorphic] }
+        klass.reflect_on_all_associations.select { |r| r.macro == :belongs_to && r.options[:polymorphic] }
           .map(&:foreign_type).include? method.to_s
       end
 
@@ -54,7 +55,7 @@ module ActiveAdmin
       end
 
       def seems_searchable?
-        has_predicate? || scope?
+        column_for(method).nil? && (has_predicate? || scope?)
       end
 
       # If the given method has a predicate (like _eq or _lteq), it's pretty
@@ -63,11 +64,6 @@ module ActiveAdmin
         !!Ransack::Predicate.detect_from_string(method.to_s)
       end
 
-      # Ransack lets you define custom search methods, called ransackers.
-      def ransacker?
-        klass._ransackers.key? method.to_s
-      end
-
       # Ransack supports exposing selected scopes on your model for advanced searches.
       def scope?
         context = Ransack::Context.for klass

data/lib/active_admin/filters/resource_extension.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ActiveAdmin
   module Filters
 
@@ -83,7 +84,7 @@ module ActiveAdmin
         @filters_to_remove = nil
       end
 
-    private
+      private
 
       # Collapses the waveform, if you will, of which filters should be displayed.
       # Removes filters and adds in default filters as desired.
@@ -123,25 +124,49 @@ module ActiveAdmin
       # Returns a default set of filters for the associations
       def default_association_filters
         if resource_class.respond_to?(:reflect_on_all_associations)
-          poly, not_poly = resource_class.reflect_on_all_associations.partition{ |r| r.macro == :belongs_to && r.options[:polymorphic] }
+          poly, not_poly = resource_class.reflect_on_all_associations.partition { |r| r.macro == :belongs_to && r.options[:polymorphic] }
 
           # remove deeply nested associations
-          not_poly.reject!{ |r| r.chain.length > 2 }
+          not_poly.reject! { |r| r.chain.length > 2 }
 
           filters = poly.map(&:foreign_type) + not_poly.map(&:name)
+
+          # Check high-arity associations for filterable columns
+          max = namespace.maximum_association_filter_arity
+          if max != :unlimited
+            high_arity, low_arity = not_poly.partition do |r|
+              r.klass.reorder(nil).limit(max + 1).count > max
+            end
+
+            # Remove high-arity associations with no searchable column
+            high_arity = high_arity.select(&method(:searchable_column_for))
+
+            high_arity = high_arity.map { |r| r.name.to_s + "_" + searchable_column_for(r) + namespace.filter_method_for_large_association }
+
+            filters = poly.map(&:foreign_type) + low_arity.map(&:name) + high_arity
+          end
+
           filters.map &:to_sym
         else
           []
         end
       end
 
+      def search_columns
+        @search_columns ||= namespace.filter_columns_for_large_association.map(&:to_s)
+      end
+
+      def searchable_column_for(relation)
+        relation.klass.column_names.find { |name| search_columns.include?(name) }
+      end
+
       def add_filters_sidebar_section
         self.sidebar_sections << filters_sidebar_section
       end
 
       def filters_sidebar_section
-        ActiveAdmin::SidebarSection.new :filters, only: :index, if: ->{ active_admin_config.filters.any? } do
-          active_admin_filters_form_for assigns[:search], active_admin_config.filters
+        ActiveAdmin::SidebarSection.new :filters, only: :index, if: -> { active_admin_config.filters.any? } do
+          active_admin_filters_form_for assigns[:search], **active_admin_config.filters
         end
       end
 

data/lib/active_admin/filters.rb

@@ -1,11 +1,12 @@
-require 'active_admin/filters/dsl'
-require 'active_admin/filters/resource_extension'
-require 'active_admin/filters/formtastic_addons'
-require 'active_admin/filters/forms'
-require 'active_admin/helpers/optional_display'
-require 'active_admin/filters/active_sidebar'
+# frozen_string_literal: true
+require "active_admin/filters/dsl"
+require "active_admin/filters/resource_extension"
+require "active_admin/filters/formtastic_addons"
+require "active_admin/filters/forms"
+require "active_admin/helpers/optional_display"
+require "active_admin/filters/active_sidebar"
 
 # Add our Extensions
 ActiveAdmin::ResourceDSL.send :include, ActiveAdmin::Filters::DSL
-ActiveAdmin::Resource.send    :include, ActiveAdmin::Filters::ResourceExtension
+ActiveAdmin::Resource.send :include, ActiveAdmin::Filters::ResourceExtension
 ActiveAdmin::ViewHelpers.send :include, ActiveAdmin::Filters::ViewHelper

data/lib/active_admin/form_builder.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # Provides an intuitive way to build has_many associated records in the same form.
 module Formtastic
   module Inputs
@@ -13,7 +14,6 @@ end
 
 module ActiveAdmin
   class FormBuilder < ::Formtastic::FormBuilder
-    include MethodOrProcHelper
 
     self.input_namespaces = [::Object, ::ActiveAdmin::Inputs, ::Formtastic::Inputs]
 
@@ -21,127 +21,167 @@ module ActiveAdmin
     self.input_class_finder = ::Formtastic::InputClassFinder
     self.action_class_finder = ::Formtastic::ActionClassFinder
 
-    def cancel_link(url = {action: "index"}, html_options = {}, li_attrs = {})
+    def cancel_link(url = { action: "index" }, html_options = {}, li_attrs = {})
       li_attrs[:class] ||= "cancel"
-      li_content = template.link_to I18n.t('active_admin.cancel'), url, html_options
+      li_content = template.link_to I18n.t("active_admin.cancel"), url, html_options
       template.content_tag(:li, li_content, li_attrs)
     end
 
     attr_accessor :already_in_an_inputs_block
 
-    def assoc_heading(assoc)
-      object.class.reflect_on_association(assoc).klass.model_name.
-        human(count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT)
+    def has_many(assoc, options = {}, &block)
+      HasManyBuilder.new(self, assoc, options).render(&block)
     end
+  end
 
-    def has_many(assoc, options = {}, &block)
-      # remove options that should not render as attributes
-      custom_settings = :new_record, :allow_destroy, :heading, :sortable, :sortable_start
-      builder_options = {new_record: true}.merge! options.slice  *custom_settings
-      options         = {for: assoc      }.merge! options.except *custom_settings
-      options[:class] = [options[:class], "inputs has_many_fields"].compact.join(' ')
-      sortable_column = builder_options[:sortable]
-      sortable_start  = builder_options.fetch(:sortable_start, 0)
+  # Decorates a FormBuilder with the additional attributes and methods
+  # to build a has_many block.  Nested has_many blocks are handled by
+  # nested decorators.
+  class HasManyBuilder < SimpleDelegator
+    attr_reader :assoc
+    attr_reader :options
+    attr_reader :heading, :sortable_column, :sortable_start
+    attr_reader :new_record, :destroy_option, :remove_record
+
+    def initialize(has_many_form, assoc, options)
+      super has_many_form
+      @assoc = assoc
+      @options = extract_custom_settings!(options.dup)
+      @options.reverse_merge!(for: assoc)
+      @options[:class] = [options[:class], "inputs has_many_fields"].compact.join(" ")
 
       if sortable_column
-        options[:for] = [assoc, sorted_children(assoc, sortable_column)]
+        @options[:for] = [assoc, sorted_children(sortable_column)]
       end
+    end
 
+    def render(&block)
       html = "".html_safe
-      unless builder_options.key?(:heading) && !builder_options[:heading]
-        html << template.content_tag(:h3) do
-          builder_options[:heading] || assoc_heading(assoc)
-        end
-      end
+      html << template.content_tag(:h3) { heading } if heading.present?
+      html << template.capture { content_has_many(&block) }
+      html = wrap_div_or_li(html)
+      template.concat(html) if template.output_buffer
+      html
+    end
 
-      html << template.capture do
-        form_block = proc do |has_many_form|
-          index    = parent_child_index options[:parent] if options[:parent]
-          block_contents = template.capture do
-            block.call(has_many_form, index)
-          end
-          template.concat(block_contents)
-          template.concat has_many_actions(has_many_form, builder_options, "".html_safe)
-        end
+    protected
 
-        template.assigns[:has_many_block] = true
-        contents = without_wrapper { inputs(options, &form_block) } || "".html_safe
+    # remove options that should not render as attributes
+    def extract_custom_settings!(options)
+      @heading = options.key?(:heading) ? options.delete(:heading) : default_heading
+      @sortable_column = options.delete(:sortable)
+      @sortable_start = options.delete(:sortable_start) || 0
+      @new_record = options.key?(:new_record) ? options.delete(:new_record) : true
+      @destroy_option = options.delete(:allow_destroy)
+      @remove_record = options.delete(:remove_record)
+      options
+    end
 
-        if builder_options[:new_record]
-          contents << js_for_has_many(assoc, form_block, template, builder_options[:new_record], options[:class])
-        else
-          contents
-        end
+    def default_heading
+      assoc_klass.model_name.
+        human(count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT)
+    end
+
+    def assoc_klass
+      @assoc_klass ||= __getobj__.object.class.reflect_on_association(assoc).klass
+    end
+
+    def content_has_many(&block)
+      form_block = proc do |form_builder|
+        render_has_many_form(form_builder, options[:parent], &block)
       end
 
-      tag = @already_in_an_inputs_block ? :li : :div
-      html = template.content_tag(tag, html, class: "has_many_container #{assoc}", 'data-sortable' => sortable_column, 'data-sortable-start' => sortable_start)
-      template.concat(html) if template.output_buffer
-      html
+      template.assigns[:has_many_block] = true
+      contents = without_wrapper { inputs(options, &form_block) }
+      contents ||= "".html_safe
+
+      js = new_record ? js_for_has_many(options[:class], &form_block) : ""
+      contents << js
     end
 
-    protected
+    # Renders the Formtastic inputs then appends ActiveAdmin delete and sort actions.
+    def render_has_many_form(form_builder, parent, &block)
+      index = parent && form_builder.send(:parent_child_index, parent)
+      template.concat template.capture { yield(form_builder, index) }
+      template.concat has_many_actions(form_builder, "".html_safe)
+    end
 
-    def has_many_actions(has_many_form, builder_options, contents)
-      if has_many_form.object.new_record?
+    def has_many_actions(form_builder, contents)
+      if form_builder.object.new_record?
         contents << template.content_tag(:li) do
-          template.link_to I18n.t('active_admin.has_many_remove'), "#", class: 'button has_many_remove'
+          remove_text = remove_record.is_a?(String) ? remove_record : I18n.t("active_admin.has_many_remove")
+          template.link_to remove_text, "#", class: "button has_many_remove"
         end
-      elsif call_method_or_proc_on(has_many_form.object,
-                                   builder_options[:allow_destroy],
-                                   exec: false)
-
-        has_many_form.input(:_destroy, as: :boolean,
-                            wrapper_html: {class: 'has_many_delete'},
-                            label: I18n.t('active_admin.has_many_delete'))
+      elsif allow_destroy?(form_builder.object)
+        form_builder.input(
+          :_destroy, as: :boolean,
+                     wrapper_html: { class: "has_many_delete" },
+                     label: I18n.t("active_admin.has_many_delete"))
       end
 
-      if builder_options[:sortable]
-        has_many_form.input builder_options[:sortable], as: :hidden
+      if sortable_column
+        form_builder.input sortable_column, as: :hidden
 
-        contents << template.content_tag(:li, class: 'handle') do
-          I18n.t('active_admin.move')
+        contents << template.content_tag(:li, class: "handle") do
+          I18n.t("active_admin.move")
         end
       end
 
       contents
     end
 
-    def sorted_children(assoc, column)
-      object.public_send(assoc).sort_by do |o|
+    def allow_destroy?(form_object)
+      !! case destroy_option
+         when Symbol, String
+           form_object.public_send destroy_option
+         when Proc
+           destroy_option.call form_object
+         else
+           destroy_option
+         end
+    end
+
+    def sorted_children(column)
+      __getobj__.object.public_send(assoc).sort_by do |o|
         attribute = o.public_send column
         [attribute.nil? ? Float::INFINITY : attribute, o.id || Float::INFINITY]
       end
     end
 
-    private
-
     def without_wrapper
-      is_being_wrapped = @already_in_an_inputs_block
-      @already_in_an_inputs_block = false
+      is_being_wrapped = already_in_an_inputs_block
+      self.already_in_an_inputs_block = false
 
       html = yield
 
-      @already_in_an_inputs_block = is_being_wrapped
+      self.already_in_an_inputs_block = is_being_wrapped
       html
     end
 
     # Capture the ADD JS
-    def js_for_has_many(assoc, form_block, template, new_record, class_string)
-      assoc_reflection = object.class.reflect_on_association assoc
-      assoc_name       = assoc_reflection.klass.model_name
-      placeholder      = "NEW_#{assoc_name.to_s.underscore.upcase.gsub(/\//, '_')}_RECORD"
+    def js_for_has_many(class_string, &form_block)
+      assoc_name = assoc_klass.model_name
+      placeholder = "NEW_#{assoc_name.to_s.underscore.upcase.gsub(/\//, '_')}_RECORD"
       opts = {
-        for: [assoc, assoc_reflection.klass.new],
+        for: [assoc, assoc_klass.new],
         class: class_string,
         for_options: { child_index: placeholder }
       }
-      html = template.capture{ inputs_for_nested_attributes opts, &form_block }
-      text = new_record.is_a?(String) ? new_record : I18n.t('active_admin.has_many_new', model: assoc_name.human)
+      html = template.capture { __getobj__.send(:inputs_for_nested_attributes, opts, &form_block) }
+      text = new_record.is_a?(String) ? new_record : I18n.t("active_admin.has_many_new", model: assoc_name.human)
 
-      template.link_to text, '#', class: "button has_many_add", data: {
+      template.link_to text, "#", class: "button has_many_add", data: {
         html: CGI.escapeHTML(html).html_safe, placeholder: placeholder
       }
     end
+
+    def wrap_div_or_li(html)
+      template.content_tag(
+        already_in_an_inputs_block ? :li : :div,
+        html,
+        class: "has_many_container #{assoc}",
+        "data-sortable" => sortable_column,
+        "data-sortable-start" => sortable_start)
+    end
   end
 end