activeadmin 1.1.0 → 2.4.0

data/lib/active_admin/dependency.rb

@@ -1,7 +1,7 @@
 module ActiveAdmin
   module Dependency
     module Requirements
-      DEVISE = '>= 3.2', '< 5'
+      DEVISE = '>= 4.0', '< 5'
     end
 
     # Provides a clean interface to check for gem dependencies at runtime.
@@ -55,8 +55,8 @@ module ActiveAdmin
       Matcher.new name.to_s
     end
 
-    def self.rails5?
-      rails >= '5.x'
+    def self.supports_zeitwerk?
+      rails >= "6.0.0.beta3" && RUBY_ENGINE != "jruby"
     end
 
     class Matcher
@@ -94,70 +94,6 @@ module ActiveAdmin
         info = spec ? "#{spec.name} #{spec.version}" : '(missing)'
         "<ActiveAdmin::Dependency::Matcher for #{info}>"
       end
-
-      def adapter
-        @adapter ||= Adapter.const_get(@name.camelize).new self
-      end
-
-      def method_missing(method, *args, &block)
-        if respond_to_missing?(method)
-          adapter.send method, *args, &block
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        adapter.respond_to?(method) || super
-      rescue NameError
-        # 🐾
-      end
-    end
-
-    # Dependency adapters provide an easy way to wrap the conditional logic
-    # necessary to support multiple versions of a gem.
-    #
-    # ActiveAdmin::Dependency.rails.adapter.parameterize 'a b'
-    # => 'a_b'
-    #
-    # ActiveAdmin::Dependency.rails.parameterize 'a b'
-    # => 'a_b'
-    #
-    # ActiveAdmin::Dependency.devise.adapter
-    # -> NameError: uninitialized constant ActiveAdmin::Dependency::Adapter::Devise
-    #
-    module Adapter
-      class Base
-        def initialize(version)
-          @version = version
-        end
-      end
-
-      class Rails < Base
-        def parameterize(string)
-          if Dependency.rails5?
-            string.parameterize separator: '_'
-          else
-            string.parameterize '_'
-          end
-        end
-
-        def redirect_back(controller, fallback_location)
-          controller.instance_exec do
-            if Dependency.rails5?
-              redirect_back fallback_location: fallback_location
-            elsif controller.request.headers.key? 'HTTP_REFERER'
-              redirect_to :back
-            else
-              redirect_to fallback_location
-            end
-          end
-        end
-
-        def render_key
-          Dependency.rails5? ? :body : :text
-        end
-      end
     end
 
   end

data/lib/active_admin/deprecation.rb

@@ -6,30 +6,5 @@ module ActiveAdmin
       ActiveSupport::Deprecation.warn "Active Admin: #{message}", callstack
     end
 
-    # Deprecate a method.
-    #
-    # @param [Module] klass the Class or Module to deprecate the method on
-    # @param [Symbol] method the method to deprecate
-    # @param [String] message the message to display to the end user
-    #
-    # Example:
-    #
-    #     class MyClass
-    #       def my_method
-    #         # ...
-    #       end
-    #       ActiveAdmin::Deprecation.deprecate self, :my_method,
-    #         "MyClass#my_method is being removed in the next release"
-    #     end
-    #
-    def deprecate(klass, method, message)
-      klass.send :define_method, "deprecated_#{method}", klass.instance_method(method)
-
-      klass.send :define_method, method do |*args|
-        ActiveAdmin::Deprecation.warn "#{message}", caller
-        send "deprecated_#{method}", *args
-      end
-    end
-
   end
 end

data/lib/active_admin/dsl.rb

@@ -83,14 +83,7 @@ module ActiveAdmin
     #                         this action item on.
     #                 :except: A single or array of controller actions not to
     #                          display this action item on.
-    def action_item(name = nil, options = {}, &block)
-      if name.is_a?(Hash)
-        options = name
-        name = nil
-      end
-
-      Deprecation.warn "using `action_item` without a name is deprecated! Use `action_item(:edit)`." unless name
-
+    def action_item(name, options = {}, &block)
       config.add_action_item(name, options, &block)
     end
 

data/lib/active_admin/dynamic_setting.rb

@@ -0,0 +1,38 @@
+module ActiveAdmin
+
+  class DynamicSetting
+    def self.build(setting, type)
+      (type ? klass(type) : self).new(setting)
+    end
+
+    def self.klass(type)
+      klass = "#{type.to_s.camelcase}Setting"
+      raise ArgumentError, "Unknown type: #{type}" unless ActiveAdmin.const_defined?(klass)
+      ActiveAdmin.const_get(klass)
+    end
+
+    def initialize(setting)
+      @setting = setting
+    end
+
+    def value(*_args)
+      @setting
+    end
+  end
+
+  # Many configuration options (Ex: site_title, title_image) could either be
+  # static (String), methods (Symbol) or procs (Proc). This wrapper takes care of
+  # returning the content when String or using instance_eval when Symbol or Proc.
+  #
+  class StringSymbolOrProcSetting < DynamicSetting
+    def value(context = self)
+      case @setting
+      when Symbol, Proc
+        context.instance_eval(&@setting)
+      else
+        @setting
+      end
+    end
+  end
+
+end

data/lib/active_admin/dynamic_settings_node.rb

@@ -0,0 +1,28 @@
+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,5 +1,10 @@
 module ActiveAdmin
   class Engine < ::Rails::Engine
+    initializer "active_admin.load_app_path" 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

data/lib/active_admin/error.rb

@@ -6,7 +6,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 +24,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
 

data/lib/active_admin/filters/active_filter.rb

@@ -19,20 +19,23 @@ module ActiveAdmin
       def values
         condition_values = condition.values.map(&:value)
         if related_class
-          related_class.find(condition_values)
+          related_class.where(related_primary_key => condition_values)
         else
           condition_values
         end
       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 related_class
-          "#{related_class.model_name.human} #{translated_predicate}".strip
+        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}"
         else
-          "#{attribute_name} #{translated_predicate}".strip
-        end
+          "#{attribute_name} #{translated_predicate}"
+        end.strip
       end
 
       def predicate_name
@@ -54,6 +57,18 @@ module ActiveAdmin
         resource_class.human_attribute_name(name)
       end
 
+      def related_class_name
+        return unless related_class
+
+        related_class.model_name.human
+      end
+
+      def filter_label
+        return unless filter
+
+        filter[:label] || I18n.t(name, scope: ['formtastic', 'labels'], default: nil)
+      end
+
       #@return Ransack::Nodes::Attribute
       def condition_attribute
         condition.attributes[0]
@@ -75,13 +90,35 @@ module ActiveAdmin
       def find_class
         if condition_attribute.klass != resource_class && condition_attribute.klass.primary_key == name.to_s
           condition_attribute.klass
-        else
-          assoc = condition_attribute.klass.reflect_on_all_associations.
-            reject { |r| r.options[:polymorphic] }. #skip polymorphic
-            detect { |r| r.foreign_key.to_s == name.to_s }
-          assoc.class_name.constantize if assoc
+        elsif predicate_association
+          predicate_association.klass
+        end
+      end
+
+      def filter
+        resource.filters[name.to_sym]
+      end
+
+      def related_primary_key
+        if predicate_association
+          predicate_association.association_primary_key
+        elsif related_class
+          related_class.primary_key
         end
       end
+
+      def predicate_association
+        @predicate_association = find_predicate_association unless defined?(@predicate_association)
+        @predicate_association
+      end
+
+      private
+
+      def find_predicate_association
+        condition_attribute.klass.reflect_on_all_associations.
+          reject { |r| r.options[:polymorphic] }. #skip polymorphic
+          detect { |r| r.foreign_key.to_s == name.to_s }
+      end
     end
   end
 end

data/lib/active_admin/filters/active_sidebar.rb

@@ -5,7 +5,7 @@ module ActiveAdmin
     class ActiveSidebar < ActiveAdmin::SidebarSection
 
       def initialize
-        super I18n.t("active_admin.search_status.headline"), sidebar_options
+        super 'search_status', sidebar_options
       end
 
       def block
@@ -28,7 +28,7 @@ module ActiveAdmin
                         text_node filter.label
                       end
                       b do
-                        text_node filter.values.map { |v| pretty_format(v) }.to_sentence.html_safe
+                        text_node to_sentence(filter.values.map { |v| pretty_format(v) })
                       end
                     end
                   end
@@ -39,6 +39,10 @@ module ActiveAdmin
         end
       end
 
+      def title
+        I18n.t("active_admin.search_status.headline")
+      end
+
       protected
 
       def sidebar_options

data/lib/active_admin/filters/forms.rb

@@ -48,8 +48,8 @@ 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)
 
@@ -57,8 +57,11 @@ module ActiveAdmin
           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)
+
+            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

data/lib/active_admin/filters/formtastic_addons.rb

@@ -37,7 +37,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
 

data/lib/active_admin/filters/resource_extension.rb

@@ -83,7 +83,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,24 +123,48 @@ 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
+        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